Controlling Run-Time Checks :: Using the MATLAB Function Block (Simulink®)

Product Documentation

Search MATLAB Documentation
R2012a Documentation → Simulink
View documentation for other releases	Learn more about Simulink

Contents

Index

• Getting Started

• User's Guide

• Introduction to Simulink

• Modeling Dynamic Systems

• Simulating Dynamic Systems

• Managing Blocks

• Working with Blocks

• Working with Block Parameters

• Working with Lookup Tables

• Working with Block Masks

• Creating Custom Blocks

• Working with Block Libraries

• Using the MATLAB Function Block

• Introduction to MATLAB Function Blocks

• Creating an Example Model That Uses a MATLAB Function Block

• Debugging a MATLAB Function Block

• MATLAB Function Block Editor

• Working with MATLAB Function Reports

• Typing Function Arguments

• Sizing Function Arguments

Parameter Arguments in MATLAB Function Block Functions

• Resolving Signal Objects for Output Data

• Working with Structures and Bus Signals

• Using Variable-Size Data in MATLAB Function Blocks

• Using Enumerated Data in MATLAB Function Blocks

• Using Global Data with the MATLAB Function Block

• Working with Frame-Based Signals

• Creating Custom Block Libraries with MATLAB Function Blocks

• Using Traceability in MATLAB Function Blocks

• Including MATLAB Source Code as Comments in the Generated Code

• Enhancing Readability of Generated Code for MATLAB Function Blocks

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

• Controlling Run-Time Checks

Types of Run-Time Checks

When to Disable Run-Time Checks

How to Disable Run-Time Checks

• Tutorial: Integrating MATLAB Code with a Simulink Model for Tracking a Moving Object

Learning Objectives

Tutorial Prerequisites

Example: The Kalman Filter

Files for the Tutorial

Best Practices Used in This Tutorial

Key Points to Remember

Where to Learn More

• Tutorial: Integrating MATLAB Code with a Simulink Model for Filtering an Audio Signal

Learning Objectives

Tutorial Prerequisites

Example: The LMS Filter

Files for the Tutorial

• Managing Data

About Data Types

Data Types Supported by Simulink

Fixed-Point 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

Validating a Floating-Point Embedded Model

Tutorial: Validating a Single-Precision Model

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

Disadvantages of Level-1 Data Class Infrastructure

Features of Level-2 Data Class Infrastructure

Other Differences between Level-1 and Level-2 Data Classes

About Packages and Data Classes

Define Level-1 Data Classes

Working with Classes

Enumerated Property Types

Enabling Custom Storage Classes

Use of Design Minimum and Maximum

Valid Values for Design Minimum and Maximum

Basic Workflow for Defining a Simulink Enumeration

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

Simulating with Enumerations

Specifying Enumerations as Data Types

Getting Information About Enumerations

Enumeration Value Display

Instantiating Enumerations

Enumerated Values in Computation

Logging Enumerated Data

Importing Enumerated Data

Enumerations and Scopes

Enumerated Types for Switch Blocks

Nonsupport of Enumerations

Working with Simulation Data

Simulation Data

Approaches for Exporting Signal Data

Enabling Simulation Data Export

Viewing Logged Simulation Data With the Simulation Data Inspector

Data Format for Block-Based Exported Data

Data Format for Model-Based Exported Data

Signal Logging Format

Logged Data Store Format

State and Output Data Format

Limit Data Points to Last

Refining Output

Producing Additional Output

Producing Specified Output Only

Signal Logging Workflow

Signal Logging Limitations

Enabling Logging for a Signal

Specifying a Logging Name

Limiting the Data Logged for a Signal

Approaches for Viewing the Signal Logging Configuration

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

Enabling and Disabling Logging Globally for a Model

Specifying the Signal Logging Data Format

Specifying a Name for the Signal Logging Data

Benefits of Overriding Signal Logging Settings

Two Interfaces for Overriding Signal Logging Settings

Scope of Signal Logging Setting Overrides

Signal Logging Selector

Command-Line Interface for Overriding Signal Logging Settings

Viewing Signal Logging Data

The Signal Logging Object

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

Techniques for Importing Signal Data

Guidelines for Specifying Time and Signal Values for Imported Data

Sharing Simulation Data Across Models

Example of Importing Data to Model a Continuous Plant

Specify a Signal-Only Structure

Example of Importing Data to Test a Discrete Algorithm

Guidelines for Importing a Test Case

Example of Test Case Data

Using a From Workspace Block to Import an Input Test Case

Using a Signal Builder Block to Import an Input Test Case

Root-Level Input Ports

Enabling Data Import

Importing Bus Data

Specifying the Time Dimension

Models with Multiple Root Inport Blocks

Defining a Structure of MATLAB timeseries Objects for a Bus Signal

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

Alternative to Using MATLAB timeseries Data

Simulink.TsArray Data

Data Array Format

Specifying the Input Expression

Specifying the Input Expression

Data Structures

One Structure for All Ports or a Structure for Each Port

Specifying Signal Data

Specifying Time Data

Examples of Specifying Signal and Time Data

State Information

Saving State Information

Importing Initial States

Importing and Exporting State Information for Referenced Models

Local and Global Data Stores

When to Use a Data Store

Creating Data Stores

Accessing Data Stores

Workflow for Configuring Data Stores

Using Data Stores with Buses and Arrays of Buses

Creating the Data Store

Specifying Data Store Memory Block Attributes

Creating the Data Store

Local and Global Data Stores

Specifying Signal Object Data Store Attributes

Writing to a Data Store

Reading from a Data Store

Accessing a Global Data Store

Accessing Specific Bus and Matrix Elements

Local Data Store Example

Global Data Store Example

Logging Local and Global Data Store Values

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

About Data Store Access Order

Ordering Access Using Function Call Subsystems

Ordering Access Using Block Priorities

About Data Store Diagnostics

Detecting Access Order Errors

Detecting Multitasking Access Errors

Detecting Duplicate Name Errors

Data Store Diagnostics in the Model Advisor

• Managing Signals

Creating Signals

Signal Line Styles

Signal Properties

Testing Signals

Summary of Signal Types

Control Signals

Composite (Bus) Signals

About Virtual Signals

Signal Data Types

Signal Dimensions, Size, and Width

Complex Signals

Initializing Signal Values

Viewing Signal Values

Displaying Signal Values in Model Diagrams

Exporting Signal Data

About Signal Label Propagation

Propagated Signal Label Format

Blocks That Support Signal Label Propagation

Display Propagated Signal Labels

How Simulink Propagates Signal Labels

About Signal Dimensions

Simulink Blocks that Support Multidimensional Signals

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

About Signal Highlighting

Highlighting Signal Sources

Highlighting Signal Destinations

Removing Highlighting

Resolving Incomplete Highlighting to Library Blocks

About Signal Ranges

Blocks That Allow Signal Range Specification

Specifying Ranges for Signals

Checking for Signal Range Errors

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

What Is a Test Point?

Designating a Signal as a Test Point

Displaying Test Point Indicators

Port/Signal Displays Menu

Port Data Types

Signal Dimensions

Signal Resolution Indicators

Wide Nonscalar Lines

About Signal Groups

Signal Builder Window

Creating Signal Group Sets

Editing Waveforms

Signal Builder Time Range

Exporting Signal Group Data

Printing, Exporting, and Copying Waveforms

Simulating with Signal Groups

Simulation Options Dialog Box

Composite Signal Terminology

Types of Simulink Buses

View Information about Buses

Buses and Muxes

Circular Bus Definitions

About Bus Objects

Bus Object Capabilities

Associating Bus Objects with Simulink Blocks

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 by Name

Filtering by Relationship

Changing Filtered Objects

Clearing the Filter

Prerequisites for Customization

Writing a Bus Object Import Function

Writing a Bus Object Export Function

Registering Customizations

Changing Customizations

Creating Nonvirtual Buses

Nonvirtual Bus Sample Times

Automatic Bus Conversion

Explicit Bus Conversion

Connecting Buses to Root Level Inports

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

Bus Signal Initialization

Creating Initial Condition (IC) Structures

Three Ways to Initialize Bus Signals Using Block Parameters

Setting Diagnostics to Support Bus Signal Initialization

What Is an Array of Buses?

Benefits of an Array of Buses

Blocks That Support Arrays of Buses

Array of Buses Limitations

Defining an Array 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

About Variable-Size Signals

Creating Variable-Size Signals

How Variable-Size Signals Propagate

Subsystem Initialization of 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

Demo of Level-2 MATLAB S-Function with Variable-Size Signals

Demo of C S-Function with Variable-Size Signals

Simulink Block Data Type Support

Conditionally Executed Subsystem Blocks

Switching Blocks

• Customizing Simulink Environment and Printed Models

About Adding Items to the Model Editor Menus

Defining Menu Items

Registering Menu Customizations

Callback Info Object

Debugging Custom Menu Callbacks

About Menu Tags

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

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

Reordering Libraries

Disabling and Hiding Libraries

Customizing the Library Browser's Menu

About Registering User Interface Customizations

Customization Manager

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

Before You Begin

Variable and Static Information

Single Use or Multiple Use Print Frames

Adding and Removing Rows

Adding and Removing Cells

Resizing Rows and Cells

Print Frame Size

Procedure for Adding Information to Cells

Text Information

Variable Information

Multiple Entries in a Cell

Aligning the Information in a Cell

Editing Text Strings

Removing and Copying Entries

Changing the Font Characteristics

Saving a Print Frame

Opening a Print Frame

About the Example

Create the Print Frame

Print the Block Diagram with the Print Frame

• Running Models on Target Hardware

Prepare Models That Use Model Reference

About External Mode

Run Your Simulink Model in External Mode

Stop External Mode

Prepare Models That Use Model Reference

About External Mode

Set up Bluetooth on Windows

Run Your Simulink Model in External Mode

Stop External Mode

Set the COM Port Number Manually

Tips for Use Bluetooth Blocks

Add Bluetooth Blocks to your Models

Configure a Bluetooth Slave

Configure a Bluetooth Master

• Developing S-Functions

Passing Parameters to S-Functions

When to Use an S-Function

Mathematics of Simulink Blocks

Simulation Stages

S-Function Callback Methods

MATLAB S-Functions

MEX S-Functions

Direct Feedthrough

Dynamically Sized Arrays

Setting Sample Times and Offsets

Overview of Examples

Level-2 MATLAB S-Function Examples

Level-1 MATLAB S-Function Examples

C S-Function Examples

Fortran S-Function Examples

C++ 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

About Level-2 MATLAB S-Functions

About Run-Time Objects

Level-2 MATLAB S-Function Template

Level-2 MATLAB S-Function Callback Methods

Using the setup Method

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

MATLAB S-Function Demos

About the Maintenance of Level-1 MATLAB S-Functions

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

About Writing C S-Functions

Creating C MEX S-Functions

About Building S-Functions Automatically

Deploying the Generated S-Function

How the S-Function Builder Builds an S-Function

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

Introducing an Example of a Basic C MEX S-Function

Defines and Includes

Callback Method Implementations

Simulink/Simulink Coder Interfaces

Building the Timestwo Example

About the Templates for C S-Functions

S-Function Source File Requirements

Data Types in S-Functions

Compiling C S-Functions

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

Supporting the Use of Multiple Instances of Referenced Models That Are in Normal Mode

About Debugging C MEX S-Functions

Debugging C MEX S-Functions in the Simulink Environment

Debugging C MEX S-Functions Using Third-Party Software

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

Obsolete Macros

Fortran MEX Template File

Example of a Level-1 Fortran S-Function

Inline Code Generation Example

About Creating Level-2 Fortran S-Functions

C/Fortran Interfacing Tips

Constructing the Gateway

Example C MEX S-Function Calling Fortran Code

Find the States

Use Flints if Needed

Considerations for Real Time

What is a DWork Vector?

Advantages of DWork Vectors

DWork Vectors and the Simulink Engine

DWork Vectors and the Simulink Coder Product

Using DWork Vectors in C MEX S-Functions

DWork Vector C MEX Macros

Using DWork Vectors in Level-2 MATLAB S-Functions

Using DWork Vectors With Legacy Code

General DWork Vector

DWork Scratch Vector

DState Work Vector

DWork Mode Vector

Level-2 MATLAB S-Function DWork Vector

Description of Elementary Work Vector

Relationship to DWork Vectors

Using Elementary Work Vectors

Additional Work Vector Macros

Elementary Work Vector Examples

About Dialog Parameters

Tunable Parameters

About Run-Time Parameters

Creating Run-Time Parameters

Updating Run-Time Parameters

Tuning Run-Time Parameters

Accessing Run-Time Parameters

Creating Input Ports for C S-Functions

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

Scalar Expansion of Inputs

Masked Multiport S-Functions

Using Custom Data Types in C S-Functions

Using Custom Data Types in Level-2 MATLAB S-Functions

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

SimState Compliance Specification for Level-2 MATLAB S-Functions

SimState Compliance Specification for C-MEX S-Functions

MX Array Manipulation

Memory Allocation

About Frame-Based Signals

Using Frame-Based Signals in C S-Functions

Using Frame-Based Signals in Level-2 MATLAB S-Functions

About Handling Errors

Exception Free Code

ssSetErrorStatus Termination Criteria

Checking Array Bounds

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

• Modeling Guidelines

• Release Notes

Controlling Run-Time Checks

On this page…

Types of Run-Time Checks

When to Disable Run-Time Checks

How to Disable Run-Time Checks

Types of Run-Time Checks

In simulation, the code generated for your MATLAB Function block includes the following run-time checks:

Memory integrity checks
These checks detect violations of memory integrity in code generated for MATLAB Function blocks and stop execution with a diagnostic message.
Responsiveness checks in code generated for MATLAB Function blocks
These checks enable periodic checks for Ctrl+C breaks in the generated code. Enabling responsiveness checks also enables graphics refreshing.

When to Disable Run-Time Checks

Generally, generating code with run-time checks enabled results in more lines of generated code and slower simulation than generating code with the checks disabled. Disabling run-time checks usually results in streamlined generated code and faster simulation, with these caveats:

Consider disabling:	Only if:
Memory integrity checks	You are sure that your code is safe and that all array bounds and dimension checking is unnecessary.
Responsiveness checks	You are sure that you will not need to stop execution of your application using Ctrl+C.

How to Disable Run-Time Checks

MATLAB Function blocks enable run-time checks by default, but you can disable them explicitly for all MATLAB Function blocks in your Simulink model. Follow these steps:

Open your MATLAB Function block.
In the MATLAB Function Block Editor, select Tools > Open Simulation Target.
The Configuration Parameters dialog box opens with Simulation Target selected.
Clear the Ensure memory integrity or Ensure responsiveness check boxes, as applicable, and click Apply.

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

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

Tutorial: Integrating MATLAB Code with a Simulink Model for Tracking a Moving Object

Tutorial: Integrating MATLAB Code with a Simulink Model
for Tracking a Moving Object

Related Products & Applications

Get Simulink trial software

Learn more about Simulink through this collection of videos, articles, technical literature and the Getting Started with Simulink Guide.

Get this Simulink Kit

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