• Laying Out the Model Architecture

• Creating Subsystems

• Creating Model Components

• Creating Reusable Components

• Supporting Shared Utility Directories in the Build Process

• Creating Component Object Libraries and Enhancing Simulation Performance

• Combining Multiple Models

  Simulink Built-In Blocks That Support Code Generation

  Block Set Support for Code Generation

  User-Created Block Considerations

  Introduction

• Single-Tasking and Multitasking Execution Modes

• Handling Rate Transitions

• Example: Single-Tasking and Multitasking Execution of a Model

• Handling Asynchronous Events

• Using Timers

• Configuring Scheduling

  Overview

• Sample Time Propagation

  Latches for Subsystem Blocks

  Block Execution Order

• Algebraic Loops

  Introduction

  Nontunable Parameter Storage

• Tunable Parameter Storage

  Tunable Parameter Storage Classes

• Using the Model Parameter Configuration Dialog Box

• Tunable Expressions

• Linear Block Parameter Tunability

  Parameter Configuration Quick Reference Diagram

  Generated Code for Parameter Data Types

• Tunable Workspace Parameter Data Type Considerations

  Parameter Tuning by Using MATLAB Commands

  Introduction

• Signal Storage Concepts

• Signals with Auto Storage Class

  Signals with Test Points

  Interfacing Signals to External Code

  Symbolic Naming Conventions for Signals in Generated Code

  Summary of Signal Storage Class Options

• Monitoring Signals With the C API

  Introduction

• Parameter Objects

  Parameter Object Configuration Quick Reference Diagram

• Signal Objects

• Using Signal Objects to Initialize Signals and Discrete States

• Resolving Conflicts in Configuration of Parameter and Signal Objects

  Customizing Code for Parameter and Signal Objects

  Using Objects to Export ASAP2 Files

  About Enumerated Data Types

  Default Code for an Enumerated Data Type

  Enumerated Type Safe Casting

• Overriding Default Methods (Optional)

  How emlc Works with Enumerated Types

  Enumerated Type Limitations

  Introduction

  Block State Storage

• Block State Storage Classes

  Using the State Attributes Tab to Interface States to External Code

• Symbolic Names for Block States

  Block States and Simulink Signal Objects

  Summary of State Storage Class Options

  About Simulink Data Stores

  Storage Classes for Data Store Memory Blocks

  Data Store Memory Blocks and Simulink Signal Objects

  Nonscalar Data Stores in Generated Code

  Data Store Buffering in Generated Code

• Getting Familiar With Model Configuration Options That Pertain To Code Generation

  Configuring Code Generation Objectives

  Configuring a Model from the MATLAB Command Window

  Introduction

  Targets and Code Formats

  Targets and Code Styles

• Available Targets

• Selecting a Target

• Targets and Code Formats

• Template Makefiles and Make Options

  Custom Targets

  Configuring Code Comments

• Configuring Generated Identifiers

• Generated Source Files and File Dependencies

• Understanding How Code Is Generated From a Model

  Generating a Report

• Reviewing Generated Code

• Choosing and Configuring a Compiler

• Configuring the Build Process

  Initiating the Build Process

• Files and Directories Created by the Build Process

  Rebuilding a Model

  Reducing Build Time for Referenced Models

• Understanding the Build Process

• Relocating Code to Another Development Environment

  Optimization Parameters Overview

• Optimizing Models

• Minimizing Computations and Storage for Intermediate Results

• Block Diagram Performance Tuning

• Optimizing Signals

• Inlining Parameters

  Configuring a Loop Unrolling Threshold

• Optimizing Code Generated for Vector Assignments

  Controlling Memory Allocation for Time Counters

• Optimizing Code Resulting from Floating-Point to Integer Conversions

  Optimization Dependencies

  Controlling the Compiling and Linking Phases of the Build Process

  Cross-Compiling Code Generated on a Microsoft Windows System

• Controlling the Location and Naming of Libraries During the Build Process

  Recompiling Precompiled Libraries

• Customizing Post Code Generation Build Processing

• Configuring Generated Code with TLC

  Converts M-code to C Code

  Running a Demo of Embedded MATLAB Coder

  How Embedded MATLAB Coder Resolves Function Calls

  Workflow for Converting M-Code to Embeddable C Code

  Workflow for Converting M-Code to a C MEX Function

  How to Set Up Your C Compiler

  Supported Compilers for Generating MEX Functions

  Supported Compilers for Generating C Code

  Compile Path Search Order

  Can I Add Files to the Embedded MATLAB Path?

  When to Use the Embedded MATLAB Path

  Adding Directories to Search Paths

  Naming Conventions

  Debugging Strategies

  Detecting Embedded MATLAB Syntax Violations at Compile Time

  Types of Configuration Objects

  Working with Configuration Objects

  Creating Configuration Objects

  Modifying Configuration Objects

  Saving Configuration Objects

  Why You Must Specify Input Properties

  Properties to Specify

  Rules for Specifying Properties of Primary Inputs

  Methods for Defining Properties of Primary Inputs

  Defining Input Properties by Example at the Command Line

  Defining Input Properties Programmatically in the M-File

  Types of Targets

  Specifying the Target to the Compiler

  Relationship of Targets and Configuration Objects

  Location of Generated Files

  Specifying main Functions for C Executables

  Before Compiling Your M-Code

  Running Embedded MATLAB Coder

  Specifying Compiler Options

  Specifying Custom Files to Build

  Partitioning Generated Files

  How to Select the File Partitioning Method

  Partitioning Generated Files When You Generate One C File Per M-File

  Generated Files and Locations

  File Partitioning and Inlining

  About Compilation Reports

  Generating Compilation Reports

  Names and Locations of Compilation Reports

  Opening Compilation Reports

  Description of Compilation Reports

  Viewing Your M-Code

  Viewing Call Stack Information

  Viewing the Generated C Code

  Viewing the Compilation Summary Information

  Viewing Error and Warning Messages

  Viewing Variables in Your M-Code

  Viewing Target Build Information

  Keyboard Shortcuts for the Compilation Report

  Embedded MATLAB Coder Compilation Report Limitations

  Calling C Functions from the Embedded MATLAB Subset

  Calling Initialize and Terminate Functions

  Calling C Functions with Multiple Outputs

  Calling C Functions that Return Arrays

  About Custom C Code Integration with Embedded MATLAB Coder

  Specifying Custom C Files on the Command Line

  Specifying Custom C Files with Configuration Objects

  How Embedded MATLAB Functions Use the BLAS Library

  When to Disable BLAS Library Support

  How to Disable BLAS Library Support

  Supported Compilers

  Types of Runtime Checks

  When to Disable Runtime Checks

  How to Disable Runtime Checks

  About the Runtime Stack

  When to Use the Runtime Stack

• Integration Options

  Making External Code Language Compatible With Generated Code

  Custom Code Library

  Example: Using a Custom Code Block

  Custom Code in Subsystems

  Preventing User Source Code from Being Deleted from Build Directories

• Introduction to S-Functions for Code Generation

• Writing Noninlined S-Functions

• Writing Wrapper S-Functions

• Writing Fully Inlined S-Functions

• Automating the Generation of Files for Fully Inlined S-Functions Using Legacy Code Tool

• Writing Fully Inlined S-Functions with the mdlRTW Routine

  Guidelines for Writing Inlined S-Functions

• Writing S-Functions That Support Expression Folding

  Writing S-Functions That Specify Port Scope and Reusability

  Writing S-Functions That Specify Sample Time Inheritance Rules

  Writing S-Functions That Support Code Reuse

• Writing S-Functions for Multirate Multitasking Environments

• Build Support for S-Functions

• Configuring the Hardware Implementation

• Configuring the Target Hardware Environment

• Resources for Wind River Systems Tornado Applications

• Wind River Systems Tornado Application Architecture

• Installing the Wind River Systems Tornado Software

• Implementing a Wind River Systems Tornado Application

  Building the Application

  Automatic Download and Execution

• Manual Download and Execution

  Introduction

• Generating C API Files

• Description of C API Files

• Using the C API in an Application

  C API Limitations

  Overview

  Targets Supporting ASAP2

• Defining ASAP2 Information

• Generating an ASAP2 File

• Customizing an ASAP2 File

  Structure of the ASAP2 File

  Generating ASAP2 and C API Files

  Introduction

• Using the External Mode User Interface

• External Mode Compatible Blocks and Subsystems

• External Mode Communications Overview

• Client/Server Implementations

  Using External Mode Programmatically

• Creating a TCP/IP Transport Layer for External Communication

• External Mode Limitations

  About Logging to MAT-Files

• Configuring a Model to Log States, Time, and Output

  Logging Data with Scope and To Workspace Blocks

  Logging Data with To File Blocks

  Data Logging Differences in Single- and Multitasking Models

  About Shared Utility Functions

  Controlling Shared Utility Function Generation

  rtwtypes.h and Shared Utility Functions

  Incremental Shared Utility Function Generation and Compilation

  Shared Utility Checksum

  Shared Fixed-Point Utility Functions

  About Host-Based Simulation

  Host-Based Simulation Performance

  Goals of Host-Based Simulation

  Running Host-Based Simulations

  About Rapid Simulation

  Rapid Simulation Performance

  General Rapid Simulation Workflow

  Identifying Your Rapid Simulation Requirements

  Configuring Inport Blocks to Provide Rapid Simulation Source Data

  Configuring and Building a Model for Rapid Simulation

• Setting Up Rapid Simulation Input Data

  Programming Scripts for Batch and Monte Carlo Simulations

• Running Rapid Simulations

  Rapid Simulation Target Limitations

  About Generated Code Verification

• Tracing Generated Code

• Profiling Code Performance

  About Rapid Prototyping

• Rapid Prototyping System Simulations

• Rapid Prototyping a Real-Time System

  About Software-In-the-Loop Simulation

  Maintaining Bit-True Agreement Between Host Simulations and Code for Target Deployment

  Setting Up and Running SIL Simulations Using a Hand-Written S-Function Wrapper

  About Hardware-In-the-Loop Simulation

  Setting Up and Running HIL Simulations

  Compiler Version Mismatch Errors

  Generated Executable Image Produces Incorrect Results

  Compile-Time Errors

• What Is the Target Language Compiler?

• Target Language Compiler Capabilities

• Code Generation Process

• The Advantages of Inlining S-Functions

• Where to Go from Here

  Code Architecture

• Target Language Compiler Overview

• Inlining S-Functions

  Introduction

• Reading Record Files with TLC

• Inlining S-Functions with TLC

• Exploring Variable Names and Loop Rolling

• Debugging Your TLC Code

• Using TLC Code Coverage to Aid Debugging

• Wrapping User Code with TLC

• Build Process

• Configuring TLC

• Code Generation Concepts

• TLC Files

• Data Handling with TLC: an Example

  Introduction to the model.rtw File

  Using Scopes in the model.rtw File

• Object Information in the model.rtw File

• Data References in the model.rtw File

• Using Library Functions to Access model.rtw

• Target Language Compiler Directives

• Command-Line Arguments

• About the TLC Debugger

• Using the TLC Debugger

• TLC Coverage

• TLC Profiler

  Introduction

• Writing Block Target Files to Inline S-Functions

• Inlining C MEX S-Functions

  Inlining M-File S-Functions

  Inlining Fortran (F-MEX) S-Functions

• TLC Coding Conventions

• Block Target File Methods

  Loop Rolling

  Error Reporting

  Obsolete Functions

• Target Language Compiler Function Conventions

• Input Signal Functions

• Output Signal Functions

• Parameter Functions

• Block State and Work Vector Functions

• Block Path and Error Reporting Functions

• Code Configuration Functions

• Sample Time Functions

• Other Useful Functions

• Advanced Functions

• Generating Errors from TLC Files

• TLC Error Messages

  TLC Function Library Error Messages

  Real-Time Workshop: General Tab Overview

  System target file

  Language

  Compiler optimization level

  Custom compiler optimization flags

  TLC options

  Generate makefile

  Make command

  Template makefile

  Ignore custom storage classes

  Ignore test point signals

  Select objective

  Prioritized objectives

  Set objectives

  Configuration Set Objectives Dialog Box

  Check model

  Check model before generating code

  Generate code only

  Build/Generate code

  Real-Time Workshop: Report Tab Overview

  Create code generation report

  Launch report automatically

  Code-to-model

  Model-to-code

  Configure

  Eliminated / virtual blocks

  Traceable Simulink blocks

  Traceable Stateflow objects

  Traceable Embedded MATLAB functions

  Real-Time Workshop: Comments Tab Overview

  Include comments

  Simulink block / Stateflow object comments

  Show eliminated blocks

  Verbose comments for SimulinkGlobal storage class

  Simulink block descriptions

  Simulink data object descriptions

  Custom comments (MPT objects only)

  Custom comments function

  Stateflow object descriptions

  Requirements in block comments

  Real-Time Workshop: Symbols Tab Overview

  Global variables

  Global types

  Field name of global types

  Subsystem methods

  Subsystem method arguments

  Local temporary variables

  Local block output variables

  Constant macros

  Minimum mangle length

  Maximum identifier length

  Generate scalar inlined parameter as

  Signal naming

  M-function

  Parameter naming

  #define naming

  Use the same reserved names as Simulation Target

  Reserved names

  Real-Time Workshop: Custom Code Tab Overview

  Use the same custom code settings as Simulation Target

  Use local custom code settings (do not inherit from main model)

  Source file

  Header file

  Initialize function

  Terminate function

  Include directories

  Source files

  Libraries

  Real-Time Workshop: Debug Tab Overview

  Verbose build

  Retain .rtw file

  Profile TLC

  Start TLC debugger when generating code

  Start TLC coverage when generating code

  Enable TLC assertion

  Real-Time Workshop: Interface Tab Overview

  Target function library

  Utility function generation

  Support: floating-point numbers

  Support: absolute time

  Support: non-finite numbers

  Support: continuous time

  Support: complex numbers

  Support: non-inlined S-functions

  Support: variable-size signals

  Multiword type definitions

  Maximum word length

  GRT compatible call interface

  Single output/update function

  Terminate function required

  Generate reusable code

  Reusable code error diagnostic

  Pass root-level I/O as

  Block parameter visibility

  Internal data visibility

  Block parameter access

  Internal data access

  External I/O access

  Generate destructor

  Use operator new for referenced model object registration

  Generate preprocessor conditionals

  Suppress error status in real-time model data structure

  Configure Model Functions

  Configure C++ Encapsulation Interface

  Create Simulink (S-Function) block

  Enable portable word sizes

  MAT-file logging

  MAT-file variable name modifier

  Interface

  Signals in C API

  Parameters in C API

  Transport layer

  MEX-file arguments

  Static memory allocation

  Static memory buffer size

  Real-Time Workshop: RSim Target Tab Overview

  Enable RSim executable to load parameters from a MAT-file

  Solver selection

  Force storage classes to AUTO

  Real-Time Workshop S-Function Code Generation Options Tab Overview

  Create new model

  Use value for tunable parameters

  Include custom source code

  Real-Time Workshop: Tornado Target Tab Overview

  Target function library

  Utility function generation

  MAT-file logging

  MAT-file variable name modifier

  Code Format

  StethoScope

  Download to VxWorks target

  Base task priority

  Task stack size

  External mode

  Transport layer

  MEX-file arguments

  Static memory allocation

  Static memory buffer size

  Recommended Settings Summary

  Parameter Command-Line Information Summary

  Real-Time Workshop Dialog Box Overview

  General Tab

  Report Tab

  Symbols Tab

  Custom Code Tab

  Debug Tab

  Interface Tab

  Advanced Tab

  Generate code only

  Automatic C MEX Generation Dialog Box Overview

  General Tab

  Report Tab

  Symbols Tab

  Custom Code Tab

  Advanced Tab

  Hardware Implementation Parameters Dialog Box Overview

  Hardware Implementation Parameters

  Compiler Options Parameters Dialog Box Overview

  Compiler Options Parameters

  Real-Time Workshop Overview

  Check solver for code generation

  Identify questionable blocks within the specified system

  Check for model reference configuration mismatch

  Check the hardware implementation

  Identify questionable software environment specifications

  Identify questionable code instrumentation (data I/O)

  Check for blocks that have constraints on tunable parameters

  Identify questionable subsystem settings

  Disable signal logging

  Identify blocks that generate expensive saturation and rounding code

  Check sample times and tasking mode

  Identify questionable fixed-point operations

  Check model configuration settings against code generation objectives