Use Variant Subsystem Blocks with Conditionally Executed Subsystems
You can use conditionally executed subsystems that use control input ports such as Enabled, Triggered, Reset, and the Function-Call subsystems as variant choices within the Variant Subsystem block. For more information on conditionally executed systems, see Conditionally Executed Subsystems Overview.
Note
When the Variant activation time parameter of the
Variant Subsystem block is set to code
compile
, the type of control port blocks in all the variant
choices must be same. For example, you cannot use Enabled
Subsystem and Function-Call Subsystem blocks as
choices within a Variant Subsystem block that has code
compile
activation time.
The control input ports on the variant choice blocks and the corresponding input port on the parent Variant Subsystem block must have the same name.
Create a Variant Subsystem with Enabled Subsystem as Choice
Consider this model with a Variant Subsystem block named
Controller
and two Enabled Subsystem blocks,
Linear
and Nonlinear
, as variant choices.
The variant conditions on the Linear
and
Nonlinear
blocks are VSSMODE==0
and
VSSMODE==1
, respectively. If you use an Enabled
Subsystem block for the Linear
choice, then the
Nonlinear
choice must also be an Enabled
Subsystem.
When you generate code from this model, the Linear
and
Nonlinear
choices are guarded by the corresponding variant
conditions.
step() { #if VSSMODE==0 // code for Linear choice ....... #elif VSSMODE==1 // code for Nonlinear choice ....... #endif
Use Variant Subsystem Block to Create an Export-Function Model
Export-function models are Simulink® models that generate code for independent functions that can be integrated with an external environment and scheduler. You can use a Variant Subsystem block with Function-Call Subsystem blocks as variant choices to create an export-function model. For more information on export-function models, see Export-Function Models Overview.
Consider a model containing a Variant Subsystem block named
VariantFcnCall
with two Function-Call
Subsystem blocks, Linear
and
Nonlinear
, as variant choices. The variant conditions set on
Linear
and Nonlinear
choices are
VSS_MODE==0
and VSS_MODE==1
, respectively.
The VariantFcnCall
block has a root level function-call inport
block, fcn
, and the same name is given to the control ports on
the Linear
and Nonlinear
choice blocks. The
Variant activation time parameter of
VariantFcnCall
is set to code
compile
.
You can also have a similar modeling pattern with a multi-point entry function using Model blocks.
In this example, the inputs fcln1
, fcln2
,
and fcln3
are routed through a Variant Subsystem
block, Model
, that uses Model blocks as variant
choices.
Code Generation for Export-Function Model
When you generate code from this model, the definition of the export function,
fcn
, contains the C
preprocessor
conditionals #if
and #endif
. The code for
Linear
and Nonlinear
choices are
guarded by the corresponding variant conditions. For more information on
configuring the model to generate code, see Prepare Variant-Containing Model for Code Generation.
void fcn(void) { /* RootInportFunctionCallGenerator: '<Root>/RootFcnCall_InsertedFor_fcn_at_outport_1' */ #if VSSMODE == 0 rtDWork.Linear.DiscreteFilter = rtU.In1 - 0.5 * rtDWork.Linear.DiscreteFilter_states; rtDWork.Linear.DiscreteFilter_states = rtDWork.Linear.DiscreteFilter; #endif /* VSSMODE == 0 */ #if VSSMODE == 1 rtDWork.Nonlinear.DiscreteFilter = look1_binlxpw(rtU.In1, rtCP_LookupTable_bp01Data, rtCP_LookupTable_tableData, 4U) - 0.5 * rtDWork.Nonlinear.DiscreteFilter_states; rtDWork.Nonlinear.DiscreteFilter_states = rtDWork.Nonlinear.DiscreteFilter; #endif /* VSSMODE == 1 */ #if VSSMODE == 0 rtY.Out1 = rtDWork.Linear.DiscreteFilter; #endif /* VSSMODE == 0 */ #if VSSMODE == 1 rtY.Out1 = rtDWork.Nonlinear.DiscreteFilter; #endif /* VSSMODE == 1 */ }
Guard Export Function Definition in Generated Code
To guard the whole definition of the export function, fcn
,
using a variant condition, use a Variant Source block as shown in
this example.
In the generated code, the definition of the export function,
fcn()
, is guarded with A==1
.
#if A == 1 void fcn(void) { ….. } #endif
This function can be referred using a code snippet similar to this one.
….. #if A==1 fcn() #endif ……
Propagate Variant Conditions from Variant Subsystem Blocks to Conditional Subsystems
When you propagate a variant condition to a conditional subsystem, the same condition is set to all ports.
Consider this model. The Variant Subsystem block,
VariantFcnCall
, has conditional subsystem blocks as choices.
The inport fcn
on VariantFcnCall
corresponds
to the control input ports on the variant choice blocks. A single-input,
single-output Variant Source block with the condition
A==1
is connected to the fcn
port. The
VariantFcnCall
block gets the variant condition of the signal
connected to the fcn
port. The condition assigned to the block
then propagates to the blocks connected to its input and output ports. When you
simulate this model after setting A=1
, the variant condition
A==1
propagates to the VariantFcnCall
block and to the In1
and Out1
blocks connected
to it, as shown in the Variant Conditions Legend.
Limitations
These conditions are not supported when using conditionally executed systems as variant choices within a Variant Subsystem block:
Action Port blocks in the variant choices.
Iterator Port blocks in the variant choices of a Variant Subsystem with Variant activation time set to
code compile
.Configuring a model as an AUTOSAR component with runnable as a variant subsystem choice.
Initialize Function, Reset Function, Terminate Function, and Simulink Function blocks.
Note
Initialize and Terminate event ports are always unconditional because they control both the model default and block-specific initialize and terminate events of the referenced model. If you define an Initialize function block in the referenced model, it corresponds to an explicit initialize event.