Real-Time Workshop

Open Architecture of Real-Time Workshop

Real-Time Workshop is an open system designed for use with a wide variety of operating environments and hardware types. Figure 1-4 shows how you can extend key elements of Real-Time Workshop.

You can configure the Real-Time Workshop program generation process to your own needs by modifying the following components:

• Simulink and the model file (model.mdl)

• Simulink provides a very high-level language (VHLL) development environment. The language elements are blocks and subsystems that visually embody your algorithms. You can think of Real-Time Workshop as a compiler that processes a VHLL source program (model.mdl), and emits code suitable for a traditional high-level language (HLL) compiler.

  S-functions written in C let you extend the Simulink VHLL by adding new general purpose blocks, or incorporating legacy code into a block.

• The intermediate model description (model.rtw)

• The initial stage of the code generation process is to analyze the source model. The resultant description file contains a hierarchical structure of records describing systems and blocks and their connections.

  The S-function API includes a special function, mdlRTW, that lets you customize the code generation process by inserting parameter data from your own blocks into the model.rtw file.

• The Target Language Compiler (TLC) program

• The Target Language Compiler interprets a program that reads the intermediate model description and generates code that implements the model as a program.

  You can customize the elements of the TLC program in two ways. First, you can implement your own system target file, which controls overall code generation parameters. Second, you can implement block target files, which control how code is generated from individual blocks such as your own S-function blocks.

Figure 1-4: Real-Time Workshop Architecture

• Source code generated from the model; for descriptions of these files, see Summary of Files Created by the Build Procedure in the Real-Time Workshop Getting Started Guide.

• There are several ways to customize generated code, or interface it to custom code:
  • Exported entry points let you interface your hand-written code to the generated code. This makes it possible to develop your own timing and execution engine, or to combine code generated from several models into a single executable.
  • You can automatically make signals, parameters, and other data structures within generated code visible to your own code, facilitating parameter tuning and signal monitoring.
  • Prepare or modify Target Language Compiler script files to customize the transformation of Simulink blocks into source code. See the Target Language Compiler Reference Guide for further details.

• Run-time interface support files

• The run-time interface consists of code interfacing to the generated model code. You can create a custom set of run-time interface files, including:
  • A harness (main) program
  • Code to implement a custom external mode communication protocol
  • Code that interfaces to parameters and signals defined in the generated code
  • Timer and other interrupt service routines
  • Hardware I/O drivers

• The template makefile and model.mk

• A makefile, model.mk, controls the compilation and linking of generated code. Real-Time Workshop generates model.mk from a template makefile during the code generation and build process. You can create a custom template makefile to control compiler options and other variables of the make process.

All of these components contribute to the process of transforming a Simulink model into an executable program. The topics in the next section point you to documentation describing each of them.

Rapid Prototyping for Control Systems

Where to Find Help