Stateflow - Documentation

Contents

Index

• Getting Started

• Stateflow Chart Concepts

• Stateflow Chart Notation

• Overview of Stateflow Objects

Graphical Objects

Nongraphical Objects

For More Information on Stateflow Objects

• Rules for Naming Stateflow Objects

Characters You Can Use

Restriction on Name Length

Reserved Keywords

What Is a State?

State Hierarchy

State Decomposition

• Transitions

What Is a Transition?

Transition Hierarchy

Transition Label Notation

Valid Transitions

• Transition Connections

Transitions to and from Exclusive (OR) States

Transitions to and from Junctions

Transitions to and from Exclusive (OR) Superstates

Transitions to and from Substates

Self-Loop Transitions

Inner Transitions

• Default Transitions

What Is a Default Transition?

Drawing Default Transitions

Labeling Default Transitions

Default Transition Examples

• Connective Junctions

What Is a Connective Junction?

Flow Graph Notation with Connective Junctions

• History Junctions

What Is a History Junction?

History Junctions and Inner Transitions

• Graphical Functions

What Is a Graphical Function?

Example of Using a Graphical Function

Advantages of Using Graphical Functions

Example of Using a Box

• Stateflow Chart Semantics

• What Do Semantics Mean for Stateflow Charts?

What Are Chart Semantics?

Common Graphical and Nongraphical Constructs

References for Chart Semantics

• How Chart Constructs Interact During Execution

Overview of the Example Model

Model of the Check-In Process for a Hotel

How the Chart Interacts with Simulink Blocks

Phases of Chart Execution

Modeling Guidelines for Charts with Events, States, and Transitions

• How Events Drive Chart Execution

How Stateflow Charts Respond to Events

Sources for Stateflow Events

How Charts Process Events

• Types of Chart Execution

Lifecycle of a Stateflow Chart

Execution of an Inactive Chart

Execution of an Active Chart

Execution of a Chart with Super Step Semantics

Execution of a Chart at Initialization

• Process for Grouping and Executing Transitions

Transition Flow Graph Types

Order of Execution for a Set of Flow Graphs

• Evaluation Order for Outgoing Transitions

What Does Ordering Mean for Outgoing Transitions?

Explicit Ordering of Outgoing Transitions

Implicit Ordering of Outgoing Transitions

What Happens When You Switch Between Explicit and Implicit Ordering

Transition Testing Order in Multilevel State Hierarchy

• Process for Entering, Executing, and Exiting States

Steps for Entering a State

Steps for Executing an Active State

Steps for Exiting an Active State

State Execution Example

• Execution Order for Parallel States

What Does Ordering Mean for Parallel States?

Explicit Ordering of Parallel States

Implicit Ordering of Parallel States

How a Chart Maintains Order of Parallel States

How a Chart Assigns Execution Priorities to Restored States

What Happens When You Switch Between Explicit and Implicit Ordering

How a Chart Orders Parallel States in Boxes and Subcharts

• Early Return Logic for Event Broadcasts

Guidelines for Proper Chart Behavior

How Early Return Logic Works

Example of Early Return Logic

• Creating Stateflow Charts

Creating a Stateflow Chart

• Working with States in Charts

Creating a State

Moving and Resizing States

Creating Substates and Superstates

Grouping States

Specifying Substate Decomposition

Specifying Activation Order for Parallel States

Changing State Properties

Labeling States

Outputting State Activity to a Simulink Model

• Working with Transitions in Charts

Creating a Transition

Straight and Curved Transitions

Labeling Transitions

Moving Transitions

Changing Transition Arrowhead Size

Creating Self-Loop Transitions

Creating Default Transitions

Changing Transition Properties

• Using the Stateflow Editor

Stateflow Editor Window

Displaying the Context Menu for Objects

Specifying Colors and Fonts in the Stateflow Editor

Differentiating Syntax Elements in the Stateflow Action Language

Selecting and Deselecting Graphical Objects

Cutting and Pasting Graphical Objects

Copying Graphical Objects

Formatting Chart Objects

Editing Object Labels

Viewing Stateflow Objects in the Model Explorer

Zooming a Chart

Zooming a Chart Object Using the Stateflow API

Undoing and Redoing Editor Operations

Stateflow Chart Notes Dialog Box

Keyboard Shortcuts for Stateflow Charts

Customizing the Stateflow Editor

• Modeling Logic Patterns and Iterative Loops Using Flow Graphs

What Is a Flow Graph?

Difference Between Flow Graphs and State Charts

When to Use Flow Graphs

• Creating Flow Graphs with the Pattern Wizard

Why Use the Pattern Wizard?

How to Create Reusable Flow Graphs

Saving and Reusing Flow Graph Patterns

MAAB-Compliant Patterns from the Pattern Wizard

Try It: Creating and Reusing a Custom Pattern with the Pattern Wizard

• Drawing and Customizing Flow Graphs By Hand

How to Draw a Flow Graph

How to Change Connective Junction Size

How to Modify Junction Properties

Best Practices for Creating Flow Graphs

• Enhancing Readability of Generated Code for Flow Graphs

Appearance of Generated Code for Flow Graphs

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

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

• Building Mealy and Moore Charts

• Overview of Mealy and Moore Machines

Semantics of Mealy and Moore Machines

Running a Demo of Mealy and Moore Machines

The Default State Machine Type

Availability of Output

Advantages of Mealy and Moore Charts Over Classic Stateflow Charts

Creating Mealy and Moore Charts

• Design Considerations for Mealy Charts

Mealy Semantics

Design Rules for Mealy Charts

Example: Mealy Vending Machine

• Design Considerations for Moore Charts

Moore Semantics

Design Rules for Moore Charts

Example: Moore Traffic Light

Changing Chart Type

Debugging Mealy and Moore Charts

• Extending Stateflow Charts

• Using History Junctions to Extend Charts and States

About History Junctions

Creating a History Junction

Changing History Junction Size

Changing History Junction Properties

• Using Subcharts to Extend Charts

What Is a Subchart?

Creating a Subchart

Manipulating Subcharts as Objects

Opening a Subchart

Editing a Subchart

Navigating Subcharts

• Using Supertransitions to Extend Transitions

What Is a Supertransition?

Drawing a Supertransition Into a Subchart

Drawing a Supertransition Out of a Subchart

Labeling Supertransitions

• Extending Transitions with Smart Behavior

What Are Smart Transitions?

Setting Smart Behavior in Transitions

What Smart Transitions Do

What Nonsmart Transitions Do

• Using Graphical Functions to Extend Actions

What Is a Graphical Function?

Why Use a Graphical Function?

Where to Use a Graphical Function

Workflow for Defining a Graphical Function

Managing Large Graphical Functions

Calling Graphical Functions in Stateflow Action Language

Exporting Chart-Level Graphical Functions

Specifying Graphical Function Properties

• Using Boxes to Extend Charts

When to Use Boxes

Semantics of Boxes

Rules for Using Boxes

Drawing and Editing a Box

Examples of Using Boxes

• Using Notes to Extend Charts

Editing Existing Notes

Changing Note Font and Color

• Printing Stateflow Charts

Printing Scaled Charts

Using Tiled Printing for Stateflow Charts

Generating a Model Report

Printing the Current Chart

• Defining Data

• Adding Data

When to Add Data

Where You Can Use Data

Adding Data Using the Stateflow Editor

Adding Data Using the Model Explorer

• Setting Data Properties in the Data Dialog Box

What Is the Data Properties Dialog Box?

When to Use the Data Properties Dialog Box

Opening the Data Properties Dialog Box

Properties You Can Set in the General Pane

Properties You Can Set in the Value Attributes Pane

Properties You Can Set in the Description Pane

Entering Expressions and Parameters for Data Properties

• Sharing Data with Simulink Models and the MATLAB Workspace

Sharing Input and Output Data with Simulink Models

Sharing Simulink Parameters with Stateflow Charts

Initializing Data from the MATLAB Base Workspace

Saving Data to the MATLAB Workspace

• Sharing Global Data with Simulink Models

About Data Stores

How Stateflow Charts Work with Local and Global Data Stores

Accessing Data Store Memory from a Stateflow Chart

Diagnostics for Sharing Data Between Stateflow Charts and Simulink Blocks

Creating a Global Data Store Across Multiple Models

• Sharing Chart Data with External Modules

Methods of Sharing Chart Data with External Modules

Exporting Data to External Modules

Importing Data from External Modules

• Typing Stateflow Data

What Is Data Type?

Specifying Data Type and Mode

Built-In Data Types

Inheriting Data Types from Simulink Objects

Deriving Data Types from Previously Defined Data

Typing Data by Using an Alias

Strong Data Typing with Simulink I/O

• Sizing Stateflow Data

About Stateflow Data Sizes

How to Specify Data Size

Sizing Data as a Constant Value

Sizing Data by Expression

Inheriting Input and Output Data Size from Simulink Signals

• Defining Temporary Data

When to Define Temporary Data

How to Define Temporary Data

• Using Dot Notation to Identify Data in a Chart

What Is Dot Notation?

Resolution of Data Identifiers with Dot Notation

Best Practices for Using Dot Notation in Data Identifiers

• Resolving Data Properties from Simulink Signal Objects

About Explicit Signal Resolution

Inherited Properties

Enabling Explicit Signal Resolution

A Simple Example

• Best Practices for Using Data in Stateflow Charts

Avoid Inheriting Output Data Properties from Simulink Blocks

Tips for Using Data Stores in Stateflow Charts

• Transferring Data Across Models

Copying Data Objects

Moving Data Objects

• Defining Events

• How Events Work in Stateflow Charts

What Is an Event?

When to Use Events

Types of Events

Where You Can Use Events

• How to Define Events

Adding Events Using the Stateflow Editor

Adding Events Using the Model Explorer

• Setting Properties for an Event

When to Use the Event Properties Dialog Box

Accessing the Event Properties Dialog Box

Property Fields

• Using Input Events to Activate a Stateflow Chart

What Is an Input Event?

Using Edge Triggers to Activate a Stateflow Chart

Using Function Calls to Activate a Stateflow Chart

Associating Input Events with Control Signals

• Using Output Events to Activate a Simulink Block

What Is an Output Event?

Using Edge Triggers to Activate a Simulink Block

Using Function Calls to Activate a Simulink Block

Associating Output Events with Output Ports

Accessing Simulink Subsystems Triggered By Output Events

• Using Implicit Events

What Are Implicit Events?

Referencing Implicit Events

Example of an Implicit Event

• Counting Events

When to Count Events

How to Count Events

Example of Storing Input Data in a Vector

Best Practices for Using Events in Stateflow Charts

• Transferring Events Across Models

Copying Event Objects

Moving Event Objects

• Using Actions in Stateflow Charts

• Defining Action Types

About Action Types

State Action Types

Transition Action Types

Example of Action Type Execution

• Using Operations in Actions

Binary and Bitwise Operations

Unary Operations

Assignment Operations

Pointer and Address Operations

Type Cast Operations

Replacing Operators with Target Functions

• Symbols in Action Language

Boolean Symbols, true and false

Comment Symbols, %, //, /*

Hexadecimal Notation Symbols, 0xFF

Infinity Symbol, inf

Line Continuation Symbol, ...

Literal Code Symbol, $

MATLAB Display Symbol, ;

Single-Precision Floating-Point Number Symbol, F

• Calling C Functions in Actions

Calling C Library Functions

Calling the abs Function

Calling min and max Functions

Replacement of C Math Library Functions with Target-Specific Implementations

Calling Custom C Code Functions

• Using MATLAB Functions and Data in Actions

MATLAB Functions and Stateflow Code Generation

ml Namespace Operator

Which ml Should I Use?

How Charts Infer the Return Size for ml Expressions

Using Data and Event Arguments in Actions

• Using Arrays in Actions

Arrays and Custom Code

• Broadcasting Events in Actions

About Events in Actions

Directed Event Broadcasting

Example of Directed Event Broadcasting Using send

Example of Directed Event Broadcasting Using Qualified Event Names

• Using Temporal Logic in State Actions and Transitions

What Is Temporal Logic?

Rules for Using Temporal Logic Operators

Operators for Event-Based Temporal Logic

Examples of Event-Based Temporal Logic

Notations for Event-Based Temporal Logic

Operators for Absolute-Time Temporal Logic

Defining Time Delays

Examples of Absolute-Time Temporal Logic

Running a Model That Demonstrates Absolute-Time Temporal Logic

Using Absolute-Time Temporal Logic in a Conditionally Executed Subsystem

How Sample Time Affects Chart Execution

Tips for Using Absolute-Time Temporal Logic

• Using Change Detection in Actions

About Change Detection

Running a Model That Demonstrates Change Detection

How Change Detection Works

Change Detection Operators

Change Detection Example

• Checking State Activity

When to Check State Activity

How to Check State Activity

The in Operator

How Checking State Activity Works

State Resolution for Identically Named Substates

Best Practices for Checking State Activity

• Using Bind Actions to Control Function-Call Subsystems

About Bind Actions

Binding a Function-Call Subsystem to a State

Example Model That Binds a Function-Call Subsystem to a State

Behavior of a Bound Function-Call Subsystem

Why Avoid Muxed Trigger Events with Binding

• Saving and Restoring Simulations Using SimState

What Is a SimState?

• Benefits of Using a Snapshot of the Simulation State

Division of a Long Simulation into Segments

Test of a Chart Response to Different Settings

• Example of Dividing a Long Simulation into Segments

Goal of the Example

Defining the SimState

Loading the SimState

Simulating the Specific Segment

• Example of Testing a Unique Chart Configuration

Goal of the Example

Defining the SimState

Loading the SimState and Modifying Values

Testing the Modified SimState

• Example of Testing a Chart with Fault Detection Logic

Goal of the Example

Defining the SimState

Modifying SimState Values for One Actuator Failure

Testing the SimState for One Failure

Modifying SimState Values for Two Actuator Failures

Testing the SimState for Two Failures

Methods for Interacting with the SimState of a Chart

• Rules for Using the SimState of a Chart

Limitations on Values You Can Modify

Rules for Modifying Data Values

Rules for Modifying State Activity

Restriction on Continuous-Time Charts

No Partial Loading of a SimState

Restriction on Copying SimState Values

SimState Limitations That Apply to All Blocks in a Model

• Best Practices for Using the SimState of a Chart

Use MAT-Files to Save a SimState for Future Use

Use M-Files to Save SimState Commands for Future Use

• Using Vectors and Matrices in Stateflow Charts

• How Vectors and Matrices Work in Stateflow Charts

When to Use Vectors and Matrices

Where You Can Use Vectors and Matrices

• How to Define Vectors and Matrices

Defining a Vector

Defining a Matrix

• Scalar Expansion for Converting Scalars to Nonscalars

What Is Scalar Expansion?

How Scalar Expansion Works for Functions

• How to Assign and Access Values of Vectors and Matrices

Notation for Vectors and Matrices

Assigning and Accessing Values of Vectors

Assigning and Accessing Values of Matrices

Using Scalar Expansion to Assign Values of a Vector or Matrix

• Operations That Work with Vectors and Matrices in Stateflow Action Language

Binary Operations

Unary Operations and Actions

Assignment Operations

Rules for Using Vectors and Matrices in Stateflow Charts

• Best Practices for Vectors and Matrices in Stateflow Charts

Using Embedded MATLAB Functions to Perform Matrix Multiplication and Division

Using the temporalCount Operator to Index a Vector

• Examples of Vectors and Matrices in Stateflow Charts

Communications Example

Physics Example

• Using Variable-Size Data in Stateflow Charts

What Is Variable-Size Data?

How Charts Implement Variable-Size Data

Enabling Support for Variable-Size Data

Declaring Variable-Size Inputs and Outputs

• Example: Computing Output Based on Size of Input Signal

About the Example

Opening the Model

Chart: VarSizeSignalSource

Chart: size_based_processing

Simulating the Model

Rules for Using Variable-Size Data in Stateflow Charts

• Using Enumerated Data in Stateflow Charts

What Is Enumerated Data?

Benefits of Using Enumerated Data in a Chart

Where to Use Enumerated Data

Elements of an Enumerated Data Type Definition

• How to Define Enumerated Data in a Stateflow Chart

Tasks for Defining Enumerated Data in a Chart

Defining an Enumerated Data Type in an M-file

Adding Enumerated Data to a Chart

Ensuring That Changes in Data Type Definition Take Effect

• Notation for Referring to Enumerated Values in a Chart

Nonprefixed Notation for Enumerated Values

Prefixed Notation for Enumerated Values

Operations on Enumerated Data in Stateflow Action Language

• How to View Enumerated Values in a Stateflow Chart

Viewing Values of Enumerated Data During Simulation

Viewing Values of Enumerated Data After Simulation

Rules for Using Enumerated Data in a Stateflow Chart

Best Practices for Using Enumerated Data in a Stateflow Chart

• CD Player Model That Uses Enumerated Data

Overview of CD Player Model

Benefits of Using Enumerated Types in This Model

Running the CD Player Model

How the UserRequest Chart Works

How the CdPlayerModeManager Chart Works

How the CdPlayerBehaviorModel Chart Works

• Example of Using Enumerated Values for Assignment

Goal of the Example

Building the Chart

Viewing Results for Simulation

How the Chart Works

• Modeling Continuous-Time Systems in Stateflow Charts

• About Continuous-Time Modeling

What Is Continuous-Time Modeling?

When To Use Stateflow Charts for Continuous-Time Modeling

Running Models That Demonstrate Continuous-Time Modeling

Workflow for Creating Continuous-Time Charts

Configuring a Stateflow Chart to Update in Continuous-Time

When to Enable Zero-Crossing Detection

• Defining Continuous-Time Variables

About Continuous-Time Variables

Implicit Time Derivatives

Rules for Using Continuous-Time Variables

How to Define Continuous-Time Variables

Exposing Continuous States to a Simulink Model

• Modeling a Bouncing Ball in Continuous-Time

Dynamics of a Bouncing Ball

Modeling the Bouncing Ball

• Design Considerations for Continuous-Time Modeling in Stateflow Charts

Rationale for Design Considerations

Summary of Rules for Continuous-Time Modeling

• Using Fixed-Point Data in Stateflow Charts

• What Is Fixed-Point Data?

Before You Begin

Fixed-Point Numbers

Fixed-Point Operations

• How Fixed-Point Data Works in Stateflow Charts

How Stateflow Software Defines Fixed-Point Data

Specifying Fixed-Point Data

Fixed-Point Context-Sensitive Constants

Tips for Using Fixed-Point Data

Overflow Detection for Fixed-Point Types

Sharing Fixed-Point Data with Simulink Models

• Fixed-Point "Bang-Bang Control" Example

Opening the Fixed-Point "Bang-Bang Control" Example

Exploring the Fixed-Point "Bang-Bang Control" Example

• Operations with Fixed-Point Data

Supported Operations with Fixed-Point Operands

Promotion Rules for Fixed-Point Operations

Assignment (=, :=) Operations

Fixed-Point Conversion Operations

Automatic Scaling of Stateflow Fixed-Point Data

• Using Complex Data in Stateflow Charts

• How Complex Data Works in Stateflow Charts

What Is Complex Data?

When to Use Complex Data

Where You Can Use Complex Data

How You Can Use Complex Data

How to Define Complex Data

• Operations on Complex Data in Stateflow Action Language

Binary Operations

Unary Operations and Actions

Assignment Operations

• Using Operators to Handle Complex Numbers

Why Use Operators for Complex Numbers?

Defining a Complex Number

Accessing Real and Imaginary Parts of a Complex Number

Working with Vector Arguments

Rules for Using Complex Data in Stateflow Charts

• Tips for Using Complex Data in Stateflow Charts

Performing Math Function Operations with an Embedded MATLAB Function

Performing Complex Division with an Embedded MATLAB Function

• Implementing a Frame Synchronization Controller Using a Stateflow Chart

What Is Frame Synchronization?

A Frame Synchronization Controller Chart

Key Features of the Chart

Opening the Model

How the Chart Works

• Implementing a Spectrum Analyzer Using a Stateflow Chart

What Is a Spectrum Analyzer?

A Spectrum Analyzer Model

Running the Spectrum Analyzer Model

How the Sinusoid Generator Block Works

How the Analyzer Chart Works

How the Unwrap Chart Works

• Defining Interfaces to Simulink Models and the MATLAB Workspace

• Overview of Stateflow Block Interfaces

Stateflow Block Interfaces

Typical Tasks to Define Stateflow Block Interfaces

Where to Find More Information on Events and Data

• Specifying Chart Properties

About Chart Properties

Setting Properties for a Single Chart

Setting Properties for All Charts in the Model

Setting the Stateflow Block Update Method

• Implementing Update Interfaces to Simulink Models

Defining a Triggered Stateflow Block

Defining a Sampled Stateflow Block

Defining an Inherited Stateflow Block

Defining a Continuous Stateflow Block

Defining Function-Call Output Events

Defining Edge-Triggered Output Events

Creating Chart Libraries

• MATLAB Workspace Interfaces

About the MATLAB Workspace

Examining the MATLAB Workspace

Interfacing the MATLAB Workspace with Stateflow Charts

• Interface to External Sources

Exported Events

Imported Events

• Working with Structures and Bus Signals in Stateflow Charts

• About Stateflow Structures

What Is a Stateflow Structure?

What You Can Do with Structures

Example of Stateflow Structures

• Defining Stateflow Structures

Rules for Defining Structure Data Types in Stateflow Charts

Defining Structure Inputs and Outputs

Defining Local Structures

Defining Temporary Structures

Defining Structure Types with Expressions

• Structure Operations

Indexing Sub-Structures and Fields

Assigning Values

Getting Addresses

Integrating Custom Structures in Stateflow Charts

Debugging Structures

• Stateflow Design Patterns

• Debouncing Signals

Why Debounce Signals

The Debouncer Model

Key Behaviors of Debouncer Chart

Running the Debouncer

• Scheduling Execution of Simulink Subsystems

When to Implement Schedulers Using Stateflow Charts

Types of Scheduler Patterns

Scheduling Multiple Subsystems in a Single Time Step Using a Ladder Logic Scheduler

Scheduling One Subsystem in a Single Time Step Using a Loop Scheduler

Scheduling Subsystems to Execute at Specific Times Using a Temporal Logic Scheduler

• Implementing Dynamic Test Vectors

When to Implement Test Vectors Using Stateflow Charts

A Dynamic Test Vector Chart

Key Behaviors of the Test Vector Chart and Model

Running the Model with Stateflow Test Vectors

• Truth Table Functions

What Is a Truth Table?

• Language Options for Stateflow Truth Tables

Stateflow Classic Truth Tables

Embedded MATLAB Truth Tables

Selecting a Language for Stateflow Truth Tables

Migration from Stateflow Classic to Embedded MATLAB Truth Tables

Workflow for Using Truth Tables

• Building a Simulink Model with a Stateflow Truth Table

Methods for Adding Truth Tables to Simulink Models

Adding a Stateflow Block that Calls a Truth Table Function

• Programming a Truth Table

Opening a Truth Table for Editing

Selecting An Action Language

Entering Truth Table Conditions

Entering Truth Table Decisions

Entering Truth Table Actions

Assigning Truth Table Actions to Decisions

Adding Initial and Final Actions

• Debugging a Truth Table

Checking Truth Tables for Errors

Debugging a Truth Table During Simulation

• Correcting Overspecified and Underspecified Truth Tables

Example of an Overspecified Truth Table

Example of an Underspecified Truth Table

• Checking Model Coverage for Truth Tables

Types of Coverage in Stateflow Truth Tables

Generating a Model Coverage Report

Analyzing Coverage in Stateflow Truth Tables

• How Stateflow Software Implements Truth Tables

Types of Generated Content

Viewing Generated Content

How Stateflow Software Generates Graphical Functions for Truth Tables

How Stateflow Software Generates Embedded MATLAB Code for Truth Tables

• Truth Table Editor Operations

Truth Table Editor Reference

Searching and Replacing Text in Truth Tables

• Using Embedded MATLAB Functions in Stateflow Charts

Introduction to Embedded MATLAB Functions

Building a Simulink Model with an Embedded MATLAB Function

Programming an Embedded MATLAB Function

• Debugging an Embedded MATLAB Function

Checking Embedded MATLAB Functions for Syntax Errors

Run-Time Debugging for Embedded MATLAB Functions

Checking for Data Range Violations

• Model Coverage for an Embedded MATLAB Function

About Model Coverage

Types of Model Coverage in Embedded MATLAB Functions

Creating a Model with Embedded MATLAB Function Decisions

Understanding Embedded MATLAB Function Model Coverage

• Working with Structures and Bus Signals in Embedded MATLAB Functions

About Structures in Embedded MATLAB Functions

Defining Structures in Embedded MATLAB Functions

Working with Enumerated Data in Embedded MATLAB Functions

Working with Variable-Size Data in Embedded MATLAB Functions

Enhancing Readability of Generated Code for Embedded MATLAB Functions

• Using Simulink Functions in Stateflow Charts

What Is a Simulink Function?

• When to Use a Simulink Function in a Stateflow Chart

Advantages of Using Simulink Functions in a Stateflow Chart

Benefits of Using a Simulink Function to Access Simulink Blocks

Benefits of Using a Simulink Function to Schedule Execution of Multiple Controllers

• How to Define a Simulink Function in a Stateflow Chart

Task 1: Add a Function to the Chart

Task 2: Define the Subsystem Elements of the Simulink Function

Task 3: Configure the Function Inputs

• How a Simulink Function Binds to a State

Binding Behavior of a Simulink Function

Controlling Subsystem Variables When the Simulink Function Is Disabled

Example of Binding a Simulink Function to a State

How a Simulink Function Behaves When Called from Multiple Sites

Rules for Using Simulink Functions in Stateflow Charts

Best Practices for Using Simulink Functions

• Example of Defining a Function That Uses Simulink Blocks

Goal of the Example

Editing a Model to Use a Simulink Function

Running the New Model

• Example of Scheduling Execution of Multiple Controllers

Goal of the Example

Editing a Model to Use Simulink Functions

Running the New Model

• Building Targets

• Targets You Can Build

Code Generation for Stateflow Charts and Truth Table Blocks

Software Requirements for Building Targets

• Choosing a Procedure to Simulate a Model

Guidelines for Simulation

Choosing the Right Procedure for Simulation

• Procedures for Simulation

Starting Simulation

Integrating Custom C++ Code for Simulation

Integrating Custom C Code for Nonlibrary Charts for Simulation

Integrating Custom C Code for Library Charts for Simulation

Integrating Custom C Code for All Charts for Simulation

Speeding Up Simulation

• Choosing a Procedure to Generate Embeddable Code for a Model

Guidelines for Embeddable Code Generation

Choosing the Right Procedure for Embeddable Code Generation

• Procedures for Embeddable Code Generation

Generating Code

Integrating Custom C++ Code for Code Generation

Integrating Custom C Code for Nonlibrary Charts for Code Generation

Integrating Custom C Code for Library Charts for Code Generation

Integrating Custom C Code for All Charts for Code Generation

• Optimizing Generated Code

How to Optimize Generated Code for Embeddable Targets

Design Tips for Optimizing Generated Code

• Using the Command-Line API to Set Parameters for Simulation and Embeddable Code Generation

How to Set Parameters at the Command Line

Simulation Parameters for Nonlibrary Models

Simulation Parameters for Library Models

Code Generation Parameters for Nonlibrary Models

Code Generation Parameters for Library Models

• Specifying Relative Paths for Custom Code

Why Use Relative Paths?

Searching Relative Paths

Path Syntax Rules

Choosing a Compiler

• Examples of Integrating Custom C Code in Nonlibrary Models

Accessing Examples of Custom C Code Integration

Example of Using Custom C Code to Define Global Constants

Example of Using Custom C Code to Define Global Constants, Variables, and Functions

• How to Build a Stateflow Custom Target

When to Build a Custom Target

Adding a Stateflow Custom Target to Your Model

Configuring a Custom Target

Building a Custom Target

What Happens During the Target Building Process?

• Parsing Stateflow Charts

How the Stateflow Parser Works

Calling the Stateflow Parser

Parser Error Checking

Parsing Chart Example

• Resolving Event, Data, and Function Symbols in Stateflow Action Language

Resolving Symbols

Symbol Autocreation Wizard

• Error Messages When Parsing Charts and Generating Code

How Error Messages Appear

Parser Error Messages

Code Generation Error Messages

Compilation Error Messages

• Generated Code Files for Targets You Build

S-Function MEX-Files

Folder Structure of Generated Files

Code Files for a Simulation Target

Code Files for an Embeddable Target

Code Files for a Custom Target

• Traceability of Stateflow Objects in Real-Time Workshop Generated Code

What Is Traceability?

Traceability Requirements

Traceable Stateflow Objects

When to Use Traceability

Basic Workflow for Using Traceability

Examples of Using Traceability

Format of Traceability Comments

• Controlling Inlining of State Functions in Generated Code

How Stateflow Software Inlines Generated Code for State Functions

How to Set the State Function Inline Option

Best Practices for Controlling State Function Inlining

• Debugging and Testing Stateflow Charts

• Using the Stateflow Debugger

Opening the Stateflow Debugger

Animating Stateflow Charts

Setting Breakpoints for Debugging a Chart

Options for Error Checking in the Debugging Window

Starting Simulation in the Debugging Window

Options to Control Execution Rate in the Debugging Window

Options to Control the Output Display Pane

• Example of Debugging Run-Time Errors in a Chart

Creating the Model and the Stateflow Chart

Debugging the Stateflow Chart

Correcting the Run-Time Error

Identifying Stateflow Objects in Error Messages

• Debugging State Inconsistencies in a Chart

Definition of State Inconsistency

Causes of State Inconsistency

Detecting State Inconsistency

State Inconsistency Example

• Debugging Conflicting Transitions in a Chart

What Are Conflicting Transitions?

Detecting Conflicting Transitions

Example of Conflicting Transitions

• Debugging Data Range Violations in a Chart

Types of Data Range Violations

Detecting Data Range Violations

Data Range Violation Example

• Debugging Cyclic Behavior in a Chart

What Is Cyclic Behavior?

Detecting Cyclic Behavior During Simulation

Cyclic Behavior Example

Flow Cyclic Behavior Not Detected Example

Noncyclic Behavior Flagged as a Cyclic Example

Guidelines for Avoiding Unwanted Recursion in a Chart

• Watching Data Values with Debuggers

Watching Data in the Stateflow Debugger

Watching Stateflow Data in the MATLAB Command Window

• Monitoring Test Points in Stateflow Charts

About Test Points in Stateflow Charts

Setting Test Points for Stateflow States and Local Data with the Model Explorer

Logging Chart Signals Using the Signal Logging Dialog Box

Logging Chart Signals Using the Command-Line API

Using a Floating Scope to Monitor Data Values and State Activity

• Understanding Model Coverage for Stateflow Charts

What Is Model Coverage?

How Model Coverage Reports Work for Charts

Specifying Coverage Report Settings

Cyclomatic Complexity

Decision Coverage

Condition Coverage

Coverage Reports for Stateflow Charts

Colored Stateflow Chart Coverage Display

• Exploring and Modifying Charts

• Using the Model Explorer with Stateflow Objects

Viewing Stateflow Objects in the Model Explorer

Editing States or Charts in the Model Explorer

Adding Data and Events in the Model Explorer

Adding Custom Targets in the Model Explorer

Renaming Objects in the Model Explorer

Setting Properties for Stateflow Objects in the Model Explorer

Moving and Copying Data, Events, and Targets in the Model Explorer

Changing the Port Order of Input and Output Data and Events

Deleting Data, Events, and Targets in the Model Explorer

• Using the Stateflow Search & Replace Tool

Opening the Search & Replace Tool

Using Different Search Types

Specifying the Search Scope

Using the Search Button and View Area

Specifying the Replacement Text

Using the Replace Buttons

Search and Replace Messages

• Finding Stateflow Objects

Types of Finder Tools

Opening Stateflow Finder

Using Stateflow Finder

Finder Display Area

• Semantic Rules Summary

Entering a Chart

Executing an Active Chart

Entering a State

Executing an Active State

Exiting an Active State

Executing a Set of Flow Graphs

Executing an Event Broadcast

• Semantic Examples

Categories of Semantic Examples

• Transitions to and from Exclusive (OR) States Examples

Label Format for a State-to-State Transition Example

Transitioning from State to State with Events Example

Transitioning from a Substate to a Substate with Events Example

• Condition Action Examples

Condition Action Example

Condition and Transition Actions Example

Condition Actions in For-Loop Construct Example

Condition Actions to Broadcast Events to Parallel (AND) States Example

Cyclic Behavior to Avoid with Condition Actions Example

• Default Transition Examples

Default Transition in Exclusive (OR) Decomposition Example

Default Transition to a Junction Example

Default Transition and a History Junction Example

Labeled Default Transitions Example

• Inner Transition Examples

Processing Events with an Inner Transition in an Exclusive (OR) State Example

Processing Events with an Inner Transition to a Connective Junction Example

Inner Transition to a History Junction Example

• Connective Junction Examples

Label Format for Transition Segments Example

If-Then-Else Decision Construct Example

Self-Loop Transition Example

For-Loop Construct Example

Flow Graph Notation Example

Transitions from a Common Source to Multiple Destinations Example

Transitions from Multiple Sources to a Common Destination Example

Transitions from a Source to a Destination Based on a Common Event Example

Backtracking Behavior in Flow Graphs Example

Event Actions in a Superstate Example

• Parallel (AND) State Examples

Event Broadcast State Action Example

Event Broadcast Transition Action with a Nested Event Broadcast Example

Event Broadcast Condition Action Example

• Directed Event Broadcasting Examples

Directed Event Broadcast Using Send Example

Directed Event Broadcast Using Qualified Event Name Example

• Using the API

• Overview of the Stateflow API

What Is the Stateflow API?

Stateflow API Object Hierarchy

Getting a Handle on Stateflow API Objects

What Are API Object Properties and Methods?

• Quick Start for the Stateflow API

Creating a New Model and Chart

Accessing the Model Object

Accessing the Chart Object

Creating New Objects in the Chart

• Accessing the Properties and Methods of Objects

Naming Conventions for Properties and Methods

Using Dot Notation with Properties and Methods

Using Function Notation with Methods

• Displaying Properties and Methods

Displaying Properties

Displaying the Names of Methods

Displaying Property Subproperties

Displaying Enumerated Values for Properties

• Creating and Destroying API Objects

About Creating and Destroying API Objects

Creating Stateflow Objects

Establishing the Parent (Container) of an Object

Destroying Stateflow Objects

• Accessing Existing Stateflow Objects

About Stateflow Object Handles

Finding Objects and Properties

Finding Objects at Different Levels of Containment

Retrieving Recently Selected Objects

Getting and Setting the Properties of Objects

• Moving Graphical Objects

How to Move Objects Programmatically

Example of Moving Subcharted States

Rules for Moving Objects Programmatically

• Copying Objects

Accessing the Clipboard Object

copy Method Limitations

Copying by Grouping (Recommended)

Copying Objects Individually

• Using the Editor Object

About Editor Objects

Accessing the Editor Object

Changing the Display in the Stateflow Editor

Entering Multiline Labels

Creating Default Transitions

Making Supertransitions

Creating a MATLAB Script of API Commands

• API Object Reference

Reference Table Column Descriptions

All Object Methods

Chart Properties

Clipboard Methods

Constructor Methods

Data Properties

Editor Properties

Embedded MATLAB Function Properties

Embedded MATLAB Function Methods

Event Properties

Graphical Function Properties

Graphical Function Methods

Junction Properties

Junction Methods

Machine Properties

Machine Methods

Note Properties

Simulink Function Properties

Simulink Function Methods

State Properties

• Target Properties

CodeFlagsInfo Property of Targets

Transition Properties

Transition Methods

Truth Table Properties

Truth Table Methods

Truth Table Chart Properties

Truth Table Chart Methods

• API Object Properties and Methods

API Method Reference

• Release Notes

Stateflow roadmap
page

	Functions:
	By Category
	Alphabetical List

	API Properties and Methods:
	By Category
	Alphabetical List



	Documentation Set

	Getting Started
	Introduces you to Stateflow software and gets you started using it

	User's Guide
	Provides tutorials and comprehensive information about the elements of Stateflow software

	Examples in Documentation
	Lists major examples in Stateflow documentation



	Product Demos

	Stateflow 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, and upgrade issues



	Printable (PDF) Documentation on the Web

PDF documents reflect the most recent version of Stateflow software and might describe features not available in earlier versions of the software.
	Stateflow Getting Started Guide
	Stateflow User's Guide
	Stateflow Reference
	Stateflow API
	Stateflow 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