Simulink - Documentation

Contents

Index

• Getting Started

• Simulink Basics

Starting Simulink Software

• Opening a Model

Opening an Existing Model

Opening Models with Different Character Encodings

Avoiding Initial Model Open Delay

Loading a Model

• Saving a Model

How to Tell If a Model Needs Saving

Techniques for Saving Models

Saving Models with Different Character Encodings

Saving a Model in an Earlier Simulink Version

Saving from One Earlier Simulink Version to Another

• Using the Model Editor

Editor Overview

Undoing a Command

Zooming Block Diagrams

Panning Block Diagrams

Viewing Command History

Bringing the MATLAB Software Desktop Forward

Copying Models to Third-Party Applications

Updating a Block Diagram

• Printing a Block Diagram

Print Dialog Box

Specifying Paper Size and Orientation

Positioning and Sizing a Diagram

Print Sample Time Legend

• Generating a Model Report

Model Report Options

Ending a Simulink Session

• Summary of Mouse and Keyboard Actions

Model Viewing Shortcuts

Block Editing Shortcuts

Line Editing Shortcuts

Signal Label Editing Shortcuts

Annotation Editing Shortcuts

• How Simulink Works

• Modeling Dynamic Systems

Block Diagram Semantics

Creating Models

Block Parameters

Tunable Parameters

Block Sample Times

Systems and Subsystems

• Simulating Dynamic Systems

Model Compilation

Simulation Loop Phase

Zero-Crossing Detection

Algebraic Loops

• Working with Sample Times

What Is Sample Time?

• How to Specify the Sample Time

Designating Sample Times

Specifying Block-Based Sample Times Interactively

Specifying Port-Based Sample Times Interactively

Specifying Block-Based Sample Times Programmatically

Specifying Port-Based Sample Times Programmatically

Accessing Sample Time Information Programmatically

Specifying Sample Times for a Custom Block

Determining Sample Time Units

Changing the Sample Time After Simulation Start Time

• How to View Sample Time Information

Viewing Sample Time Display

Managing the Sample Time Legend

How to Print Sample Time Information

• Types of Sample Time

Discrete Sample Time

Continuous Sample Time

Fixed in Minor Step

Inherited Sample Time

Constant Sample Time

Variable Sample Time

Triggered Sample Time

Asynchronous Sample Time

Determining the Compiled Sample Time of a Block

Managing Sample Times in Subsystems

• Managing Sample Times in Systems

Purely Discrete Systems

Resolving Rate Transitions

• How Propagation Affects Inherited Sample Times

Process for Sample Time Propagation

Simulink Rules for Assigning Sample Times

Monitoring Backpropagation in Sample Times

• Creating a Model

• Creating an Empty Model

Creating a Model Template

• Populating a Model

About the Library Browser

Opening the Library Browser

Browsing Block Libraries

Searching Block Libraries

Cloning Blocks to Models

• Selecting Objects

Selecting an Object

Selecting Multiple Objects

• Specifying Block Diagram Colors

How to Specify Block Diagram Colors

Choosing a Custom Color

Defining a Custom Color

Specifying Colors Programmatically

Displaying Sample Time Colors

• Connecting Blocks

Automatically Connecting Blocks

Manually Connecting Blocks

Disconnecting Blocks

Aligning, Distributing, and Resizing Groups of Blocks Automatically

• Annotating Diagrams

How to Annotate Diagrams

Annotations Properties Dialog Box

Annotation Callback Functions

Associating Click Functions with Annotations

Annotations API

Using TeX Formatting Commands in Annotations

Creating Annotations Programmatically

• Creating Subsystems

Why Subsystems are Advantageous

Creating a Subsystem by Adding the Subsystem Block

Creating a Subsystem by Grouping Existing Blocks

Model Navigation Commands

Labeling Subsystem Ports

Controlling Access to Subsystems

Interconverting Subsystems and Block Diagrams

Emptying Subsystems and Block Diagrams

• Modeling Control Flow Logic

Equivalent C Language Statements

Modeling Conditional Control Flow Logic

Modeling While and For Loops

• Using Callback Functions

About Callback Functions

Tracing Callbacks

Creating Model Callback Functions

Creating Block Callback Functions

Port Callback Parameters

Example Callback Function Tasks

• Using Model Workspaces

About Model Workspaces

Simulink.ModelWorkspace Data Object Class

Changing Model Workspace Data

Model Workspace Dialog Box

• Resolving Symbols

About Symbol Resolution

Hierarchical Symbol Resolution

Specifying Numeric Values with Symbols

Specifying Other Values with Symbols

Limiting Signal Resolution

Explicit and Implicit Symbol Resolution

Programmatic Symbol Resolution

• Consulting the Model Advisor

About the Model Advisor

Starting the Model Advisor

Overview of the Model Advisor Window

Running Model Advisor Checks

Fixing a Warning or Failure

Reverting Changes Using Restore Points

Viewing and Saving Model Advisor Reports

Running the Model Advisor Programmatically

• Managing Model Versions

How Simulink Helps You Manage Model Versions

Model File Change Notification

Specifying the Current User

Model Properties Dialog Box

Creating a Model Change History

Version Control Properties

• Model Discretizer

What Is the Model Discretizer?

How to Discretize a Model from the Model Discretizer GUI

Viewing the Discretized Model

How to Discretize Blocks from the Simulink Model

How to Discretize a Model from the MATLAB Command Window

• Creating Conditional Subsystems

About Conditional Subsystems

• Enabled Subsystems

What Are Enabled Subsystems?

Creating an Enabled Subsystem

Blocks an Enabled Subsystem Can Contain

Using Blocks with Constant Sample Times in Enabled Subsystems

• Triggered Subsystems

What Are Triggered Subsystems?

Creating a Triggered Subsystem

Blocks That a Triggered Subsystem Can Contain

• Triggered and Enabled Subsystems

What Are Triggered and Enabled Subsystems?

Creating a Triggered and Enabled Subsystem

A Sample Triggered and Enabled Subsystem

Creating Alternately Executing Subsystems

Function-Call Subsystems

• Conditional Execution Behavior

What Is Conditional Execution Behavior?

Propagating Execution Contexts

Behavior for Switch Blocks

Displaying Execution Contexts

Disabling Conditional Execution Behavior

Displaying Execution Context Bars

• Referencing a Model

• Overview of Model Referencing

About Model Referencing

Referenced Model Advantages

Model Referencing Demos

Model Referencing Resources

Creating a Model Reference

Converting a Subsystem to a Referenced Model

• Referenced Model Simulation Modes

About Referenced Model Simulation Modes

Specifying the Simulation Mode

Mixing Simulation Modes

Accelerating a Freestanding or Top Model

• Viewing a Model Reference Hierarchy

Displaying Version Numbers

• Model Reference Simulation Targets

About Simulation Targets

Building Simulation Targets

• Simulink Model Referencing Requirements

About Model Referencing Requirements

Name Length Requirement

Configuration Parameter Requirements

Model Structure Requirements

• Parameterizing Model References

Global Nontunable Parameters

Global Tunable Parameters

Using Model Arguments

• Defining Function-Call Models

About Function-Call Models

Function-Call Model Demo

Creating a Function-Call Model

Referencing a Function-Call Model

Function-Call Model Requirements

• Using Model Reference Variants

Adapting Models to Different Contexts

About Model Reference Variants

Model Reference Variant Components

Model Reference Variant Example

Model Reference Variant Requirements

Implementing Model Reference Variants

Saving Variant Referenced Models

Changing Variant Model Definitions

Parameterizing Variant Models

Reusing Variant Objects and Models

Overriding Variant Conditions

Variant Models and Enumerated Types

Generating Code for Variant Models

Model Reference Variant Limitations

• Protecting Referenced Models

About Protected Models

The Model Protection Facility

Model Protection Requirements

Protecting a Referenced Model

Packaging a Protected Model

Testing a Protected Model

Using a Protected Model

Model Protection Limitations

• Inheriting Sample Times

Blocks That Depend on Absolute Time

Blocks Whose Outputs Depend on Inherited Sample Time

Refreshing Model Blocks

• Simulink Model Referencing Limitations

Limitations on All Model Referencing

Limitations on Normal Mode Referenced Models

Limitations on Accelerator Mode Referenced Models

Limitations on PIL Mode Referenced Models

• Working with Blocks

• About Blocks

What Are Blocks?

Block Data Tips

• Adding Blocks

Ways to Add Blocks

Adding Blocks by Browsing or Searching with the Library Browser

Copying Blocks from a Model

Adding Frequently Used Blocks

Adding Blocks Programmatically

• Editing Blocks

Copying and Moving Blocks from One Window to Another

Moving Blocks in a Model

Copying Blocks in a Model

Deleting Blocks

• Working with Block Parameters

About Block Parameters

Mathematical Versus Configuration Parameters

Setting Block Parameters

Specifying Numeric Parameter Values

Checking Parameter Values

Changing the Values of Block Parameters During Simulation

Inlining Parameters

Block Properties Dialog Box

State Attributes Pane of Block Parameters Dialog Box

• Changing a Block's Appearance

Changing a Block's Orientation

Resizing a Block

Displaying Parameters Beneath a Block

Using Drop Shadows

Manipulating Block Names

Specifying a Block's Color

• Displaying Block Outputs

Block Output Data Tips

Setting Block Output Data Tip Options

Enabling Block Output Display

Controlling the Block Output Display

Port Value Display Limitations

• Controlling and Displaying the Sorted Order

What Is Sorted Order?

Displaying the Sorted Order

Sorted Order Notation

How Simulink Determines the Sorted Order

Assigning Block Priorities

Rules for Priorities

• Accessing Block Data During Simulation

About Block Run-Time Objects

Accessing a Run-Time Object

Listening for Method Execution Events

Synchronizing Run-Time Objects and Simulink Execution

• Working with Block Libraries

About Block Libraries

• Working with Reference Blocks

About Reference Blocks

Creating a Reference Block

Updating a Reference Block

Modifying Reference Blocks

Finding a Reference Block's Library Block Prototype

Getting Information About Library Blocks Referenced by a Model

• Working with Library Links

Displaying Library Links

Disabling Links to Library Blocks

Restoring Disabled or Parameterized Links

Determining Link Status

Breaking a Link to a Library Block

Fixing Unresolved Library Links

• Creating Block Libraries

Creating a Library

Creating a Sublibrary

Modifying a Library

Locking Libraries

Making Backward-Compatible Changes to Libraries

• Adding Libraries to the Library Browser

How to Display a Library in the Library Browser

Example of a Minimal slblocks.m File

Adding More Descriptive Information in slblocks.m

• Working with Block Masks

What Are Masks?

Why Use a Mask?

Masked Subsystem Example

Roadmap for Masking Blocks

Mask Terminology

• Creating a Block Mask

Opening the Mask Editor

Defining a Mask Icon

Understanding Mask Parameters

Defining Mask Parameters

Defining Mask Documentation

Using a Block Mask

Masking a Model Block

• Masks on Blocks in User Libraries

About Masks and User-Defined Libraries

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

• Operating on Existing Masks

Changing a Block Mask

Viewing Mask Parameters

Looking Under a Block Mask

Removing and Caching a Mask

Restoring a Cached Mask

Permanently Deleting a Mask

Roadmap for Dynamic Masks

Calculating Values Used Under the Mask

• Controlling Masks Programmatically

Predefined Masked Dialog Parameters

Notes on Mask Parameter Storage

• Understanding Mask Code Execution

Specifying Mask Initialization

Mask Initialization Code

Debugging Masks that Use M-Code

• Creating Dynamic Mask Dialog Boxes

Setting Nested Masked Block Parameters

About Dynamic Masked Dialog Boxes

Enable parameter

Setting Masked Block Dialog Parameters

• Creating Dynamic Masked Subsystems

Allow library block to modify its contents

Creating Self-Modifying Masks for Library Blocks

Best Practices for Using M-Code in Masks

• Working with Signals

• Signal Basics

Creating Signals

Displaying Signal Values

Signal Line Styles

Signal Data Types

Signal Dimensions

Complex Signals

Virtual Signals

Control Signals

Composite Signals

Signal Glossary

Validating Signal Connections

• Displaying Signal Sources and Destinations

About Signal Highlighting

Highlighting Signal Sources

Highlighting Signal Destinations

Removing Highlighting

Resolving Incomplete Highlighting to Library Blocks

• Determining Output Signal Dimensions

About Signal Dimensions

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

• Checking Signal Ranges

About Signal Range Checking

Blocks That Allow Signal Range Specification

Specifying Ranges for Signals

Checking for Signal Range Errors

• Introducing the Signal and Scope Manager

What is the Signal & Scope Manager?

Displaying the Signal and Scope Manager User Interface

Understanding the Signal and Scope Manager User Interface

• Using the Signal and Scope Manager

Attaching a New Viewer or Generator

Creating a Multiple Axes Viewer

Adding Additional Signals to an Existing Viewer

Viewing Test Point Data

Adding Custom Viewers and Generators

• The Signal Selector

About the Signal Selector

Port/Axis Selector

Model Hierarchy

Inputs/Signals List

• Initializing Signals and Discrete States

About Initialization

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

• Working with Test Points

About Test Points

Designating a Signal as a Test Point

Displaying Test Point Indicators

• Displaying Signal Properties

Port/Signal Displays Menu

Port Data Types

Signal Dimensions

Signal Resolution Indicators

Wide Nonscalar Lines

• Working with Signal Groups

About the Signal Groups

Creating a Signal Group Set

Signal Builder Dialog Box

Editing Signal Groups

Editing Signals

Editing Waveforms

Signal Builder Time Range

Exporting Signal Group Data

Printing, Exporting, and Copying Waveforms

Simulating with Signal Groups

Simulation Options Dialog Box

• Working with Variable-Size Signals

• Variable-Size Signal Basics

About Variable-Size Signals

Creating Variable-Size Signals

How Variable-Size Signals Propagate

Subsystem Initialization of Variable-Size Signals

• Simulink Models Using Variable-Size Signals

Demo of Variable-Size Signal Generation and Operations

Demo of Variable-Size Signal Length Adaptation

Demo of Mode-Dependent Variable-Size Signals

• S-Functions Using Variable-Size Signals

Demo of Level-2 M-File S-Function with Variable-Size Signals

Demo of C-File S-Function with Variable-Size Signals

• Simulink Block Support for Variable-Size Signals

Logic and Bit Operations

Math Operations

Subsystem Blocks

Conditionally Executed Subsystem Blocks

Signal Attributes

Switching Blocks

User-Defined Function Blocks

Signal Processing Blockset

Video and Image Processing Blockset

Variable-Size Signal Limitations

• Using Composite Signals

• About Composite Signals

Composite Signal Terminology

Types of Simulink Buses

Buses and Muxes

Creating and Accessing a Bus

• Nesting Buses

Circular Bus Definitions

Bus-Capable Blocks

• Using Bus Objects

About Bus Objects

Bus Object Capabilities

Associating Bus Objects with Simulink Blocks

• Using the Bus Editor

Opening the Bus Editor

Displaying Bus Objects

Creating Bus Objects

Creating Bus Elements

Nesting Bus Definitions

Changing Bus Entities

Exporting Bus Objects

Importing Bus Objects

Closing the Bus Editor

• Filtering Displayed Bus Objects

Filtering by Name

Filtering by Relationship

Changing Filtered Objects

Clearing the Filter

• Customizing Bus Object Import and Export

Prerequisites for Customization

Writing a Bus Object Import Function

Writing a Bus Object Export Function

Viewing the Customization Manager

Registering Customizations

Changing Customizations

Using the Bus Object API

• Virtual and Nonvirtual Buses

Creating Nonvirtual Buses

Nonvirtual Bus Sample Times

Automatic Bus Conversion

• Connecting Buses to Inports and Outports

Connecting Buses to Root Level Inports

Connecting Buses to Root Level Outports

Connecting Buses to Nonvirtual Inports

Connecting Buses to Model, Stateflow, and Embedded MATLAB Blocks

Connecting Multi-Rate Buses to Referenced Models

Buses and Libraries

• Avoiding Mux/Bus Mixtures

Using Diagnostics for Mux/Bus Mixtures

Using the Model Advisor for Mux/Bus Mixtures

Correcting Buses Used as Muxes

Bus to Vector Block Backward Compatibility

Avoiding Mux/Bus Mixtures When Developing Models

Buses in Generated Code

Composite Signal Limitations

• Working with Data

• Working with Data Types

About Data Types

Data Types Supported by Simulink

Fixed-Point Data

Enumerated Data

Block Support for Data and Numeric Signal Types

Creating Signals of a Specific Data Type

Specifying Block Output Data Types

Using the Data Type Assistant

Displaying Port Data Types

Data Type Propagation

Data Typing Rules

Typecasting Signals

• Working with Data Objects

About Data Object Classes

About Data Object Methods

Using the Model Explorer to Create Data Objects

About Object Properties

Changing Object Properties

Handle Versus Value Classes

Comparing Data Objects

Saving and Loading Data Objects

Using Data Objects in Simulink Models

Creating Persistent Data Objects

Data Object Wizard

• Subclassing Simulink Data Classes

About Packages and Data Classes

Working with Packages

Working with Classes

Enumerated Property Types

Enabling Custom Storage Classes

Associating User Data with Blocks

• Using Enumerated Data

Enumerated Data in Simulink

Demos of Enumerated Data Types

• Defining an Enumerated Data Type

Workflow for Defining Enumerated Data

Creating a Class Definition File

Enumerated Class Definition Syntax

Enumerated Class Definition Example

Defining Enumerated Values

Overriding Default Methods (Optional)

Defining Additional Customizations

Saving the M-File on the MATLAB Path

Changing an Enumerated Data Type

• Using Enumerated Data in a Simulink Model

Simulating with Enumerated Types

Referencing an Enumerated Type

Instantiating an Enumerated Type

Displaying Enumerated Values

Enumerated Values in Computation

• Simulink Constructs that Support Enumerated Types

Logging Enumerated Data

Importing Enumerated Data

• Simulink Enumerated Type Limitations

Enumerated Types and Bus Initialization

Enumerated Types on Scopes

Enumerated Types for Switch Blocks

Nonsupport of Enumerated Types

• Importing and Exporting Data

• Logging Signals

About Signal Logging

Globally Enabling and Disabling Logging

Enabling Logging for a Signal

Displaying Logging Indicators

Specifying a Logging Name

Limiting the Data Logged for a Signal

Logging Virtual Signals

Logging Multidimensional Signals

Logging Composite Signals

Logging Referenced Model Signals

Viewing Logged Signal Data

Accessing Logged Signal Data

Handling Spaces and Newlines in Logged Names

Extracting Partial Data from a Running Simulation

Example: Logging Signal Data in the F14 Model

Signal Logging Limitations

• Importing Data from a Workspace

Enabling Data Import

Importing Time-Series Data

Importing Data Arrays

Using a MATLAB Time Expression to Import Data

Importing Data Structures

Specifying Time Vectors for Discrete Systems

• Exporting Data to the MATLAB Workspace

Enabling Data Export

• Importing and Exporting States

Saving Final States

Loading Initial States

Limiting Output

• Specifying Output Options

Refining Output

Producing Additional Output

Producing Specified Output Only

Comparing Output Options

• Working with Data Stores

• About Data Stores

When to Use a Data Store

Creating Data Stores

Accessing Data Stores

Workflow for Configuring Data Stores

• Defining Data Stores with Data Store Memory Blocks

Creating the Data Store

Specifying Data Store Memory Block Attributes

• Defining Data Stores with Signal Objects

Creating the Data Store

Local and Global Data Stores

Specifying Signal Object Data Store Attributes

Accessing Data Stores with Simulink Blocks

• Data Store Examples

Local Data Store Example

Global Data Store Example

• Ordering Data Store Access

About Data Store Access Order

Ordering Access Using Function Call Subsystems

Ordering Access Using Block Priorities

• Using Data Store Diagnostics

About Data Store Diagnostics

Detecting Access Order Errors

Detecting Multitasking Access Errors

Detecting Duplicate Name Errors

Data Store Diagnostics in the Model Advisor

Data Stores and Software Verification

• Working with Lookup Tables

About Lookup Table Blocks

Anatomy of a Lookup Table

Lookup Tables Block Library

• Guidelines for Choosing a Lookup Table

Data Set Dimensionality

Data Set Numeric and Data Types

Data Accuracy and Smoothness

Dynamics of Table Inputs

Efficiency of Performance

Summary of Lookup Table Block Features

• Entering Breakpoints and Table Data

Entering Data in a Block Parameter Dialog Box

Entering Data in the Lookup Table Editor

Entering Data Using the Lookup Table Dynamic Block's Inports

• Characteristics of Lookup Table Data

Sizes of Breakpoint Data Sets and Table Data

Monotonicity of Breakpoint Data Sets

Formulation of Evenly-Spaced Breakpoints

Representation of Discontinuities in Lookup Tables

• Methods for Estimating Missing Points

About Estimating Missing Points

Interpolation Methods

Extrapolation Methods

Rounding Methods

Example Output for Lookup Methods

• Lookup Table Editor

When to Use the Lookup Table Editor

Layout of the LUT Editor

Browsing LUT Blocks

Editing Table Values

Adding and Removing Rows and Columns in a Table

Displaying N-Dimensional Tables in the Editor

Plotting LUT Tables

Editing Custom LUT Blocks

Example of a Logarithm Lookup Table

Examples for Prelookup and Interpolation Blocks

Lookup Table Glossary

• Modeling with Simulink

• General Considerations when Building Simulink Models

Avoiding Invalid Loops

Model Building Tips

Modeling a Continuous System

• Best-Form Mathematical Models

Series RLC Example

Solving Series RLC Using Resistor Voltage

Solving Series RLC Using Inductor Voltage

Example: Converting Celsius to Fahrenheit

• Exploring, Searching, and Browsing Models

• Managing Configuration Sets

• Setting Up Configuration Sets

About Configuration Sets

Configuration Set Components

Displaying Configuration Sets

Activating a Configuration Set

Opening Configuration Sets

Copying, Deleting, and Moving Configuration Sets

Copying Configuration Set Components

Creating Configuration Sets

Setting Values in Configuration Sets

Configuration Set API

Model Configuration Dialog Box

Model Configuration Preferences Dialog Box

• Referencing Configuration Sets

Overview of Configuration References

Creating a Freestanding Configuration Set

Creating and Attaching a Configuration Reference

Obtaining a Configuration Reference Handle

Attaching a Configuration Reference to Other Models

Changing a Configuration Reference

Activating a Configuration Reference

Unresolved Configuration References

Getting Values from a Referenced Configuration Set

Changing Values in a Referenced Configuration Set

Replacing a Referenced Configuration Set

Building Models and Generating Code

Configuration Reference Limitations

Configuration References for Models with Older Simulation Target Settings

• Running Simulations

Simulation Basics

• Controlling Execution of a Simulation

Starting a Simulation

Pausing or Stopping a Simulation

Using Blocks to Stop or Pause a Simulation

Specifying a Simulation Start and Stop Time

• Choosing a Solver

What Is a Solver?

Choosing a Solver Type

Choosing a Fixed-Step Solver

Choosing a Variable-Step Solver

Interacting with a Running Simulation

• Saving and Restoring the Simulation State as the SimState

Overview of the SimState

How to Save the SimState

How to Restore the SimState

How to Change the States of a Block within the SimState

Using the SimState Interface Checksum Diagnostic

Limitations of the SimState

Using SimState within S-Functions

• Diagnosing Simulation Errors

Response to Run-Time Errors

Simulation Diagnostics Viewer

Creating Custom Simulation Error Messages

• Running a Simulation Programmatically

About Programmatic Simulation

• Using the sim Command

Single-Output Syntax for the sim Command

Examples of Implementing the sim Command

Calling sim from within parfor

• Using the set_param Command

Running a Simulation from an S-Function

• Running Parallel Simulations

Overview of Calling sim from within parfor

sim in parfor with Rapid Accelerator Mode

Workspace Access Issues

Resolving Workspace Access Issues

Data Concurrency Issues

Resolving Data Concurrency Issues

• Error Handling in Simulink Using MSLException

Error Reporting in a Simulink Application

The MSLExeption Class

Methods of the MSLException Class

Capturing Information about the Error

• Improving Simulation Performance and Accuracy

About Improving Performance and Accuracy

Speeding Up the Simulation

• Comparing Performance

Performance of the Simulation Modes

Measuring Performance

• Improving Acceleration Mode Performance

Improving Simulation Accuracy

• Visualizing Simulation Results

• About Scope Blocks, Viewers, Signal Logging, and Test Points

What Are Scope Blocks, Signal Viewers, Test Points and Data Logging?

How Scope Blocks and Signal Viewers Differ

Why Use Generators and Signal Viewers Instead of Source and Scope Blocks?

Methods for Attaching a Generator or Viewer

Displaying a Scope Viewer

• Things to Know When Using Viewers

How the Viewer Determines Trace Color Coding and Line Styles

How Scope Viewer Parameter Settings Can Affect Performance

• Changing Viewer Characteristics

The Scope Viewer Toolbar

Scope Viewer Parameters Dialog Box

Scope Viewer Context Menu

• Performing Common Viewer Tasks

Viewing Scope Viewer Help

Attaching a Scope Viewer

Adding Multiple Signals to a Scope Viewer

Adding a Legend

Zooming In On Graph Regions

Displaying Multiple Axes

How to Save Data to MATLAB Workspace

Saving the Viewer Data to a File

Plotting the Viewer Data

• Performing Common Generator Tasks

Attaching a Generator

Removing a Generator

• Analyzing Simulation Results

• Viewing Output Trajectories

Using the Scope Block

Using Return Variables

Using the To Workspace Block

• Linearizing Models

About Linearizing Models

Linearization with Referenced Models

Linearization Using the 'v5' Algorithm

Finding Steady-State Points

• Simulink Debugger

Introduction to the Debugger

• Using the Debugger's Graphical User Interface

Displaying the Graphical Interface

Breakpoints Pane

Simulation Loop Pane

Sorted List Pane

• Using the Debugger's Command-Line Interface

Controlling the Debugger

Accessing the MATLAB Workspace

Getting Online Help

Starting the Debugger

Starting a Simulation

• Running a Simulation Step by Step

Block Data Output

Stepping Commands

Continuing a Simulation

Running a Simulation Nonstop

• Setting Breakpoints

About Breakpoints

Setting Unconditional Breakpoints

Setting Conditional Breakpoints

• Displaying Information About the Simulation

Displaying Block I/O

Displaying Algebraic Loop Information

Displaying System States

Displaying Solver Information

• Displaying Information About the Model

Displaying a Models Sorted Lists

Displaying a Block

• Accelerating Models

What Is Acceleration?

• How the Acceleration Modes Work

Accelerator Mode

Rapid Accelerator Mode

• Code Regeneration in Accelerated Models

Structural Changes That Cause Rebuilds

Determining If the Simulation Will Rebuild

• Choosing a Simulation Mode

Comparing Modes

• Designing Your Model for Effective Acceleration

Selecting Blocks for Accelerator Mode

Selecting Blocks for Rapid Accelerator Mode

Controlling S-Function Execution

Accelerator and Rapid Accelerator Mode Data Type Considerations

Using Scopes and Viewers with Rapid Accelerator Mode

Factors Inhibiting Acceleration

• Performing Acceleration

Customizing the Build Process

Running Acceleration Mode from the User Interface

Making Run-Time Changes

• Interacting with the Acceleration Modes Programmatically

Why Interact Programmatically?

Building Accelerator Mode MEX-files

Controlling Simulation

Simulating Your Model

Customizing the Acceleration Build Process

• Using the Accelerator Mode with the Simulink Debugger

Advantages of Using Accelerator Mode with the Debugger

How to Run the Debugger

When to Switch Back to Normal Mode

• Capturing Performance Data

What Is the Profiler?

How the Profiler Works

Enabling the Profiler

How to Save Simulink Profiler Results

• Customizing the Simulink User Interface

• Adding Items to Model Editor Menus

About Adding Items to the Model Editor Menus

Defining Menu Items

Registering Menu Customizations

Callback Info Object

Debugging Custom Menu Callbacks

About Menu Tags

• Disabling and Hiding Model Editor Menu Items

About Disabling and Hiding Model Editor Menu Items

Example: Disabling the New Model Command on the Simulink Editor's File Menu

Creating a Filter Function

Registering a Filter Function

• Disabling and Hiding Dialog Box Controls

About Disabling and Hiding Controls

Example: Disabling a Button on a Simulink Dialog Box

Writing Control Customization Callback Functions

Dialog Box Methods

Dialog Box and Widget IDs

Registering Control Customization Callback Functions

• Customizing the Library Browser

Reordering Libraries

Disabling and Hiding Libraries

Customizing the Library Browser's Menu

• Registering Customizations

About Registering User Interface Customizations

Customization Manager

• Creating Custom Blocks

• Using the Embedded MATLAB Function Block

• Introduction to Embedded MATLAB Function Blocks

What Is an Embedded MATLAB Function Block?

Why Use Embedded MATLAB Function Blocks?

• Creating an Example Embedded MATLAB Function

Adding an Embedded MATLAB Function Block to a Model

Programming the Embedded MATLAB Function

Building the Function and Checking for Errors

Defining Inputs and Outputs

• Debugging an Embedded MATLAB Function Block

How Debugging Affects Simulation Speed

Enabling and Disabling Debugging

Debugging the Function in Simulation

Watching Function Variables During Simulation

Checking for Data Range Violations

Debugging Tools

• Embedded MATLAB Function Editor

Customizing the Embedded MATLAB Editor

Embedded MATLAB Editor Tools

Editing and Debugging Embedded MATLAB Code

Ports and Data Manager

• Working with Compilation Reports

About Compilation Reports

Location of Compilation Reports

Opening Compilation Reports

Description of Compilation Reports

Viewing Your Embedded MATLAB Function Code

Viewing Call Stack Information

Viewing the Compilation Summary Information

Viewing Error and Warning Messages

Viewing Variables in Your M-Code

Keyboard Shortcuts for the Compilation Report

Compilation Report Limitations

• Typing Function Arguments

About Function Arguments

Specifying Argument Types

Inheriting Argument Data Types

Built-In Data Types for Arguments

Specifying Argument Types with Expressions

Specifying Simulink Fixed Point Data Properties

• Sizing Function Arguments

Specifying Argument Size

Inheriting Argument Sizes from Simulink

Specifying Argument Sizes with Expressions

Parameter Arguments in Embedded MATLAB Functions

• Resolving Signal Objects for Output Data

Implicit Signal Resolution

Eliminating Warnings for Implicit Signal Resolution in the Model

Disabling Implicit Signal Resolution for an Embedded MATLAB Function Block

Forcing Explicit Signal Resolution for an Output Data Signal

• Working with Structures and Bus Signals

About Structures in Embedded MATLAB Function Blocks

Example of Structures in an Embedded MATLAB Function Block

How Structure Inputs and Outputs Interface with Bus Signals

Rules for Defining Structures in Embedded MATLAB Function Blocks

Workflow for Creating Structures in Embedded MATLAB Function Blocks

Indexing Substructures and Fields

Assigning Values to Structures and Fields

Working with Non-Tunable Structure Parameters in Embedded MATLAB Function Blocks

Limitations of Structures in Embedded MATLAB Function Blocks

• Using Variable-Size Data in Embedded MATLAB Function Blocks

What Is Variable-Size Data?

How Embedded 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 Embedded MATLAB Function Blocks

Limitations of Variable-Size Support in Embedded MATLAB Function Blocks

• Using Enumerated Data in Embedded MATLAB Function Blocks

Enumerated Data in Embedded MATLAB Function Blocks

When to Use Enumerated Data

Simple Example: Defining and Using Enumerated Types in Embedded MATLAB Function Blocks

Using Enumerated Data in Embedded MATLAB Function Blocks

How to Define Enumerated Data Types for Embedded MATLAB Function Blocks

How to Add Enumerated Data to Embedded MATLAB Function Blocks

How to Instantiate Enumerated Data in Embedded MATLAB Function Blocks

Operations on Enumerated Data

Limitations of Enumerated Types

• Working with Frame-Based Signals

About Frame Based Signals

Supported Types for Frame-Based Data

Adding Frame-Based Data in Embedded MATLAB Function Blocks

Examples of Frame-Based Signals in Embedded MATLAB Function Blocks

• Using Traceability in Embedded MATLAB Function Blocks

Extent of Traceability in Embedded MATLAB Function Blocks

Traceability Requirements

Basic Workflow for Using Traceability

Tutorial: Using Traceability in an Embedded MATLAB Function Block

• Enhancing Readability of Generated Code for Embedded MATLAB Function Blocks

Requirements for Using Readability Optimizations

Converting If-Elseif-Else Code to Switch-Case Statements

Example of Converting Code for If-Elseif-Else Decision Logic to Switch-Case Statements

• Speeding Up Simulation with the Basic Linear Algebra Subprograms (BLAS) Library

How Embedded MATLAB Function Blocks Use the BLAS Library

When to Disable BLAS Library Support

How to Disable BLAS Library Support

Supported Compilers

• Controlling Runtime Checks

Types of Runtime Checks

When to Disable Runtime Checks

How to Disable Runtime Checks

• PrintFrame Editor

• PrintFrame Editor Overview

About the Print Frame Editor

What PrintFrames Are

Starting the PrintFrame Editor

Getting Help for the PrintFrame Editor

Closing the PrintFrame Editor

Print Frame Process

• Designing the Print Frame

Before You Begin

Variable and Static Information

Single Use or Multiple Use Print Frames

Specifying the Print Frame Page Setup

• Creating Borders (Rows and Cells)

Adding and Removing Rows

Adding and Removing Cells

Resizing Rows and Cells

Print Frame Size

• Adding Information to Cells

Procedure for Adding Information to Cells

Text Information

Variable Information

Multiple Entries in a Cell

• Changing Information in Cells

Aligning the Information in a Cell

Editing Text Strings

Removing and Copying Entries

Changing the Font Characteristics

• Saving and Opening Print Frames

Saving a Print Frame

Opening a Print Frame

Printing Block Diagrams with Print Frames

About the Example

Create the Print Frame

Print the Block Diagram with the Print Frame

• Simulink Graphical User Interface

• Configuration Parameters Dialog Box

Configuration Parameters Dialog Box Overview

• Model Configuration Pane

• Solver Pane

• Data Import/Export Pane

• Optimization Pane

• Diagnostics Pane: Solver

• Diagnostics Pane: Sample Time

• Diagnostics Pane: Data Validity

• Diagnostics Pane: Type Conversion

• Diagnostics Pane: Connectivity

• Diagnostics Pane: Compatibility

• Diagnostics Pane: Model Referencing

• Diagnostics Pane: Saving

• Hardware Implementation Pane

• Model Referencing Pane

• Simulation Target Pane: General

• Simulation Target Pane: Symbols

• Simulation Target Pane: Custom Code

• Library Browser

About the Library Browser

• Libraries Pane

• Library Pane

Block Description Pane

• Search Toolbar

Most Frequently Used Blocks Pane

Library Data Repository

Library Browser Keyboard Shortcuts

• Signal Properties Dialog Box

• Signal Properties Controls

• Logging and Accessibility Options

• Real-Time Workshop Options

• Documentation Options

• Simulink Preferences Window

• Simulink Preferences Window: Main Pane

• Simulink Preferences Window: Display Defaults Pane

• Simulink Preferences Window: Font Defaults Pane

• Simulink Preferences Window: Configuration Defaults Pane

• Simulink Mask Editor

Mask Editor Overview

• Icon & Ports Pane

• Parameters Pane

• Initialization Pane

• Documentation Pane

Mask Icon Drawing Commands

Simulink Debugger Commands

Simulink Classes

• Model and Block Parameters

• Model Parameters

About Model Parameters

Examples of Setting Model Parameters

• Common Block Parameters

About Common Block Parameters

Examples of Setting Block Parameters

Block-Specific Parameters

• Mask Parameters

About Mask Parameters

Notes on Mask Parameter Storage

• Model File Format

• Model File Contents

About Model File Formats

Simulink.ConfigSet Section

BlockDefaults Section

BlockParameterDefaults Section

AnnotationDefaults Section

LineDefaults Section

• Model Advisor Checks

• Simulink Checks

Simulink Check Overview

Check model, local libraries, and referenced models for known upgrade issues

Identify unconnected lines, input ports, and output ports

Check root model Inport block specifications

Check optimization settings

Check for parameter tunability information ignored for referenced models

Check for implicit signal resolution

Check for optimal bus virtuality

Check for Discrete-Time Integrator blocks with initial condition uncertainty

Identify disabled library links

Identify parameterized library links

Identify unresolved library links

Check for proper usage of Data Store Memory blocks

Check for proper bus usage

Check for potentially delayed function-call subsystem return values

Identify block output signals with continuous sample time and non-floating point data type

Check for proper Merge block usage

Check consistency of initialization parameters for Outport and Merge blocks

Check sample times of Data Store blocks

Check for non-continuous signals driving derivative ports

Runtime diagnostics for Data Store blocks

Runtime diagnostics for S-functions

Simulink Limits

• Overview of S-Functions

• Selecting an S-Function Implementation

Available S-Function Implementations

What Type of S-Function Should You Use?

How to Implement S-Functions

S-Function Features

S-Function Limitations

• Example Using S-Functions to Incorporate Legacy C Code

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

• Writing S-Functions in M

• Writing Level-2 M-File S-Functions

About Level-2 M-File S-Functions

About Run-Time Objects

Level-2 M-File S-Function Template

Level-2 M-File S-Function Callback Methods

Using the setup Method

Example of Writing a Level-2 M-File S-Function

Instantiating a Level-2 M-File S-Function

Operations for Variable-Size Signals

Generating Code from a Level-2 M-File S-Function

M-File S-Function Demos

• Maintaining Level-1 M-File S-Functions

About the Maintenance of Level-1 M-File S-Functions

Level-1 M-File S-Function Arguments

Level-1 M-File S-Function Outputs

Defining S-Function Block Characteristics

Processing S-Function Parameters

Converting Level-1 M-File S-Functions to Level-2

• Writing S-Functions in C

• Introduction

About Writing C S-Functions

Creating C MEX S-Functions

• Building S-Functions Automatically

About Building S-Functions Automatically

Deploying the Generated S-Function

How the S-Function Builder Builds an S-Function

• S-Function Builder Dialog Box

About S-Function Builder

Parameters/S-Function Name Pane

Port/Parameter Pane

Initialization Pane

Data Properties Pane

Input Ports Pane

Output Ports Pane

Parameters Pane

Data Type Attributes Pane

Continuous Derivatives Pane

Discrete Update Pane

Build Info Pane

Example: Modeling a Two-Input/Two-Output System

• Example of a Basic C MEX S-Function

Introducing an Example of a Basic C MEX S-Function

Defines and Includes

Callback Method Implementations

Simulink/Real-Time Workshop Interfaces

Building the Timestwo Example

• Templates for C S-Functions

About the Templates for C S-Functions

S-Function Source File Requirements

Data Types in S-Functions

Compiling C S-Functions

• Integrating Existing C Functions into Simulink Models with the Legacy Code Tool

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

Calling Legacy C++ Functions

Handling Multiple Registration Files

Deploying Generated S-Functions

Legacy Code Tool Demos

Legacy Code Tool Limitations

• How the Simulink Engine Interacts with C S-Functions

Writing Callback Methods

Using S-Functions in Normal Mode Referenced Models

• Debugging C MEX S-Functions

About Debugging C MEX S-Functions

Debugging C MEX S-Functions in the Simulink Environment

Debugging C MEX S-Functions Using Third-Party Software

• Converting Level-1 C MEX S-Functions to Level-2

Guidelines for Converting Level-1 C MEX S-Functions to Level-2

Obsolete Macros

• Creating C++ S-Functions

Creating a C++ Source File

Making C++ Objects Persistent

Building C++ S-Functions

• Creating Fortran S-Functions

Level-1 Versus Level-2 S-Functions

• Creating Level-1 Fortran S-Functions

Fortran MEX Template File

Example of a Level-1 Fortran S-Function

Inline Code Generation Example

• Creating Level-2 Fortran S-Functions

About Creating Level-2 Fortran S-Functions

C/Fortran Interfacing Tips

Constructing the Gateway

Example C MEX S-Function Calling Fortran Code

• Porting Legacy Code

Find the States

Use Flints if Needed

Considerations for Real Time

• Using Work Vectors

• About DWork Vectors

What is a DWork Vector?

Advantages of DWork Vectors

DWork Vectors and the Simulink Engine

DWork Vectors and the Real-Time Workshop Product

Types of DWork Vectors

• How to Use DWork Vectors

Using DWork Vectors in C MEX S-Functions

DWork Vector C MEX Macros

Using DWork Vectors in Level-2 M-File S-Functions

Using DWork Vectors to Pass Data Between S-Functions

Using DWork Vectors With Legacy Code

• DWork Vector Examples

General DWork Vector

DWork Scratch Vector

DState Work Vector

DWork Mode Vector

Level-2 M-File S-Function DWork Vector

• Elementary Work Vectors

Description of Elementary Work Vector

Relationship to DWork Vectors

Using Elementary Work Vectors

Additional Work Vector Macros

Elementary Work Vector Examples

• Implementing Block Features

• Dialog Parameters

About Dialog Parameters

Tunable Parameters

• Run-Time Parameters

About Run-Time Parameters

Creating Run-Time Parameters

Updating Run-Time Parameters

Tuning Run-Time Parameters

Accessing Run-Time Parameters

• Input and Output Ports

Creating Input Ports for C S-Functions

Creating Input Ports for Level-2 M-File S-Functions

Creating Output Ports for C S-Functions

Creating Output Ports for Level-2 M-File S-Functions

Scalar Expansion of Inputs

Masked Multiport S-Functions

• Custom Data Types

Using Custom Data Types in C S-Functions

Using Custom Data Types in Level-2 M-File S-Functions

• Sample Times

About Sample Times

Block-Based Sample Times

Specifying Port-Based Sample Times

Hybrid Block-Based and Port-Based Sample Times

Multirate S-Function Blocks

Multirate S-Functions and Sample Time Hit Calculations

Synchronizing Multirate S-Function Blocks

Specifying Model Reference Sample Time Inheritance

• S-Function Compliance with the SimState

SimState Compliance Specification for Level-2 M-File S-Functions

SimState Compliance Specification for C-MEX S-Functions

• Matrices in C S-Functions

MX Array Manipulation

Memory Allocation

Function-Call Subsystems

Sim Viewing Devices in External Mode

• Frame-Based Signals

About Frame-Based Signals

Using Frame-Based Signals in C S-Functions

Using Frame-Based Signals in Level-2 M-File S-Functions

• Error Handling

About Handling Errors

Exception Free Code

ssSetErrorStatus Termination Criteria

Checking Array Bounds

• C MEX S-Function Examples

About S-Function Examples

Continuous States

Discrete States

Continuous and Discrete States

Variable Sample Time

Array Inputs and Outputs

Zero-Crossing Detection

Discontinuities in Continuous States

S-Function Callback Methods - Alphabetical List

• SimStruct Functions Reference

• Introduction

About SimStruct Functions

Language Support

• SimStruct Macros and Functions Listed by Usage

Dialog Box Parameters

Error Handling and Status

Input and Output Ports

Model Reference

Run-Time Parameters

Simulation Information

State and Work Vector

Code Generation

SimStruct Functions - Alphabetical List

S-Function Options - Alphabetical List

• Release Notes

Simulink roadmap page

	Blocks:
	By Category
	Alphabetical List

	Functions:
	By Category
	Alphabetical List



	Documentation Set

	Getting Started
	Introduces Simulink and gets you started using it

	User's Guide
	Provides Simulink tutorials and comprehensive product information

	Writing S-Functions
	Explains how to use S-functions to create custom blocks

	Examples in Documentation
	Lists major examples in the Simulink documentation



	Product Demos

	Simulink Demos
	Presents a collection of demos that you can run from the Help browser to help you learn the product



	What's New

	Release Notes
	Summarizes new features, bug fixes, upgrade issues, etc.



	Printable (PDF) Documentation on the Web

PDF documents reflect the most recent version of Simulink and might describe features not available in earlier versions of the software.
	Simulink Getting Started Guide
	Using Simulink
	Simulink Graphical User Interface
	Simulink Reference
	Writing S-Functions
	Simulink Release Notes

The MathWorks Web Site Resources

	Demos
	MATLAB Central
	Product Page
	Platforms & Requirements

	Related Books
	Related Products
	Technical Support

© 1984-2009- The MathWorks, Inc. - Site Help - Patents - Trademarks - Privacy Policy - Preventing Piracy - RSS