To combine code, which the code generator produces for multiple models or multiple instances of a model, into one executable program, use these techniques:
If you have Embedded Coder® software, interface the code for multiple models to a common
harness program. From the harness program, call the entry-point functions
generated for each model. The
ert.tlc system target file
has restrictions, related to embedded processing that might be incompatible
with your application.
Generate reusable, multi-instance code that is reentrant. See Combine Code Generated for Multiple Models or Multiple Instances of a Model.
The S-function system target (
rtwsfcn.tlc) does not support
combining code generated for multiple models.
To combine models for simulation and code generation, consider using model referencing. Model referencing helps with:
Symbol naming consistency
Required scheduling of the overall algorithm
Model configuration consistency
If you combine code generated for different models that is, without using referenced models, consider the following:
Data is global. Symbol (name) clashes can result.
Configuration parameter settings for the models must match, including settings such as hardware word sizes.
Reuse and sharing of code can be suboptimal (for example, duplicate code for shared utility functions, scheduling, and solvers).
Scheduling can be more complex (for example, models can have periodic sample times that are not multiples of each other, making scheduling from a common timer interrupt more complicated)
For plant models that use continuous time and state, the continuous time signals connecting models are not handled by a single solver like continuous time signals within a model, which can lead to subtle, numeric differences.
Use unidirectional signal connections between models. These connections affect
the order in which models are called. For example, if you use an output signal
modelA as input to
modelA output computation is called first.
When combining code generated for multiple models or multiple instances of a model:
Configure the models by using the same solver mode (single-tasking or multitasking).
If the models use continuous states, configure the models by using the same solver.
If the base rates for the models differ, the main program (such as
rt_malloc_main.c) must set up the timer interrupt to
occur at the greatest common divisor rate of the models. The main program calls
each model at a time interval.
A multiple-model program can log data to separate MAT-files for each model.
Only one of the models in a multiple-model program can use external mode.
If you have Embedded Coder software, you can specify an owner for individual data items such as
signals, parameters, and states. The owner of a data item generates the definition,
the memory allocation and initialization, for the data item. For example, if you
apply a storage class to a
so that it appears as a global variable in the generated code, specify one of the
combined models as the owner of the object. The code generated for that model
defines the variable.
If you use model referencing, you can modularize the generated code and establish clear ownership of data when you work in a team.
If you do not use model referencing, you can prevent generation
of duplicate definitions for a data item. For example, suppose you
Simulink.Parameter object in the base workspace
and apply the storage class
you generate code from two separate models that use the object, each
model generates a definition for the corresponding global variable.
Instead, you can specify an owner for the object so that only the
owner generates a definition.
To specify an owner for a data item:
Apply a storage class to the data item. See Organize Parameter Data into a Structure by Using Struct Storage Class (Embedded Coder).
Configure the owner of the data item by specifying a value for the Owner property.
Select the model configuration parameter Use owner from data object for data definition placement.
For more information about controlling ownership and file placement of data definitions and declarations, see Control Placement of Global Data Definitions and Declarations in Generated Files (Embedded Coder).
For each model that you are combining code for, generate the code.
Set the system target file to a GRT- or ERT-based system target file. The system target file for the models that you combine must be the same.
If you intend to have multiple instances of that model in the application,
set the model configuration parameter Code interface
Reusable function. If
you specified an ERT-based system target file, optionally, you can set the
model configuration parameter Use dynamic memory allocation for
model initialization, depending on whether you want to
statically or dynamically allocate the memory for each instance of the
Generate source code. The code generator includes
an allocation function in the generated file
The allocation function dynamically allocates model data for each
instance of the model.
After generating source code for each model:
Compile the code for each model that you are combining.
Combine the makefiles generated for the models into one makefile.
Create a combined simulation engine by
modifying a main program, such as
The main program initializes and calls the code generated for each
Run the makefile. The makefile links the object files and the main program to an executable program.