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.

When you use conditionally executed subsystems as variant choices:

The type of control port blocks in all the variant choices must be same as the Variant Subsystem block. For example, you cannot use Enabled Subsystem and Function-Call Subsystem blocks as choices within a Variant Subsystem block.
The control port on the Variant Subsystem block and the corresponding control ports on its variant choices must have the same name. For example, if the name of the control port on the Variant Subsystem is fcn, then the name of the corresponding control ports on all its variant choices must also be fcn.

Note

The properties set on the control ports that are inside the Variant Subsystem block are ignored during simulation and code generation.

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. If you use a Function-Call Subsystem block for the Linear choice, then the Nonlinear choice must also be a Function-Call Subsystem.

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 with Variant activation time of VariantFcnCall set to code compile, the definition of the export functionfcn contains the C preprocessor conditionals #if and #endif. The code for Linear and Nonlinear choices are guarded by the corresponding variant conditions. When you generate code from this model with Variant activation time of VariantFcnCall set to startup, the definition of the export function, fcn, contains the regular if conditions. The code for Linear and Nonlinear choices are guarded by the corresponding variant conditions.

This is the code generated with the activation time set to code compile. 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 with the Variant activation time set to code compile as shown in this example.

Note

The function definition is guarded only when the activation time is set to code compile. The function definition is not guarded for blocks with startup activation time.

Guard the definition of an export function using a Variant Source block

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.