| 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
- 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
- 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
- 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...
- 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
- 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
- Nonvirtual Subsystem Code Generation
- Nonvirtual Subsystem Code Generation Options
- Modularity of Subsystem Code
- Code Reuse Diagnostics
- Generating Code and Executables from Subsystems
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- Introduction
- Interrupt Handling
- Interrupt Control Block
- Task Synchronization Block
- Asynchronous Rate Transition Block
- Unprotected Asynchronous Rate Transition Block
- Creating a Customized Asynchronous Library
- 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
- 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
- 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
| | Getting Started | |