|
|
|
| R2012a Documentation → Simulink | |
Learn more about Simulink |
|
| Contents | Index |
• Running a Simulation Programmatically
• Visualizing and Comparing Simulation Results
• Analyzing Simulation Results
• Improving Simulation Performance and Accuracy
• Using the Debugger's Graphical User Interface
• Using the Debugger's Command-Line Interface
• Starting the Simulink Debugger
• Running a Simulation Step by Step
Structural Changes That Cause Rebuilds
Determining If the Simulation Will Rebuild
Selecting Blocks for Rapid Accelerator Mode
Controlling S-Function Execution
Accelerator and Rapid Accelerator Mode Data Type Considerations
Behavior of Scopes and Viewers with Rapid Accelerator Mode
Factors Inhibiting Acceleration
Running Acceleration Mode from the User Interface
Building Accelerator Mode MEX-files
Customizing the Acceleration Build Process
Adding Blocks by Browsing or Searching with the Library Browser
Adding Blocks Programmatically
Copying and Moving Blocks from One Window to Another
Creating Block Annotations Programmatically
Displaying Parameters Beneath a Block
Setting Port Value Data Tip Options
Controlling the Port Value Display
Displayed Value When No Data Is Available
Port Value Display Limitations
How Simulink Determines the Sorted Order
Listening for Method Execution Events
Synchronizing Run-Time Objects and Simulink Execution
Using Workspace Variables in Parameter Expressions
Resolving Variable References in Block Parameter Expressions
Using Parameter Objects to Specify Parameter Values
Determining Parameter Data Types
Blocks That Perform Parameter Range Checking
Specifying Ranges for Parameters
Performing Parameter Range Checking
Specifying Some Parameters as Noninline
Referencing Structure Parameters
Parameter Structure Limitations
Data Set Numeric and Data Types
Summary of Lookup Table Block Features
Entering Data in the Lookup Table Editor
Entering Data Using Inports of the Lookup Table Dynamic Block
Monotonicity of Breakpoint Data Sets
Representation of Discontinuities in Lookup Tables
Formulation of Evenly Spaced Breakpoints
Example Output for Lookup Methods
Layout of the Lookup Table Editor
Working with Table Data of Standard Format
Working with Table Data of Nonstandard Format
Importing Data from an Excel Spreadsheet
Adding and Removing Rows and Columns in a Table
Displaying N-Dimensional Tables in the Editor
Editing Custom Lookup Table Blocks
Optimize Breakpoint Spacing in Lookup Tables
Compatibility of Models with Older Versions of Lookup Table Blocks
What to Expect from the Model Advisor Check
Masking a Block for Inclusion in a User Library
Masking a Block that Resides in a User Library
Masking a Block Copied from a User Library
Promoting Block Parameters to the Mask
Creating a Simplified Custom Interface for a Built-In Block
Creating a Simplified Custom Interface for Multiple Parameters in a Subsystem
Rules for Promoting Parameters
Predefined Masked Dialog Box Parameters
Notes on Mask Parameter Storage
Setting Masked Block Dialog Box Parameters
Setting Nested Masked Block Parameters
Creating Self-Modifying Masks for Library Blocks
Initialization Command Execution
Mask Parameters Dialog Box Callback Code Execution
Speed and Code Generation Requirements
Defining Custom Block Behavior
Deciding on a Custom Block Type
Placing Custom Blocks in a Library
Adding a Graphical User Interface to a Custom Block
Adding Block Functionality Using Block Callbacks
Creating Custom Blocks from MATLAB Functions
Creating Custom Blocks from S-Functions
Finding a Linked Block's Prototype
Finding Linked Blocks in a Model
Locking Links to Blocks in a Library
Disabling Links to Library Blocks
Restoring Disabled or Parameterized Links
Checking and Setting Link Status Programmatically
Breaking a Link to a Library Block
Fixing Unresolved Library Links
Modifying and Locking Libraries
Making Backward-Compatible Changes to Libraries
Example of a Minimal slblocks.m File
Adding More Descriptive Information in slblocks.m
Why Use MATLAB Function Blocks?
Programming the MATLAB Function Block
Building the Function and Checking for Errors
Enabling and Disabling Debugging
Debugging the Function in Simulation
Watching Function Variables During Simulation
Checking for Data Range Violations
MATLAB Function Block Editor Tools
Editing and Debugging MATLAB Function Block Code
Location of MATLAB Function Reports
Opening MATLAB Function Reports
Description of MATLAB Function Reports
Viewing Your MATLAB Function Code
Viewing Call Stack Information
Viewing the Compilation Summary Information
Viewing Error and Warning Messages
Viewing Variables in Your MATLAB Code
Keyboard Shortcuts for the MATLAB Function Report
Inheriting Argument Data Types
Built-In Data Types for Arguments
Specifying Argument Types with Expressions
Specifying Simulink Fixed Point Data Properties
Inheriting Argument Sizes from Simulink
Specifying Argument Sizes with Expressions
Eliminating Warnings for Implicit Signal Resolution in the Model
Disabling Implicit Signal Resolution for a MATLAB Function Block
Forcing Explicit Signal Resolution for an Output Data Signal
Example of Structures in a MATLAB Function Block
How Structure Inputs and Outputs Interface with Bus Signals
Rules for Defining Structures in MATLAB Function Blocks
Workflow for Creating Structures in MATLAB Function Blocks
Indexing Substructures and Fields
Assigning Values to Structures and Fields
Working with Structure Parameters in MATLAB Function Blocks
Limitations of Structures and Buses in MATLAB Function Blocks
How MATLAB Function Blocks Implement Variable-Size Data
Enabling Support for Variable-Size Data
Declaring Variable-Size Inputs and Outputs
Declaring Variable-Size Data Locally
Simple Example: Defining and Using Variable-Size Data in MATLAB Function Blocks
Simple Example: Defining and Using Enumerated Types in MATLAB Function Blocks
Using Enumerated Data in MATLAB Function Blocks
How to Define Enumerated Data Types for MATLAB Function Blocks
How to Add Enumerated Data to MATLAB Function Blocks
How to Instantiate Enumerated Data in MATLAB Function Blocks
Limitations of Enumerated Types
Using Global Data with the MATLAB Function Block
Choosing How to Store Global Data
How to Use Data Store Memory Blocks
How to Use Simulink.Signal Objects
Using Data Store Diagnostics to Detect Memory Access Issues
Limitations of Using Shared Data in MATLAB Function Blocks
Supported Types for Frame-Based Data
Adding Frame-Based Data in MATLAB Function Blocks
Examples of Frame-Based Signals in MATLAB Function Blocks
How to Create Custom MATLAB Function Block Libraries
Example: Creating a Custom Signal Processing Filter Block Library
Code Reuse with Library Blocks
Debugging MATLAB Function Library Blocks
Properties You Can Specialize Across Instances of Library Blocks
Basic Workflow for Using Traceability
Tutorial: Using Traceability in a MATLAB Function Block
Location of Comments in Generated Code
Including MATLAB Function Help Text in the Function Banner
Limitations of MATLAB Source Code as Comments
Converting If-Elseif-Else Code to Switch-Case Statements
Example of Converting Code for If-Elseif-Else Decision Logic to Switch-Case Statements
When to Disable BLAS Library Support
How to Disable BLAS Library Support
When to Disable Run-Time Checks
How to Disable Run-Time Checks
Data Types Supported by Simulink
Block Support for Data and Numeric Signal Types
Creating Signals of a Specific Data Type
Specifying Block Output Data Types
Validating a Floating-Point Embedded Model
Tutorial: Validating a Single-Precision Model
Using the Model Explorer to Create Data Objects
Saving and Loading Data Objects
Using Data Objects in Simulink Models
Creating Persistent Data Objects
Disadvantages of Level-1 Data Class Infrastructure
Features of Level-2 Data Class Infrastructure
Other Differences between Level-1 and Level-2 Data Classes
Enabling Custom Storage Classes
Valid Values for Design Minimum and Maximum
Creating a Simulink Enumeration Class
Customizing a Simulink Enumeration
Saving an Enumeration in a MATLAB File
Changing and Reloading Enumerations
Importing Enumerations Defined Externally to MATLAB
Specifying Enumerations as Data Types
Getting Information About Enumerations
Enumerated Values in Computation
Enumerated Types for Switch Blocks
Approaches for Exporting Signal Data
Enabling Simulation Data Export
Viewing Logged Simulation Data With the Simulation Data Inspector
Data Format for Model-Based Exported Data
Producing Specified Output Only
Limiting the Data Logged for a Signal
Using the Model Editor to View the Signal Logging Configuration
Using the Signal Logging Selector to View the Signal Logging Configuration
Using the Model Explorer to View the Signal Logging Configuration
Specifying the Signal Logging Data Format
Specifying a Name for the Signal Logging Data
Two Interfaces for Overriding Signal Logging Settings
Scope of Signal Logging Setting Overrides
Command-Line Interface for Overriding Signal Logging Settings
Viewing Logged Signal Data with the Simulation Data Inspector
Programmatically Accessing Logged Signal Data Saved in Dataset Format
Programmatically Accessing Logged Signal Data Saved in ModelDataLogs Format
Guidelines for Specifying Time and Signal Values for Imported Data
Example of Importing Data to Model a Continuous Plant
Example of Importing Data to Test a Discrete Algorithm
Using a From Workspace Block to Import an Input Test Case
Using a Signal Builder Block to Import an Input Test Case
Models with Multiple Root Inport Blocks
When to Use a Structure of MATLAB timeseries Objects Instead of a Simulink.TsArray Object
How to Use a Structure of MATLAB timeseries Objects to Import Bus Signals
Specifying the Input Expression
One Structure for All Ports or a Structure for Each Port
Examples of Specifying Signal and Time Data
Importing and Exporting State Information for Referenced Models
Workflow for Configuring Data Stores
Using Data Stores with Buses and Arrays of Buses
Specifying Data Store Memory Block Attributes
Specifying Signal Object Data Store Attributes
Accessing Specific Bus and Matrix Elements
Supported Data Types, Dimensions, and Complexity for Logging Data Stores
Data Store Logging Limitations
Logging Data Stores Created with a Data Store Memory Block
Logging Icon for the Data Store Memory Block
Logging Data Stores Created with a Simulink.Signal Object
Accessing Data Store Logging Data
Ordering Access Using Function Call Subsystems
Ordering Access Using Block Priorities
Detecting Multitasking Access Errors
Signal Dimensions, Size, and Width
Displaying Signal Values in Model Diagrams
Propagated Signal Label Format
Blocks That Support Signal Label Propagation
Display Propagated Signal Labels
How Simulink Propagates Signal Labels
Simulink Blocks that Support Multidimensional Signals
Determining the Output Dimensions of Source Blocks
Determining the Output Dimensions of Nonsource Blocks
Signal and Parameter Dimension Rules
Scalar Expansion of Inputs and Parameters
Highlighting Signal Destinations
Resolving Incomplete Highlighting to Library Blocks
Blocks That Allow Signal Range Specification
Checking for Signal Range Errors
Using Block Parameters to Initialize Signals and Discrete States
Using Signal Objects to Initialize Signals and Discrete States
Using Signal Objects to Tune Initial Values
Example: Using a Signal Object to Initialize a Subsystem Output
Initialization Behavior Summary for Signal Objects
Designating a Signal as a Test Point
Displaying Test Point Indicators
Printing, Exporting, and Copying Waveforms
Associating Bus Objects with Simulink Blocks
Writing a Bus Object Import Function
Writing a Bus Object Export Function
Connecting Buses to Root Level Outports
Connecting Buses to Nonvirtual Inports
Connecting Buses to Model, Stateflow, and MATLAB Function Blocks
Connecting Multi-Rate Buses to Referenced Models
Creating Initial Condition (IC) Structures
Three Ways to Initialize Bus Signals Using Block Parameters
Setting Diagnostics to Support Bus Signal Initialization
Blocks That Support Arrays of Buses
Using an Array of Buses in a Model
Generated Code for an Array of Buses
Converting a Model to Use an Array of Buses
Using Diagnostics for Mux/Bus Mixtures
Using the Model Advisor for Mux/Bus Mixtures
Correcting Buses Used as Muxes
Bus to Vector Block Compatibility Issues
Avoiding Mux/Bus Mixtures When Developing Models
Creating Variable-Size Signals
How Variable-Size Signals Propagate
Subsystem Initialization of Variable-Size Signals
Demo of Variable-Size Signal Length Adaptation
Demo of Mode-Dependent Variable-Size Signals
Demo of C S-Function with Variable-Size Signals
• Customizing Simulink Environment and Printed Models
About Adding Items to the Model Editor Menus
Registering Menu Customizations
Debugging Custom Menu Callbacks
About Disabling and Hiding Model Editor Menu Items
Example: Disabling the New Model Command on the Simulink Editor's File Menu
About Disabling and Hiding Controls
Example: Disabling a Button on a Simulink Dialog Box
Writing Control Customization Callback Functions
Registering Control Customization Callback Functions
Disabling and Hiding Libraries
Customizing the Library Browser's Menu
Starting the PrintFrame Editor
Getting Help for the PrintFrame Editor
Variable and Static Information
Single Use or Multiple Use Print Frames
• Running Models on Target Hardware
Passing Parameters to S-Functions
Mathematics of Simulink Blocks
Setting Sample Times and Offsets
Level-2 MATLAB S-Function Examples
Level-1 MATLAB S-Function Examples
Using a Hand-Written S-Function to Incorporate Legacy Code
Using the S-Function Builder to Incorporate Legacy Code
Using the Legacy Code Tool to Incorporate Legacy Code
Level-2 MATLAB S-Function Template
Level-2 MATLAB S-Function Callback Methods
Example of Writing a Level-2 MATLAB S-Function
Instantiating a Level-2 MATLAB S-Function
Operations for Variable-Size Signals
Generating Code from a Level-2 MATLAB S-Function
Level-1 MATLAB S-Function Arguments
Level-1 MATLAB S-Function Outputs
Defining S-Function Block Characteristics
Processing S-Function Parameters
Converting Level-1 MATLAB S-Functions to Level-2
Deploying the Generated S-Function
How the S-Function Builder Builds an S-Function
Parameters/S-Function Name Pane
Example: Modeling a Two-Input/Two-Output System
Callback Method Implementations
Simulink/Simulink Coder Interfaces
S-Function Source File Requirements
Example of Integrating Existing C Functions into Simulink Models with the Legacy Code Tool
Registering Legacy Code Tool Data Structures
Declaring Legacy Code Tool Function Specifications
Generating and Compiling the S-Functions
Generating a Masked S-Function Block for Calling a Generated S-Function
Forcing Simulink Accelerator Mode to Use S-Function TLC Inlining Code
Handling Multiple Registration Files
Deploying Generated S-Functions
Debugging C MEX S-Functions in the Simulink Environment
Debugging C MEX S-Functions Using Third-Party Software
Example of a Level-1 Fortran S-Function
Inline Code Generation Example
Example C MEX S-Function Calling Fortran Code
DWork Vectors and the Simulink Engine
DWork Vectors and the Simulink Coder Product
Using DWork Vectors in Level-2 MATLAB S-Functions
Using DWork Vectors With Legacy Code
Level-2 MATLAB S-Function DWork Vector
Elementary Work Vector Examples
Creating Input Ports for Level-2 MATLAB S-Functions
Creating Output Ports for C S-Functions
Creating Output Ports for Level-2 MATLAB S-Functions
Using Custom Data Types in Level-2 MATLAB S-Functions
Specifying Port-Based Sample Times
Hybrid Block-Based and Port-Based Sample Times
Multirate S-Functions and Sample Time Hit Calculations
Synchronizing Multirate S-Function Blocks
Specifying Model Reference Sample Time Inheritance
SimState Compliance Specification for C-MEX S-Functions
Using Frame-Based Signals in C S-Functions
Using Frame-Based Signals in Level-2 MATLAB S-Functions
ssSetErrorStatus Termination Criteria
• Blocks
You can start the debugger from either a Simulink model window or from the MATLAB Command Window.
| On this page… |
|---|
In a model window, select Tools > Simulink Debugger.
The debugger graphical user interface opens. See Using the Debugger's Graphical User Interface.
Continue selecting toolbar buttons.
Note When running the debugger in graphical user interface (GUI) mode, you must explicitly start the simulation. For more information, seeStarting a Simulation. |
In the MATLAB Command Window, enter either
the sim command. For example, enter
sim('vdp', 'StopTime', '10', 'debug', 'on')or the sldebug command. For example, enter
sldebug 'vdp'
In both cases, the demo model vdp loads into memory, starts the simulation, and stops the simulation at the first block in the model execution list.
Continue entering debugger commands.
 | Getting Online Help | Starting a Simulation |  |
Learn more about Simulink through this collection of videos, articles, technical literature and the Getting Started with Simulink Guide.
| © 1984-2012- The MathWorks, Inc. - Site Help - Patents - Trademarks - Privacy Policy - Preventing Piracy - RSS |
