Introducing Real-Time Workshop
What Is Real-Time Workshop?
Components and Features
Capabilities and Benefits
Accelerating Your Development Process
Installing Real-Time Workshop
Third-Party Compiler Installation on Windows
Supported Compilers
Compiler Optimization Settings
Real-Time Workshop Demos
Help and Documentation
Online Documentation
Printing the Documentation
For Further Information
Related Products
Typographical Conventions
Building an Application
Automatic Program Building
Steps in the Build Process
1. Analyze the Model
2. Call the Target Language Compiler to Generate Code
3. Generate a Customized Makefile
4. Create the Executable
Summary of Files Created by the Build Procedure
Working with Real-Time Workshop
Basic Real-Time Workshop Concepts
Target and Host
Available Target Configurations
Code Formats
The Generic Real-Time Target
Target Language Compiler Files
Template Makefiles
The Build Process
Model Parameters and Code Generation
Quick Start Tutorials
Tutorial 1: Building a Generic Real-Time Program
Tutorial 2: Data Logging
Tutorial 3: Code Validation
Tutorial 4: A First Look at Generated Code
Tutorial 5: Getting Started with External Mode Using GRT
Using Real-Time Workshop
Understanding Real-Time Workshop
Product Overview
Some Real-Time Workshop Capabilities
Software Design with Real-Time Workshop
The Rapid Prototyping Process
Key Aspects of Rapid Prototyping
Rapid Prototyping for Digital Signal Processing
Rapid Prototyping for Control Systems
Open Architecture of Real-Time Workshop
Where to Find Help
How Do I...
Code Generation and the Build Process
The Real-Time Workshop User Interface
Using the Real-Time Workshop Pane
Target Configuration Options
General Code Generation Options
General Code Generation Options (cont.)
General Code Appearance Options
Target-specific Code Generation Options
TLC Debugging Options
Real-Time Workshop Submenu
Simulation Parameters and Code Generation
Solver Options
Workspace I/O Options and Data Logging
Diagnostics Pane Options
Advanced Options Pane
Tracing Generated Code Back to Your Simulink Model
Other Interactions Between Simulink and Real-Time Workshop
Selecting a Target Configuration
The System Target File Browser
Available Targets
Making an Executable
Generated Source Files
Compilation and Linking
Choosing and Configuring Your Compiler
Template Makefiles and Make Options
Compiler-Specific Template Makefiles
Template Makefile Structure
Configuring the Generated Code via TLC
Target Language Compiler Variables and Options
Generated Code Formats
Introduction
Choosing a Code Format for Your Application
Real-Time Code Format
Unsupported Blocks
System Target Files
Template Makefiles
Real-Time malloc Code Format
Unsupported Blocks
System Target Files
Template Makefiles
S-Function Code Format
Embedded C Code Format
Building Subsystems
Nonvirtual Subsystem Code Generation
Nonvirtual Subsystem Code Generation Options
Modularity of Subsystem Code
Code Reuse Diagnostics
Generating Code and Executables from Subsystems
Working with Data Structures
Parameters: Storage, Interfacing, and Tuning
Storage of Nontunable Parameters
Tunable Parameter Storage
Storage Classes of Tunable Parameters
Using the Model Parameter Configuration Dialog
Tunable Expressions
Tunability of Linear Block Parameters
Parameter Configuration Quick Reference Diagram
Signals: Storage, Optimization, and Interfacing
Signal Storage Concepts
Signals with Auto Storage Class
Declaring Test Points
Interfacing Signals to External Code
Symbolic Naming Conventions for Signals in Generated Code
Summary of Signal Storage Class Options
C API for Parameter Tuning and Signal Monitoring
Target Language Compiler API for Parameter Tuning and Signal Monitoring
Parameter Tuning via MATLAB Commands
Simulink Data Objects and Code Generation
Overview
Parameter Objects
Parameter Object Configuration Quick Reference Diagram
Signal Objects
Signal Object Configuration Quick Reference Diagram
Resolving Conflicts in Configuration of Parameter and Signal Objects
Customizing Code for Parameter and Signal Objects
Using Objects to Export ASAP2 Files
Block States: Storing and Interfacing
Storage of Block States
Block State Storage Classes
Using the State Properties Dialog Box to Interface States to External Code
Symbolic Names for Block States
Block States and Simulink Signal Objects
Summary of State Storage Class Options
Storage Classes for Data Store Memory Blocks
Data Store Memory and Simulink Signal Objects
External Mode
Introduction
Using the External Mode User Interface
External Mode Related Menu and Toolbar Items
External Mode Control Panel
Connection and Start/Stop Controls
Target Interface Dialog Box
External Signal & Triggering Dialog Box
Data Archiving Dialog Box
Parameter Download Options
External Mode Compatible Blocks and Subsystems
Compatible Blocks
Signal Viewing Subsystems
External Mode Communications Overview
The Download Mechanism
Inlined and Tunable Parameters
The TCP/IP Implementation
Using the TCP/IP Implementation
The External Interface MEX-File
External Mode Compatible Targets
Running the External Program
Error Conditions
Implementing an External Mode Protocol Layer
Limitations of External Mode
Program Architecture
Introduction
Model Execution
Program Timing
Program Execution
External Mode Communication
Data Logging In Singletasking and Multitasking Model Execution
Rapid Prototyping and Embedded Model Execution Differences
Rapid Prototyping Model Functions
Embedded Model Functions
Rapid Prototyping Program Framework
Rapid Prototyping Program Architecture
Rapid Prototyping System-Dependent Components
Rapid Prototyping System-Independent Components
Rapid Prototyping Application Components
Embedded Program Framework
Models with Multiple Sample Rates
Introduction
Singletasking vs. Multitasking Environments
Executing Multitasking Models
Multitasking and Pseudomultitasking
Building the Program for Multitasking Execution
Singletasking
Building the Program for Singletasking Execution
Model Execution
Simulating Models with Simulink
Executing Models in Real Time
Singletasking vs. Multitasking Operation
Sample Rate Transitions
Data Transfer Problems
Rate Transition Block Options
Faster to Slower Transitions in Simulink
Faster to Slower Transitions in Real Time
Slower to Faster Transitions in Simulink
Slower to Faster Transitions in Real Time
Singletasking and Multitasking Execution of a Model: an Example
Singletasking Execution
Multitasking Execution
Optimizing the Model for Code Generation
General Modeling Techniques
Expression Folding
Expression Folding Example
Using and Configuring Expression Folding
Supporting Expression Folding in S-Functions
Categories of Output Expressions
Acceptance or Denial of Requests for Input Expressions
Utilizing Expression Folding in Your TLC Block Implementation
Conditional Branch Execution
Block Diagram Performance Tuning
Look-Up Tables and Polynomials
Accumulators
Use of Data Types
Stateflow Optimizations
Simulation Parameters
Compiler Options
The S-Function Target
Introduction
Intellectual Property Protection
Creating an S-Function Block from a Subsystem
Sample Time Propagation in Generated S-Functions
Choice of Solver Type
Tunable Parameters in Generated S-Functions
Automated S-Function Generation
Restrictions
Limitations on Use of Goto and From Blocks
Other Restrictions
Unsupported Blocks
System Target File and Template Makefiles
System Target File
Template Makefiles
Real-Time Workshop Rapid Simulation Target
Introduction
Licensing Protocols for Using Simulink Solvers in Executables
Building for the Rapid Simulation Target
Running a Rapid Simulation
Simulation Performance
Batch and Monte Carlo Simulations
Limitations
Targeting Tornado for Real-Time Applications
The Tornado Environment
Confirming Your Tornado Setup Is Operational
VxWorks Library
Run-Time Architecture Overview
Parameter Tuning and Monitoring
Implementation Overview
Adding Device Driver Blocks
Configuring the Template Makefile
Tool Locations
Building the Program
Downloading and Running the Executable Interactively
Asynchronous Support
Introduction
Interrupt Handling
Interrupt Control Block
Task Synchronization Block
Asynchronous Rate Transition Block
Unprotected Asynchronous Rate Transition Block
Creating a Customized Asynchronous Library
Targeting Real-Time Systems
Introduction
Components of a Custom Target Configuration
Code Components
User-Written Run-Time Interface Code
Run-Time Interface for Rapid Prototyping
Run-Time Interface for Embedded Targets
Control Files
Tutorial: Creating a Custom Target Configuration
Customizing the Build Process
System Target File Structure
Adding a Custom Target to the System Target File Browser
Template Makefiles
Creating Device Drivers
Inlined and Noninlined Drivers
Device Driver Requirements and Limitations
Parameterizing Your Driver
Writing a Noninlined S-Function Device Driver
Writing an Inlined S-Function Device Driver
Building the MEX-File and the Driver Block
Source Code for Inlined ADC Driver
Interfacing Parameters and Signals
Signal Monitoring via Block Outputs
C API for Parameter Tuning
Target Language Compiler API for Signals and Parameters
Creating an External Mode Communication Channel
The Design of External Mode
External Mode Communications Overview
External Mode Source Files
Guidelines for Implementing the Transport Layer
Combining Multiple Models
DSP Processor Support
For DSP Blockset Users
Glossary
Blocks That Depend on Absolute Time
Targeting DOS for Real-Time Applications
DOS Target Basics
DOS Device Drivers Library
Implementation Overview
System Configuration
Sample Rate Limits
Device Driver Blocks
Device Driver Block Library
Configuring Device Driver Blocks
Adding Device Driver Blocks to the Model
Building the Program
Running the Program
The Real-Time Workshop Development Process
Introduction
A Next-Generation Development Tool
Key Features
Benefits
Integration with Simulink
How MathWorks Tools Streamline Development
Code Formats
Target Environments
Code Generation Optimizations
An Open and Extensible Environment
Examples