# MODELS

MODELNAME: sl_subsys_swerr1
PATH: examples/simulink_features/main/sl_subsys_swerr1.slx
BLOCK: B;Discrete Pulse Generator;Gain;IfAction;In;Out;Pulse Generator;SubSystem;Switch-case;case body
BLOCKTYPE: ActionPort;DiscretePulseGenerator;Gain;Inport;Outport;Sum;SwitchCase
BLOCKTYPE_FREQUENCY: 1;2;1;1;2;1;1
CHECKSUM: 3E61B117DE05103801F753998F23E1F1
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Switch-case block and action subsystem illegal example This following model is an example of an illegal combination of a switch-case block executing the action subsystem case body. Block B is driving the case body block and must execute before the Switch-case block. However, the case body block needs to execute before B. This poses a causality problem. To execute case body, we must first execute Switch-case, before B. However, B must execute prior to Switch-case and, hence, the error.

ANNOTATION:
To fix the error, the feedback loop must be removed. This can be done by using a memory block or placing the loop within the case body. Switch-case block and action subsystem illegal example This following model is an example of an illegal combination of a switch-case block executing the action subsystem case body. Block B is driving the case body block and must execute before the Switch-case block. However, the case body block needs to execute before B. This poses a causality problem. To execute case body, we must first execute Switch-case, before B. However, B must execute prior to Switch-case and, hence, the error. Copyright 1990-2013 The MathWorks, Inc.


MODELNAME: sl_subsys_trig1
PATH: examples/simulink_features/main/sl_subsys_trig1.slx
DESCRIPTION: Latch vs. non-latched input ports example
BLOCK: Discrete Pulse Generator;In;Mux;Out;Scope;Sine Wave;SubSystem;Trigger;trigss
BLOCKTYPE: DiscretePulseGenerator;Inport;Mux;Outport;Scope;Sin;TriggerPort
BLOCKTYPE_FREQUENCY: 1;2;1;6;1;1;2
CHECKSUM: C9E8A75763F27C86FE0382850F64F5E8
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Latch vs. nonlatched input ports example. The following example illustrates the use of latched and non-latched triggered subsystems. Notice that the output of trigss2 is delayed by one time step when compared with trigss1. Copyright 1990-2013 The MathWorks, Inc.


MODELNAME: sl_subsys_trig2
PATH: examples/simulink_features/main/sl_subsys_trig2.slx
DESCRIPTION: Latched triggered subsystems in a loop
BLOCK: A;B;Constant;Discrete Pulse Generator;In;Out;SubSystem;Sum;Trigger;trigss
BLOCKTYPE: Constant;DiscretePulseGenerator;Gain;Inport;Outport;Sum;TriggerPort
BLOCKTYPE_FREQUENCY: 2;1;2;2;3;2;2
CHECKSUM: 050453CB0BD207016F870FD63CBEB1AA
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Latched triggered subsystems in a loop. In this example, latched triggered subsystems are used to allow execution of triggered subsystems in a loop.  Copyright 1990-2013 The MathWorks, Inc.


MODELNAME: sl_subsys_trig3
PATH: examples/simulink_features/main/sl_subsys_trig3.slx
DESCRIPTION: Latched triggered subsystems in a loop without other blocks
BLOCK: A;B;Constant;Discrete Pulse Generator;In;Out;SubSystem;Sum;Trigger;trigss
BLOCKTYPE: Constant;DiscretePulseGenerator;Gain;Inport;Outport;Sum;TriggerPort
BLOCKTYPE_FREQUENCY: 2;1;2;2;3;2;2
CHECKSUM: 6F511464882387EBFC3843858B6767D8
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Latched triggered subsystems in a loop without other blocks This example is similar to sl_subsys_trig2, except the gain blocks have been moved inside of the triggered subsystems (same answer). Copyright 1990-2013 The MathWorks, Inc.


MODELNAME: sl_subsys_trig4
PATH: examples/simulink_features/main/sl_subsys_trig4.slx
DESCRIPTION: Illustrates equivalence of port latch and memory block for triggered subsystems
BLOCK: Discrete Pulse Generator;In;Memory;Out;SubSystem;Sum;Trigger;Unit Delay;trigss
BLOCKTYPE: DiscretePulseGenerator;Inport;Memory;Outport;Sum;TriggerPort;UnitDelay
BLOCKTYPE_FREQUENCY: 1;2;1;4;2;2;2
CHECKSUM: EDEC4E38210222917FF529D8A3F883B9
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Latched input vs. memory block. This example is illustrating that a latch on an inport blocks is functionally equivalent to using a memory block. Copyright 1990-2013 The MathWorks, Inc.


MODELNAME: sl_subsys_trigerr1
PATH: examples/simulink_features/main/sl_subsys_trigerr1.slx
DESCRIPTION: Example of modeling error - ambiguous execution order due to nonlatched triggered subsystem
BLOCK: A;B;Constant;Discrete Pulse Generator;In;Out;SubSystem;Sum;Trigger;trigss
BLOCKTYPE: Constant;DiscretePulseGenerator;Gain;Inport;Outport;Sum;TriggerPort
BLOCKTYPE_FREQUENCY: 2;1;2;2;3;2;2
CHECKSUM: ECB0278867260E655EB597E9B109BD56
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Ambiguous execution order due to nonlatched triggered subsystem in loop. The following model uses triggered subsystems in a loop. To execute trigss1, we need the value produced by B, requiring us to execute B before trigss1. Likewise, to execute B, we must execute trigss2 and trigss2 requires that A first execute. However, A requires that trigss1 first execute. This data dependency cycle is an error. To fix the error, select Latch input by delaying outside signal on both triggered subsystem inport blocks Copyright 1990-2013 The MathWorks, Inc.


MODELNAME: sl_subsys_trigerr2
PATH: examples/simulink_features/main/sl_subsys_trigerr2.slx
DESCRIPTION: Example of modeling error - ambiguous execution order
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1;5;1;1;2;1
CHECKSUM: 1372A95EA03DE8E8627E21D709FB4E7F
PRODUCT: MATLAB;Simulink;Stateflow
PRODUCT_BASECODE: SL
ANNOTATION:
Ambiguous execution order due to data dependency conflict. The following model is a triggered subsystem that in turn executes a function-call subsystem. Examining the model, we see that block A must execute before the triggered subsystem because its output is used by the function-call subsystem, which is invoked by the triggered subsystem. However, block A must be executed after the triggered subsystem because it requires out1. This creates a data dependency problem. To fix the error, A must be placed within f() Copyright 1990-2013 The MathWorks, Inc.

BLOCK:
 Demux ; Ground ; SFunction ;A;Chart;Constant;Discrete Pulse Generator;In;Out;SubSystem;Sum;Trigger;Unit Delay;f;f();out;trigss

BLOCKTYPE:
Constant;Demux;DiscretePulseGenerator;Gain;Ground;Inport;Outport;S-Function;Sum;TriggerPort;UnitDelay


MODELNAME: sl_subsys_while1
PATH: examples/simulink_features/main/sl_subsys_while1.slx
DESCRIPTION: While-subsystem example
BLOCKTYPE_FREQUENCY: 1;1;1;2;2;4;1;1;1;1;1;1
CHECKSUM: 7837991440E49C9CF72D0CE7DD2B6CDC
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
This is an example of a while subsystem that is used to compute the sum of the numbers between 1 and N Copyright 1990-2023 The MathWorks, Inc.

BLOCK:
 Demux ; SFunction ; Terminator ;(u+(u+1))/;Data Type Conversion;Display;In;N;Out;Relational Operator;SubSystem;Sum;Unit Delay;While Iterator;While System;u;y

BLOCKTYPE:
Constant;DataTypeConversion;Demux;Display;Inport;Outport;RelationalOperator;S-Function;Sum;Terminator;UnitDelay;WhileIterator


MODELNAME: sl_subsys_while2
PATH: examples/simulink_features/main/sl_subsys_while2.slx
ANNOTATION: While Iterator Block Example Copyright 1990-2013 The MathWorks, Inc.
BLOCKTYPE: Constant;Display;Inport;Memory;Outport;RelationalOperator;Sum;WhileIterator
BLOCKTYPE_FREQUENCY: 2;1;2;1;2;2;1;1
CHECKSUM: 7318E392C3BE81902997488DCEDB307D
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
While Iterator Demonstration This model demonstrates how a While Iterator block can be used to run the blocks in a subsystem multiple number of times. In this case, there is a counter in the While Subsystem that adds up the numbers from 1 to N, where N is the number of iterations that have been run. The counter runs while this value is less than the input value to the subsystem. The number of iterations it took to exceed this value is shown in the display. In order to avoid an infinite loop, we have set the maximum number of iterations in the do-while loop to be 1000. This can be seen by double-clicking the While Iterator block. Also, since the algorithm does not make sense for non-positive inputs, we do not run any of the blocks in the While Subsystem if the input is less than one. 

BLOCK:
Constant;IC;In;Memory;Number of Iterations;Out;Relational Operator;SubSystem;Sum;While Iterator;While Subsystem


MODELNAME: sldemo_bpcheck
PATH: examples/simulink_features/main/sldemo_bpcheck.slx
BLOCKTYPE: Inport;Interpolation_n-D;Lookup_n-D;Outport;PreLookup
BLOCKTYPE_FREQUENCY: 5;5;1;6;3
CHECKSUM: 20783223A19D27FB647C46C5D6DAD832
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Breakpoint consistency checking between prelookup and interpolation ensures that the breakpoint arrays in the prelookup blocks are the same length as the corresponding dimensions of the connected interpolation blocks. In this model, the breakpoint arrays have deliberately been created with incorrect lengths to illustrate the breakpoint checking. Update diagram to see the error message.  The prelookup block allows more efficient lookups than the regular lookup block. The regular lookup block is self-checking for breakpoint consistency. Copyright 1990-2013 The MathWorks, Inc.

BLOCK:
Equivalent Lookup Table for Interpolation on an 11x9 table;In;Index search in 11 even spaced points;Index search in 5 variably spaced points;Index search in 9 variably spaced points;Interpolation on a 1-D table with 11 points;Interpolation on an 11x11 table ERROR IN DIM 2 ;Interpolation on an 11x9 table;Interpolation on another 11x11 table ERROR IN DIM ;Interpolation on one 10x6 plane of a 10x6x5 table ERROR IN DIM 1 and 2 ;More Info;Out;SubSystem


MODELNAME: sldemo_foreach_repeat_scalar
PATH: examples/simulink_features/main/sldemo_foreach_repeat_scalar.slx
ANNOTATION: Copyright 2009-2023 The MathWorks, Inc.
BLOCKTYPE: Concatenate;Constant;CustomCallbackButton;DiscreteFir;Inport;Outport;Product;Scope;Selector;Sin
BLOCKTYPE_FREQUENCY: 1;2;1;3;9;3;3;1;6;1
CHECKSUM: 426A137D7E143E562059B79A7D259E7F
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Callback Button;Coefficients;Common Gain;Discrete FIR Filter;In;Out;Product;Scope;Selector;Sine Wave;SubSystem;Subsystem;Vector Concatenate


MODELNAME: sldemo_foreach_repeat_tile
PATH: examples/simulink_features/main/sldemo_foreach_repeat_tile.slx
ANNOTATION: Copyright 2009-2023 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 3;1;1;1;4;4;4;6;8;4;4
CHECKSUM: EF618DE90CFDBCFAE72B8B0E964731C2
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Add;Callback Button;Coefficients;Cumulative average value of each tile;Divide;Matrix Concatenate;Result;Selector;Signal;SubSystem;Subsystem;Sum;Unit Delay;Vector Concatenate;Width

BLOCKTYPE:
Concatenate;Constant;CustomCallbackButton;Display;Inport;Outport;Product;Selector;Sum;UnitDelay;Width


MODELNAME: sldemo_foreach_tiled
PATH: examples/simulink_features/main/sldemo_foreach_tiled.slx
ANNOTATION: Copyright 2009-2023 The MathWorks, Inc.
BLOCKTYPE: Constant;CustomCallbackButton;Display;ForEach;Inport;Outport;Product;Sum;UnitDelay;Width
BLOCKTYPE_FREQUENCY: 1;1;1;2;2;2;1;2;1;1
CHECKSUM: E58C737438F62103319A14CCFC456B62
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Add;Callback Button;Coefficients;Cumulative average value of each tile;Divide;For Each;Result;Signal;SubSystem;Sum;Tile processing: slice across first dimension;Tile processing: slice across second dimension;Unit Delay;Width


MODELNAME: sldemo_foreach_vectorized
PATH: examples/simulink_features/main/sldemo_foreach_vectorized.slx
ANNOTATION: (Non iterated input) Copyright 2009-2023 The MathWorks, Inc.
BLOCKTYPE: Constant;CustomCallbackButton;DiscreteFir;ForEach;Inport;Outport;Product;Scope;Sin
BLOCKTYPE_FREQUENCY: 2;1;1;1;3;1;1;1;1
CHECKSUM: 302D8FCDD6E79298C292DC67A24DD774
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Callback Button;Coefficients;Coeffs;Common Gain;Discrete FIR Filter;FS;Filter Each Element;For Each;Gain;Product;Scope;Signal;Sine Wave;SubSystem


MODELNAME: sldemo_ifsub
PATH: examples/simulink_features/main/sldemo_ifsub.slx
ANNOTATION: If Block Example Copyright 1990-2021 The MathWorks, Inc.
BLOCKTYPE: Abs;ActionPort;Constant;DiscretePulseGenerator;If;Inport;Merge;Mux;Outport;Saturate;Scope;Sin;Sum
BLOCKTYPE_FREQUENCY: 1;2;1;1;1;2;1;1;2;1;1;1;1
CHECKSUM: 268CDA1D650C0C018A5C4FA204497BC6
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
If-Then-Else Blocks This example shows what happens when a sine wave is fed into an If block. After running the simulation, the scope shows three plots. This example is designed to compare the If block with enabled subsystems. The first of these plots shows the original sine wave and the absolute value of the original sine wave offset by two. The absolute value of the sine wave is only shown when the subsystem is executed. This occurs between 0 and 2.5 seconds and 5 and 7.5 seconds. When the subsystem is not executed then the output of the subsystem is reset to 0. The value of 0 is determined by the initial condition of the outport. You can see when the subsystem is executed by looking at the second plot. A value of 1 indicates that it is executed. The second plot shows the original value of the input signal. If the signal is towards the top of the plot then the if subsystem related to the first plot is executed. If the signal is towards the bottom of the plot then the else subsystem related to the third plot is executed. The third plot shows the original sine wave and the saturation limited sine wave offset by two. The saturated value of the sine wave is only shown when the subsystem is executed. This occurs between 2.5 and 5 seconds and 7.5 and 10 seconds. 

BLOCK:
Abs;Action Port;Bias;If;In;Merge;More Info;Mux;Out;Pulse Generator;Saturation;Saturation between -0.75 and 0.;Scope;Sine Wave;SubSystem;Sum


MODELNAME: sldemo_interp_memory
PATH: examples/simulink_features/main/sldemo_interp_memory.slx
BLOCK: In;Interpolation Using Prelookup;More Info;Out;Prelookup;SubSystem
BLOCKTYPE: Inport;Interpolation_n-D;Outport;PreLookup
BLOCKTYPE_FREQUENCY: 1;1;1;1
CHECKSUM: 510CB05BD393D46AC977028BC39606FE
PRODUCT: MATLAB;Simulink;Simulink Coder
PRODUCT_BASECODE: SL
DESCRIPTION:
Saving Memory in Prelookup and Interpolation Blocks by Using Smaller Data This example shows how to save memory in Prelookup and Interpolation blocks. The Prelookup and Interpolation Using Prelookup blocks allow the data type storing breakpoints and table data to be set explicitly. Note that the Prelookup block allows the breakpoint data to differ from the input data type, and the Interpolation Using Prelookup block allows the table data to differ from the output data type. In this model, the breakpoints and table are stored using single precision floating-point data type, and the calculations are performed using double precision floating-point data type. This reduces the amount of breakpoint and table data memory by half. To see this in the generated code, open the model and build it.

ANNOTATION:
Copyright 2008-2013 The MathWorks, Inc. All the calculations are performed using double precision floating-point, but the breakpoints and the table are stored as single precision floating-point data. Saving Memory in Prelookup and Interpolation Blocks by Using Smaller Data


MODELNAME: sldemo_lct_bus
PATH: examples/simulink_features/main/sldemo_lct_bus.slx
DESCRIPTION: Structure Arguments Using Buses
BLOCKTYPE_FREQUENCY: 5;2;2;2;1;1;5;3;2;1;1;2;2;1;2;2;1;2;1
CHECKSUM: B156FCCADD60F464074A1D34DDE24A70
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Coverage Documentation;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
\leftarrow call the legacy function via the S-Function \leftarrow call the Simulink version Use the Legacy Code Tool to call legacy functions that have arguments of struct data type Copyright 1990-2020 The MathWorks, Inc. - open legacy files counterbus.h and counterbus.c To view the sources, click these links. - open generated S-Function sldemo\_sfun\_counterbus.c

BLOCK:
 input; input GE lower; limit;Add;And;Bus Creator;Bus Selector;Bus to Vector;COUNTERBUSCreator;Delay;From;Goto;In;LIMITBUSCreator;Limits;More Info;Out;Previous Output;Pulse Generator;SIGNALBUSCreator;ScopeA;Signal Conversion;SubSystem;Switch;TestCounter;lower_ saturation_ limit;slCounter;sldemo_sfun_counterbus;upper GE input;upper_saturation_limit

BLOCKTYPE:
BusCreator;BusSelector;BusToVector;Constant;Delay;DiscretePulseGenerator;From;Goto;Inport;Legacy Function;Logic;Outport;RelationalOperator;S-Function;Scope;SignalConversion;Sum;Switch;UnitDelay


MODELNAME: sldemo_lct_cplxgain
PATH: examples/simulink_features/main/sldemo_lct_cplxgain.slx
DESCRIPTION: Return Arguments
BLOCK: Constant;Display;Gain;In;More Info;Out;SubSystem;complex_gain;sldemo_sfun_cplx_gain
BLOCKTYPE: Constant;Display;Gain;Inport;Legacy Function;Outport;S-Function
BLOCKTYPE_FREQUENCY: 1;2;1;1;1;1;1
CHECKSUM: 5CB66D1A306B06B45C103BFBB9BE411A
PRODUCT: MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 1990-2020 The MathWorks, Inc. Use the Legacy Code Tool to call legacy functions that accept complex signals - open legacy files cplxgain.h and cplxgain.c To view the source files, click these links. - open generated S-Function sldemo_sfun_cplx_gain.c


MODELNAME: sldemo_lct_cpp
PATH: examples/simulink_features/main/sldemo_lct_cpp.slx
DESCRIPTION: C++ Object Methods
BLOCKTYPE: Constant;Legacy Function;Memory;Outport;Relay;S-Function;Scope;Switch;UnaryMinus
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1;1;1;1
CHECKSUM: BFBB19C1EF3731D27EB6CE95703F08A2
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
C-style wrapper functions for accessing each method \downarrow For this example to run, at the MATLAB command prompt enter: {\it>> mex -setup} and select a C++ compiler.  Use the Legacy Code Tool to call C++ object member functions Copyright 1990-2021 The MathWorks, Inc. - open legacy files adder\_cpp.h and adder\_cpp.cpp To view the source files, click these links. - open generated S-Function sldemo\_sfun\_adder\_cpp.cpp

BLOCK:
Constant;Memory;More Info;Out;Relay;Scope;SubSystem;Subsystem;Switch;Unary Minus;sldemo_sfun_adder_cpp


MODELNAME: sldemo_lct_filter
PATH: examples/simulink_features/main/sldemo_lct_filter.slx
DESCRIPTION: Inputs Passed by Value or Address
BLOCKTYPE_FREQUENCY: 1;2;1;4;2;4;2;1;2;2
CHECKSUM: 3C179C74B015C44546695FCE5F5D6080
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
First input accessed by value (expression is conserved in the generated code) \downarrow First input accessed by address (expression is not conserved in the generated code) \downarrow Copyright 1990-2020 The MathWorks, Inc. Use the Legacy Code Tool to call legacy functions that pass their inputs by value or by pointer - open legacy files myfilter.h, filterV1.c and filterV2.c To view the source files, click these links. - open generated S-Function sldemo_sfun_filterV1.c and sldemo_sfun_filterV2.c

BLOCK:
Band-Limited White Noise;Data Type Conversion;More Info;Out;Pulse Generator;Reference;Scope;SubSystem;Sum;TestFilter;Unit Delay;noise;sigIn;sigOut;sldemo_sfun_filterV

BLOCKTYPE:
Band-Limited White Noise.;DataTypeConversion;DiscretePulseGenerator;Inport;Legacy Function;Outport;S-Function;Scope;Sum;UnitDelay


MODELNAME: sldemo_lct_fixpt_params
PATH: examples/simulink_features/main/sldemo_lct_fixpt_params.slx
DESCRIPTION: Fixed Point Parameters
BLOCK: Constant;In;More Info;Mux;Out;Scope;SubSystem;TestFixpt;sldemo_sfun_gain_fixpt
BLOCKTYPE: Constant;Inport;Legacy Function;Mux;Outport;S-Function;Scope
BLOCKTYPE_FREQUENCY: 1;1;4;1;2;4;1
CHECKSUM: B1BF02CA1BE7021E0B0C4507166011A1
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
Inlined parameters (InlineParameters ON + Auto storage class) ==> numeric value inlined Tunable parameter with myFixpt data type specification ==> parameter is not cast Double-precision (context-sensitive) parameters ==> tunable parameter inherits data type from run-time parameter Tunable parameter with explicit data type specification (uint8) ==> parameter is cast to run-time parameter data type Copyright 1990-2020 The MathWorks, Inc. Use the Legacy Code Tool to call legacy functions with parameters of fixed-point data type - open legacy files timesFixpt.h and timesS16.c To view the source files, click these links. - open generated S-Function sldemo_sfun_gain_fixpt.c


MODELNAME: sldemo_lct_fixpt_signals
PATH: examples/simulink_features/main/sldemo_lct_fixpt_signals.slx
DESCRIPTION: Fixed Point Signals
BLOCK: Constant;In;More Info;Mux;Out;Product;Scope;SubSystem;TestFixpt;sldemo_sfun_times_s
BLOCKTYPE: Constant;Inport;Legacy Function;Mux;Outport;Product;S-Function;Scope
BLOCKTYPE_FREQUENCY: 1;2;1;1;2;1;1;1
CHECKSUM: 9EC61BCC161D62101B7360C24CE85511
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 1990-2020 The MathWorks, Inc. Use the Legacy Code Tool to call legacy functions with signals of fixed-point data type - open legacy files timesFixpt.h and timesS16.c To view the source files, click these links. - open generated S-Function sldemo_sfun_times_s16.c


MODELNAME: sldemo_lct_gain
PATH: examples/simulink_features/main/sldemo_lct_gain.slx
DESCRIPTION: Return Arguments
BLOCKTYPE_FREQUENCY: 2;1;1;1;1;2;3;2;1;1;1;1
CHECKSUM: 2498ABAE622BF2734C693CF5922151AD
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 1990-2020 The MathWorks, Inc. Use the Legacy Code Tool to call legacy functions that pass their output as a return argument - open legacy files gain.h and gainScalar.c To view the source files, click these links. - open generated S-Function sldemo_sfun_gain_scalar.c

BLOCK:
Constant;Data Type Conversion;Gain;In;More Info;Out;Scope;SubSystem;Sum;Switch;TestGain;Unit Delay;counter limited;sldemo_sfun_gain_scalar

BLOCKTYPE:
Constant;CounterLimited;DataTypeConversion;Gain;Inport;Legacy Function;Outport;S-Function;Scope;Sum;Switch;UnitDelay


MODELNAME: sldemo_lct_inherit_dims
PATH: examples/simulink_features/main/sldemo_lct_inherit_dims.slx
DESCRIPTION: Inherited Signal Dimensions
BLOCKTYPE: Constant;DataTypeConversion;Demux;Inport;Legacy Function;Outport;Probe;S-Function
BLOCKTYPE_FREQUENCY: 3;1;1;3;2;4;1;2
CHECKSUM: 1CF35F32D72C1E05B90FE778F8549E04
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
Input/Output matrix dimensions are related to the parameters values \downarrow \uparrow Input matrices are dynamically sized the Output matrix dimensions are related to the Input matrices dimensions Copyright 1990-2020 The MathWorks, Inc. Use the Legacy Code Tool to call legacy functions that have arguments with inherited dimensions - open legacy files mat_ops.h and mat_ops.c To view the source files, click these links. - open generated S-Function sldemo_sfun_mat_add.c and sldemo_sfun_mat_mult.c

BLOCK:
Constant;Data Type Conversion;Demux;In;More Info;Out;Probe;SubSystem;TestMatOps;sldemo_sfun_mat_add;sldemo_sfun_mat_mult


MODELNAME: sldemo_lct_lut
PATH: examples/simulink_features/main/sldemo_lct_lut.slx
DESCRIPTION: Lookup Tables
BLOCKTYPE: Constant;Demux;Display;Inport;Legacy Function;LookupNDDirect;Mux;Outport;S-Function
BLOCKTYPE_FREQUENCY: 2;2;2;2;2;2;2;4;2
CHECKSUM: 6556C7BB71BAB161CA8DEC796297AE64
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
3D table \downarrow 4D table \downarrow LookUp Table are defined as: >> LUT3D = single(reshape([1:4*5*6], [4 5 6])); >> LUT4D = single(reshape([1:4*5*6*2], [4 5 6 2])) Copyright 1990-2020 The MathWorks, Inc. Use the Legacy Code Tool to call legacy functions that implement N-dimensional table lookups - open legacy files lookupTable.h and directLookupTableND.c To view the source files, click these links. - open generated S-Function sldemo_sfun_dlut3D.c and sldemo_sfun_dlut4D.c

BLOCK:
Constant;Demux;Direct Lookup Table (n-D);Display;In;More Info;Mux;Out;SubSystem;TestLut;sldemo_sfun_dlut3D;sldemo_sfun_dlut4D


MODELNAME: sldemo_lct_ndarray
PATH: examples/simulink_features/main/sldemo_lct_ndarray.slx
DESCRIPTION: Inherited Signal Dimensions
BLOCK: Constant;In;More Info;Out;SubSystem;ndarray_add;sldemo_sfun_ndarray_add
BLOCKTYPE: Constant;Inport;Legacy Function;Outport;S-Function
BLOCKTYPE_FREQUENCY: 2;2;1;2;1
CHECKSUM: C9FC2298C64B44DBD9FBA4117BE8053B
PRODUCT: MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
This legacy function computes the addition of the 2 input signals: - Input1 and Input2 are dynamically sized 3D arrays - Output1 is a dynamically sized 3D array of same size as Input1 - the last 3 functions arguments allow to pass the Input1s dimensions to the legacy function Copyright 1990-2020 The MathWorks, Inc. Use the Legacy Code Tool to call legacy functions that accept Multi-Dimensional signals - open legacy files ndarray_ops.h and ndarray_ops.c To view the source files, click these links. - open generated S-Function sldemo_sfun_ndarray_add.c 


MODELNAME: sldemo_lct_sampletime
PATH: examples/simulink_features/main/sldemo_lct_sampletime.slx
DESCRIPTION: Fixed Point Parameters
BLOCKTYPE: Constant;Inport;Legacy Function;Outport;Probe;S-Function
BLOCKTYPE_FREQUENCY: 3;3;3;6;3;3
CHECKSUM: 49208036D648BDA889577AA20E21A88C
PRODUCT: MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
This blocks sample time is inherited from the input signals sample time This blocks sample time is parameterized and can be changed in the mask dialog This blocks sample time is fixed: [2 1]  Copyright 1990-2020 The MathWorks, Inc. Use the Legacy Code Tool to call legacy functions with sample time inherited, fixed and parameterized - open legacy files gain.h and gainScalar.c To view the source files, click these links. - open generated S-Function sldemo_sfun_st_inherited.c, sldemo_sfun_st_fixed.c and sldemo_sfun_st_parameterized.c

BLOCK:
Constant;In;More Info;Out;Probe;SubSystem;sample_time;sldemo_sfun_st_fixed;sldemo_sfun_st_inherited;sldemo_sfun_st_parameterized


MODELNAME: sldemo_lct_start_term
PATH: examples/simulink_features/main/sldemo_lct_start_term.slx
DESCRIPTION: Start and Terminate Actions
BLOCKTYPE_FREQUENCY: 4;1;1;1;1;1;1;4;1;1;1;2;1;2
CHECKSUM: 3F5071E993D1EEEEA18128D7551BA097
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
mdlInitializeConditions \rightarrow call initFaultCounter() \rightarrow reset the fault counter mdlStart \rightarrow call openLogFile() \rightarrow open the file sldemo\_lct\_fault.log for logging faults mdlOutput \rightarrow call incAndLogFaultCounter() \rightarrow increment the fault counter and append one line in the log file mldTerminate \rightarrow call closeLogFile() \rightarrow close the logging file Copyright 1990-2020 The MathWorks, Inc. Use the Legacy Code Tool to call legacy functions that have start and terminate actions - open legacy files fault.h and fault.c To view the source files, click these links. - open generated S-Function sldemo_sfun_fault.c - run the model and edit the generated logging file sldemo\_lct\_fault.log

BLOCK:
Constant;Data Type Conversion;Digital Clock;Enable;In;More Info;Out;Relational Operator;Scope;SubSystem;Sum;Switch;TestFault;Triggered Subsystem;Unit Delay;counter limited;sldemo_sfun_fault

BLOCKTYPE:
Constant;CounterLimited;DataTypeConversion;DigitalClock;EnablePort;Inport;Legacy Function;Outport;RelationalOperator;S-Function;Scope;Sum;Switch;UnitDelay


MODELNAME: sldemo_lct_work
PATH: examples/simulink_features/main/sldemo_lct_work.slx
DESCRIPTION: Structure Arguments Using Buses
BLOCKTYPE_FREQUENCY: 3;1;1;2;1;1;1;1;1;1;1
CHECKSUM: 4294261DE846C1AA181805FC7190D306
PRODUCT: MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
\uparrow This legacy function apply a one integration step delay. The output is the previous input value. The parameters P1 and P2 set the initial values of the sub structure fields upper\_saturation\_limit and lower\_saturation\_limit Use the Legacy Code Tool to call legacy functions that have instance specific persistent memory Copyright 1990-2020 The MathWorks, Inc. - open legacy files memory\_bus.h and memory\_bus.c To view the source files, click these links. - open generated S-Function sldemo\_sfun\_work.c

BLOCK:
Bus Selector;Bus to Vector;COUNTERBUSCreator;In;LIMITBUSCreator;More Info;Out;Pulse Generator;SIGNALBUSCreator;ScopeA;Signal Conversion;SubSystem;lower_ saturation_ limit;memory_bus;sldemo_sfun_work;upper_saturation_limit

BLOCKTYPE:
BusCreator;BusSelector;BusToVector;Constant;DiscretePulseGenerator;Inport;Legacy Function;Outport;S-Function;Scope;SignalConversion


MODELNAME: sldemo_mdladv
PATH: examples/simulink_features/main/sldemo_mdladv.slx
ANNOTATION: Model Advisor Copyright 1990-2020 The MathWorks, Inc. Interactive Use Programmatic Use
BLOCK: Gain;In;Model Advisor;More Info;Out;SubSystem;Subsystem
BLOCKTYPE: Gain;Inport;Outport
BLOCKTYPE_FREQUENCY: 3;2;3
CHECKSUM: 19959A39CB0D17B33A4A6F5BC62B229C
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Model Advisor This example shows the capabilities of the Model Advisor to check a model or subsystem for conditions and configuration settings that can result in inaccurate or inefficient simulation of the system represented by the model or generation of inefficient code from the model. The Model Advisor produces a report that lists all the suboptimal conditions or settings that it finds, suggesting better model configuration settings where appropriate. The Model Advisor can be started through menus or the command line and can also be configured and used through a comprehensive API. 


MODELNAME: sldemo_mdlref_counter_datamngt
PATH: examples/simulink_features/main/sldemo_mdlref_counter_datamngt.slx
BLOCKTYPE_FREQUENCY: 1;2;1;2;4;1;1;1;1;1;1;1;1
CHECKSUM: 0BE436677291B75BABD702A9095F2033
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 1990-2013 The MathWorks, Inc. * If reset input changes, set count to initial condition. * Otherwise (increment input changed), increment count. * In either case, limit the count to the upper/lower limits specified.

BLOCK:
 Demux ; SFunction ; Terminator ;Add;Bus Creator;Count;CountIn;Detect Overflow;Increment;Initial Count;Previous Count;Range Check;Reset Count;Saturate Count;Selector;SubSystem;Trigger on rising edge;count;outputs;result

BLOCKTYPE:
BusCreator;Constant;Demux;Inport;Outport;S-Function;Saturate;Selector;Sum;Switch;Terminator;TriggerPort;UnitDelay


MODELNAME: sldemo_mdlref_fcncall
PATH: examples/simulink_features/main/sldemo_mdlref_fcncall.slx
ANNOTATION: Copyright 1990-2023 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 6;1;1;1;1;1;3;1;7;1;1;1;1
CHECKSUM: 03E76893C8033374B0FFCB62B1BA77E9
PRODUCT: MATLAB;Simulink;Stateflow
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: sldemo_mdlref_fcncall_cntr___Model_Block___
BLOCK:
 Demux ; SFunction ; input events ;1 sec Counter;10ms clock;500ms Counter;Asynchronous Counter;Asynchronous Interrupt ;C;Callback Button;Chirp Signal;Data Type Conversion;E1();E2();E3();Hit Crossing;Mux;Out;Reference;Scheduler;Scope;SubSystem

BLOCKTYPE:
Constant;CustomCallbackButton;DataTypeConversion;Demux;DiscretePulseGenerator;HitCross;ModelReference;Mux;Outport;S-Function;Scope;TriggerPort;chirp


MODELNAME: sldemo_mdlref_fcncall_cntr
PATH: examples/simulink_features/main/sldemo_mdlref_fcncall_cntr.slx
ANNOTATION: Copyright 1990-2023 The MathWorks, Inc. Function-Call Counter
BLOCKTYPE_FREQUENCY: 1;1;2;2;1;1;2;1;1;2;1;1
CHECKSUM: 3E0CDDF40507BF5849D533730116D0C2
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Function-Call Counter Illustration of a function-call model of a triggered counter. The counter bounds are provided through the input ports of the model. The counter increments each time the model is triggered. During simulation, a function-call model is implicitly triggered by the solver. Using a fixed-step solver configures the model to simulate using evenly spaced time steps. Using a variable-step solver allows the model to simulate using unevenly spaced time steps. 

BLOCK:
 limit;Add;And;Callback Button;Constant;More Info;Previous Output;Scope;SubSystem;Switch;function;lower;output;upper;upper GE input

BLOCKTYPE:
Constant;CustomCallbackButton;Inport;InportShadow;Logic;Outport;RelationalOperator;Scope;Sum;Switch;TriggerPort;UnitDelay


MODELNAME: sldemo_mdlref_variants
PATH: examples/simulink_features/main/sldemo_mdlref_variants.slx
BLOCK: Out;Controller;Linear;More Info;Nonlinear;Scope;SubSystem;sensor1 ;sensor2 ;sensor3 ;sine
BLOCKTYPE: Inport;ModelReference;Outport;Scope;Sin
BLOCKTYPE_FREQUENCY: 3;2;1;1;3
CHECKSUM: E8CE36FC479DAFBC70D057184684E20D
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: sldemo_mrv_linear_controller___Model_Block___sldemo_mrv_nonlinear_controller___Model_Block___
DESCRIPTION:
Model Reference Variants This demo illustrates model reference variants. A Model block is used to reference one Simulink(R) model from another Simulink model. A Model block can have different variants. A variant describes one of N possible modes a Model block can operate in. Each variant of the Model block references a specific model with model specific arguments. Only one variant is active for simulation. You can switch the active variant of a Model block by changing the values of variables in the base workspace or manually overriding variant selection using the Model block dialog. 

ANNOTATION:
This demo illustrates model reference variants. A Model block is used to reference one Simulink model from another Simulink model. A Model block can have different variants. A variant describes one of N possible modes a Model block can operate in. Each variant of the Model block references a specific model with model specific arguments. Only one variant is active for simulation. You can switch the active variant of a Model block by changing the values of variables in the base workspace or manually overriding variant selection using the Model block dialog. Model Reference Variants Copyright 2009-2020 The MathWorks, Inc. Model Reference Variants


MODELNAME: sldemo_mdlref_variants_enum
PATH: examples/simulink_features/main/sldemo_mdlref_variants_enum.slx
BLOCKTYPE: Inport;ModelReference;Outport;Scope;Sin
BLOCKTYPE_FREQUENCY: 6;8;4;1;3
CHECKSUM: 0E03B93D1A31C7B5C82BD506C1065F1F
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Model Reference Variants - Enumerations and Reuse The following demo illustrates some Simulink.VariantExpression capabilities 1. Enumerations: MATLAB enumeration classes can be used to improve readability in the conditions of the variant object. 2. Reuse: Simulink.VariantExpressions can be reused in different Model blocks. Copyright 2009-2017 The MathWorks, Inc. Model Reference Variants - Enumerations and Reuse

BLOCK:
 Out;Controller;Filter;In1 ;Linear;More Info;Nonlinear;Production;Prototype;Scope;SubSystem;sensor1 ;sensor2 ;sensor3 ;sine

EXTERNALFILE_REFERENCE:
sldemo_mrv_linear_controller___Model_Block___sldemo_mrv_nonlinear_controller___Model_Block___sldemo_mrv_sig_filter1_production___Model_Block___sldemo_mrv_sig_filter1_prototype___Model_Block___sldemo_mrv_sig_filter2_production___Model_Block___sldemo_mrv_sig_filter2_prototype___Model_Block___sldemo_mrv_sig_filter3_production___Model_Block___sldemo_mrv_sig_filter3_prototype___Model_Block___


MODELNAME: sldemo_metro_basic
PATH: examples/simulink_features/main/sldemo_metro_basic.slx
BLOCKTYPE_FREQUENCY: 3;26;22;8;1;3;1;2;14;12;1;7;6
CHECKSUM: 4875BF829D523CD2E7C7FF44B1314ACF
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
This example shows how to use Simulink(R) to explore the solver Jacobian sparsity pattern, and the connection between the solver Jacobian sparsity pattern and the physical coupling between components of a physical system. A Simulink(R) model that models the synchronization of three metronomes placed on a free moving base are used. 

ANNOTATION:
Acceleration of moving base Exploring the Solver Jacobian Structure of a Model Base model for sldemo_metro_foreach  Copyright 2023 The MathWorks, Inc.

BLOCK:
-m/(M+n*m);Add;Gain;In;Integrator;Math Function;Metronome;Metronome Animation;Moving base;Mux;Product;S-Function;Scope;SubSystem;Trigonometric Function;d2/dt2(sin(theta);d2/dt2(sin(theta1));d2/dt2(sin(theta2));d2/dt2(sin(theta3));escapement angle;friction;in_;intertia;r;theta;thetadot;thetadotdot;x;xdotdot

BLOCKTYPE:
Bias;Gain;Inport;Integrator;M-S-Function;Math;Metronome animation plot;Mux;Outport;Product;Scope;Sum;Trigonometry


MODELNAME: sldemo_metro_foreach
PATH: examples/simulink_features/main/sldemo_metro_foreach.slx
BLOCKTYPE_FREQUENCY: 1;1;2;10;8;4;1;1;1;1;6;4;1;1;3;3
CHECKSUM: B0BA38166CBF6EF4BF7264DC5002D1EA
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
This demo shows an example of how multiple objects with identical dynamics can be modeled using the For Each Subsystem. The number of objects is parameterized by the length of the input signal.

ANNOTATION:
Copyright 2011-2023 The MathWorks, Inc. Modeling Objects with Identical Dynamics using For Each Subsystem

BLOCK:
-m/(M+n*m);Add;For Each;Gain;Integrator;Math Function;Metronome Animation;Metronome_i;More Info;Moving base;Mux;Product;S-Function;Scope;Signal Specification;SubSystem;Sum of Elements;Trigonometric Function;d2/dt2(sin(theta_i));d2dt2(sin(theta_i)) Moving base;escapement angle;friction;in_;inertia;initial_position;r;theta_i;thetadot_i;thetadotdot_i;x;xdotdot

BLOCKTYPE:
Bias;Constant;ForEach;Gain;Inport;Integrator;M-S-Function;Math;Metronome animation plot;Mux;Outport;Product;Scope;SignalSpecification;Sum;Trigonometry


MODELNAME: sldemo_raccel_engine_idle_speed
PATH: examples/simulink_features/main/sldemo_raccel_engine_idle_speed.slx
ANNOTATION: Idle Speed Engine Model Nonlinearities Copyright 2002-2013 The MathWorks, Inc. Linear Dynamics
BLOCKTYPE: Constant;Gain;Inport;Outport;Polyval;Scope;Sum;ToWorkspace;TransferFcn;TransportDelay
BLOCKTYPE_FREQUENCY: 1;3;1;1;3;2;2;1;3;1
CHECKSUM: 6A8E52D5894D40EF8514956D813E2517
PRODUCT: MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
BLOCK:
BPAV;Engine Speed;Gain;Idle Speed;Mean Speed;More Info;SubSystem;Sum;To Workspace;Transfer Fcn;Transport Delay;Valve Voltage;x^


MODELNAME: sldemo_shared_data_alg
PATH: examples/simulink_features/main/sldemo_shared_data_alg.slx
ANNOTATION: Copyright 2017-2020 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 3;4;1;1;4;2;4;3;1;1;3;1;2
CHECKSUM: 43A1C1D020FA9ED0AA2A96836D83185A
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Algorithm;Callback Button;ClearFault;Compare To Constant;Constant;Data Store Memory;Data Store Read;Data Store Write;Discrete PID Controller;Fault Handling;In;Out;Reference;Saturation;SetFault;Setpoint;SubSystem;Sum;Switch;Trigger

BLOCKTYPE:
Compare To Constant;Constant;CustomCallbackButton;DataStoreMemory;DataStoreRead;DataStoreWrite;Inport;Outport;PID 1dof;Saturate;Sum;Switch;TriggerPort


MODELNAME: sldemo_suspn_3dof
PATH: examples/simulink_features/main/sldemo_suspn_3dof.slx
ANNOTATION: Road-Suspension Interaction in 3 DOFs Copyright 2011-2018 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 5;7;28;26;25;21;5;6;2;13;3;1;1;20;2;4
CHECKSUM: 6EDD969452F3F9652B252B13D0EC8F69
PRODUCT: MATLAB;Simulink;Simulink Test Documentation
PRODUCT_BASECODE: SL
BLOCK:
Add;Body Dynamics;Body States;Body states;Demux;Divide;From;Front Left Suspension;Front Right Suspension;Fz;Goto;Gravity;InertiaX;InertiaY;Left tire ;Mass;Moment arm;MomentArm;More Info;Mux;PHI;PHIdot;Pitch (THETA) dynamics;Pitch angle;Pitch rate;Rear Left Suspension;Rear Right Suspension;Reference;Right tire;Road Input;Road Profiles;Road-Suspension Interaction;Roll (PHI) dynamics;Roll angle;Roll rate;Scope;States;Static Ext.;Static ext.;Static extension;SubSystem;Sum;Sum of Pitch moments;Sum of Roll moments;Sum of susp forces;Susp Forces;THETA;THETAdot;Transport Delay;Vertical (Z) dynamics;Vertical Force;Vertical disp;Vertical vel;Z;Zdot;acceleration due to gravity;damping;stiffness

BLOCKTYPE:
Constant;Demux;From;Gain;Goto;Inport;InportShadow;Integrator;Mux;Outport;Product;Scope;SignalEditor;Sum;TransportDelay;half-car suspension


MODELNAME: sldemo_varsize_basic
PATH: examples/simulink_features/main/sldemo_varsize_basic.slx
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1;6;1;1;2;1;5;1;2;2;2;1;1;1;2;1;4;2;5;1;3;1
CHECKSUM: C08E8BB8D0FBBD29DA1B398B9B25ED99
PRODUCT: MATLAB;Simulink;Stateflow
PRODUCT_BASECODE: SL
ANNOTATION:
 Bounded Variable-Size Signal Generation and Operations Stateflow Chart and Function-Call Subsystem to implement a discrete-time FIR filter equation Bus Creation, Bus Selection and Matrix Concatenation Mathematical Operations Bounded Variable-Size signal generation using Selector block Bounded Variable-size signal generation using Switch block Copyright 2009-2023 The MathWorks, Inc.

BLOCK:
 Demux ; SFunction ;Abs;Bus Creator;Bus Selector;Callback Button;Compare To Zero;Complex to Real-Imag;Constant;E();Filter Output;From;Gain;Goto;In;Math Function;Matrix Concatenate;Mode Control Logic;Out;Probe;Pulse Generator;Real-Imag to Complex;Reference;Scope;Selector;SubSystem;Sum;Switch;Third order Discrete FIR Filter;To Workspace;Unit Delay;Width;function;u

BLOCKTYPE:
Abs;BusCreator;BusSelector;Compare To Zero;ComplexToRealImag;Concatenate;Constant;CustomCallbackButton;Demux;DiscretePulseGenerator;From;Gain;Goto;Inport;Math;Outport;Probe;RealImagToComplex;S-Function;Scope;Selector;Sum;Switch;ToWorkspace;TriggerPort;UnitDelay;Width


MODELNAME: sldemo_varsize_channel_pow_alloc
PATH: examples/simulink_features/main/sldemo_varsize_channel_pow_alloc.slx
BLOCKTYPE_FREQUENCY: 1;1;1;5;1;1;1;13;1;6;1;2;1;1;1;5;2;3;1;2
CHECKSUM: 071CEB53F90496B01F87B0D820214577
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Calculate the current power. Ptot(k) = sum( vectValsAboveWaterline(k) ) Number of input elements below the waterline Calculate an updated waterline value using the largest increments such that the power budget is not exceeded. waterline(k) = waterline(k-1) + (Pcon-Ptot(k-1)) / NelemsBelowWaterline(k-1) Termination condition Optimal Power Allocation for Parallel Channels (Waterfilling) The NL signal contains the channel noise levels. The Pcon signal is the total available power budget. Tol is the tolerance to use in the search for the waterline level. Copyright 2009-2013 The MathWorks, Inc.

BLOCK:
Abs;Add;Assignment;Channel noise levels;Divide;Find Nonzero Elements;From;Get Ptot;Goto;IC;In;Init Waterline;Initial condition;InitialVec;MinMax;More Info;NELBW(k-1);NL;Obtain thresholded power;Out;Pcon;Power constraint;Ptot(k);Ptot(k-1);Scope;Sine Wave;SubSystem;Subtract;Sum individual power;Switch;Threshold power;Tol;Tolerance;Unit Delay;Unit delay;Update waterline;Vector Concatenate;Waterline;Waterline(k);Waterline(k-1);While Iterator;While Iterator Subsystem;Width;s;vec

BLOCKTYPE:
Abs;Assignment;Concatenate;Constant;Find;From;Goto;Inport;MinMax;Outport;Product;RelationalOperator;Scope;Selector;Sin;Sum;Switch;UnitDelay;WhileIterator;Width


MODELNAME: sldemo_varsize_dataLengthAdapt
PATH: examples/simulink_features/main/sldemo_varsize_dataLengthAdapt.slx
ANNOTATION: Copyright 2009-2023 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 1;1;6;1;1;1;7;3;2;1;6;1;1;1;1;1;1;1
CHECKSUM: 342678A93E477BB5C61B7AB8DF2E9378
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
 Demux ; SFunction ; Terminator ;Abs;Callback Button;Constant;Control Signal;Data Selector;Dot Product;Excellent;Generate Signal Size;Grade;In;Length Adaptation;Logical Index For Signal Length;MATLAB Function;Math Function;Multiport Switch;Obtain Linear Index;Out;Poor;Process;Raw Data;Reference;Scope;Size ;Size Selection;SubSystem;Sum;Width;u;y

BLOCKTYPE:
Abs;Concatenate;Constant;CustomCallbackButton;Demux;DotProduct;Inport;Interval Test;Math;MultiPortSwitch;Outport;RandomNumber;S-Function;Scope;Selector;Sum;Terminator;Width


MODELNAME: sldemo_varsize_dataLengthAdtFS
PATH: examples/simulink_features/main/sldemo_varsize_dataLengthAdtFS.slx
ANNOTATION: Copyright 2009-2023 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 1;2;6;1;3;3;3;6;3;6;1;9;1;3;1;3;3;3;1
CHECKSUM: BF33158F772200BFA59496BF414E6902
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
 Demux ; SFunction ; Terminator ;Abs;Callback Button;Constant;Control Signal;Data Type Conversion;Enable;Excellent;Good;In;MATLAB Function;Math Function;Merge;Out;Padding zeros ;Poor;Process;Raw Data;Reference;Scope;Select ;Select all;Size Control;SubSystem;Sum;Vector Concatenate;Width;u;y

BLOCKTYPE:
Abs;Concatenate;Constant;CustomCallbackButton;DataTypeConversion;Demux;EnablePort;Inport;Interval Test;Math;Merge;Outport;RandomNumber;S-Function;Scope;Selector;Sum;Terminator;Width


MODELNAME: sldemo_varsize_multimode
PATH: examples/simulink_features/main/sldemo_varsize_multimode.slx
ANNOTATION: Copyright 2009-2023 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 1;1;5;1;1;1;1;3;5;3;1;6;1;1;1;1;1;2;1;2
CHECKSUM: AF2AB82CC332AB2F2F25CC783551E20C
PRODUCT: MATLAB;Simulink;Stateflow
PRODUCT_BASECODE: SL
BLOCK:
 Demux ; SFunction ;Abs;Callback Button;Constant;Control Signal;Data;Display;Dot Product;Excellent;Gain;Good;In;Logical Index For Signal Length;Mode Control Logic;Mode Selection ;Multiport Switch;Obtain Linear Index;Out;Poor;Probe;Process;Reference;Scope;Selector;Size Selection;SubSystem;Sum;Unit Delay;event();function;u

BLOCKTYPE:
Abs;Concatenate;Constant;CustomCallbackButton;Demux;Display;DotProduct;Gain;Inport;Interval Test;MultiPortSwitch;Outport;Probe;RandomNumber;S-Function;Scope;Selector;Sum;TriggerPort;UnitDelay


MODELNAME: sldemo_varsize_multimodeFixSizeImpl
PATH: examples/simulink_features/main/sldemo_varsize_multimodeFixSizeImpl.slx
ANNOTATION: Copyright 2009-2023 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 1;3;1;5;1;3;1;9;4;3;5;1;1;3;6;1;6
CHECKSUM: 2B41F348F397EF1DE053F5B78E161041
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Abs;Action Port;Callback Button;Constant;Data;Display;Dot Product;Excellent;Gain;Good;In;Logical Index Vector;Mode Selection;Obtain Linear Index;Out;Poor;Process;Quality Value;Reference;Scope;Selector;SubSystem;Subsystem Enable ;Sum;Unit Delay

BLOCKTYPE:
Abs;ActionPort;Concatenate;Constant;CustomCallbackButton;Display;DotProduct;Gain;Inport;Interval Test;Outport;RandomNumber;Scope;Selector;Sum;SwitchCase;UnitDelay


MODELNAME: slexBusExample
PATH: examples/simulink_features/main/slexBusExample.slx
DESCRIPTION: Bus Element Ports This model shows how bus element port blocks can be used to simplify diagrams.
BLOCKTYPE_FREQUENCY: 1;10;8;5;1;7;4;2;13;14;5;11;6;6
CHECKSUM: 19192C42C19C5C123A3E8DDFDC510E3E
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Quickly Create Buses from Block Outputs Quickly Create Buses as Subsystem Interfaces  Drag a selection box around the lines, pause on the ellipsis, then click Create Bus  Drag a selection box around the source blocks, pause on the ellipsis, then click Create Bus   To change the display mode, click a block, pause on the ellipsis, then click Compact Notation To create a port or element, right-click and drag the block to a new position, then select one of the options. Click the label text to edit the port and element names  Click the block, pause on the ellipsis, then click Bus Ports  Click the block, pause on the ellipsis, then click Bus Ports  Click the edge of the block. Then, click Create in bus port or Create out bus port. Create Bus Element Ports Add Ports to Blocks  Drag the output port of the block to the Bus Creator block.  Drag the input port of the block to the Bus Selector block. Explore Simulink Bus Capabilities Working with Buses in Components Using Bus Element Ports at Component Interfaces Copyright 2004-2023 The MathWorks, Inc. Smart Editing to Perform Common Bus Workflows Faster

BLOCK:
Bus Assignment ;Bus Creation;Bus Creator ;Bus Element Input;Bus Element Output;Bus Interaction;Bus Selector ;Callback Button;Chirp Signal;Constant;Display;Gain;In;In Bus Element;Out;Out Bus Element;Port Conversion;Port Creation;Pulse Generator;Reference;Repeating Sequence;Scope;Sine Wave;SubSystem;Subsystem

BLOCKTYPE:
BusAssignment;BusCreator;BusSelector;Constant;CustomCallbackButton;DiscretePulseGenerator;Display;Gain;Inport;Outport;Repeating table;Scope;Sin;chirp


MODELNAME: slexBusesMATLABSystemExample
PATH: examples/simulink_features/main/slexBusesMATLABSystemExample.slx
ANNOTATION: Copyright 2015-2023 The MathWorks, Inc.
BLOCK: Bus Creator;Bus Selector;Callback Button;Gain;Math Operations;Out;Pulse Generator;Sine Wave
BLOCKTYPE: BusCreator;BusSelector;CustomCallbackButton;DiscretePulseGenerator;MATLABSystem;Outport;Sin
BLOCKTYPE_FREQUENCY: 1;2;1;1;2;5;1
CHECKSUM: 5E2ADA2032EED03F61449E8B4A1081F0
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Using Buses with MATLAB System Blocks This example shows how to use buses as inputs and outputs to the MATLAB System block. * The Gain block uses a System object(TM) that applies the gain specified in the block to the bus elements a and b of the incoming bus. The output of the block is the same bus type as the input. * The Math Operations block uses a System object that computes the sum, product, and difference between the two bus elements a and b of the input bus. The output of the block is a bus with three elements: sum, prod, and diff. * Note, if a System block output bus is the same type as the input bus, you must still specify the output bus name in the getOutputDataTypeImpl method. This is because the propagatedInputDataType method does not return the input bus object during bus propagation. * Before model initialization, all bus types used as either inputs or outputs to the MATLAB System block must be available in the MATLAB base workspace. 


MODELNAME: slexCCallerExample
PATH: examples/simulink_features/main/slexCCallerExample.slx
ANNOTATION: Copyright 2019-2023 The MathWorks, Inc. Call C Functions Using C Caller Block
BLOCKTYPE_FREQUENCY: 3;1;5;4;1;2;1;4;1;7;3;2
CHECKSUM: 132923D6FCA0BE52A34C7AB3F3DD3700
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Bus Selector;C Caller;COUNTERBUSCreator;Callback Button;Constant;Delay;Display;Enumerated Constant;LIMITBUSCreator;Out;Pulse Generator;Reference;SIGNALBUSCreator;Scope;Sine Wave;SubSystem;lower_ saturation_ limit;upper_saturation_limit

BLOCKTYPE:
BusCreator;BusSelector;CCaller;Constant;CustomCallbackButton;Delay;DiscretePulseGenerator;Display;Enumerated Constant;Outport;Scope;Sin


MODELNAME: slexCCallerExampleImageFilter
PATH: examples/simulink_features/main/slexCCallerExampleImageFilter.slx
ANNOTATION: Copyright 2018 The MathWorks, Inc.
BLOCKTYPE: Constant;CustomCallbackButton;Demux;Inport;Outport;S-Function;Terminator
BLOCKTYPE_FREQUENCY: 1;1;1;4;3;1;1
CHECKSUM: B7F3DB42D5C35118855B54B8BCB0AFBE
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
 Demux ; SFunction ; Terminator ;C Caller;Callback Button;Constant;MATLAB Function;Out;Reference;SubSystem;img_gaussian;img_mean;img_median;img_origin


MODELNAME: slexCoSimPIControllerPlantExample
PATH: examples/simulink_features/main/slexCoSimPIControllerPlantExample.slx
BLOCKTYPE_FREQUENCY: 1;1;1;1;2;4;1;1;1;1;1;1
CHECKSUM: 0E19AD767F9D03382981BCD871620039
PRODUCT: MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
 Co-Simulation Numerical Compensation for Components with Local Solvers Baseline: Monolithic simulation with Simulink solver (continuous IO connection) Co-simulation with local solvers (discrete IO connection) Copyright 2021 The MathWorks, Inc.

BLOCK:
Abs;Accumulated Co-Simulation Error During Simulation;FMU Plant #;In;Minus;Out;PI Controller for cosim system;PI Controller for non-cosim system;S-Function Plant #;Setpoint;Simulation Result;Simulink Plant #;SubSystem;Subsystem;Zero-Order Hold;accumulator

BLOCKTYPE:
Abs;DiscreteIntegrator;Display;FMU;Inport;ModelReference;Outport;S-Function;Scope;Step;Sum;ZeroOrderHold

EXTERNALFILE_REFERENCE:
cosim_pi_controller.slx___Model_Block___cosim_plant1.slx___Model_Block___cosim_plant2.slx___Model_Block___


MODELNAME: slexCoSimPrimeExample
PATH: examples/simulink_features/main/slexCoSimPrimeExample.slx
ANNOTATION: Copyright 2017 The MathWorks, Inc.
BLOCKTYPE: Constant;Demux;Display;FMU;Gain;Ground;Outport;S-Function;Terminator
BLOCKTYPE_FREQUENCY: 1;1;2;1;2;1;2;3;1
CHECKSUM: 33BF56844AA3415ADE3D46D7ABB78B3D
PRODUCT: MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
BLOCK:
 Demux ; Ground ; SFunction ; Terminator ;Co-Simulation Component ;Constant;Display;Elapsed Wall Clock Time (seconds);Gain;MATLAB Function;More Info;Out;SubSystem;Toggle MultithreadedSim Parameter;y


MODELNAME: slexCounterFunctionMdlRef
PATH: examples/simulink_features/main/slexCounterFunctionMdlRef.slx
BLOCKTYPE: ArgIn;ArgOut;From;Goto;Logic;RelationalOperator;Sum;Switch;TriggerPort;UnitDelay
BLOCKTYPE_FREQUENCY: 3;1;4;2;1;2;1;2;1;1
CHECKSUM: 30E62FE1F61AD7EC2DBC4D33D085D338
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
 input GE lower; limit;Add;And;From;Goto;Previous Output;Simulink Function;SubSystem;Switch;input~;lower;output;update;upper;upper GE input


MODELNAME: slexDynamicSchedulingExample
PATH: examples/simulink_features/main/slexDynamicSchedulingExample.slx
BLOCKTYPE_FREQUENCY: 4;1;2;1;3;1;1;4;2;1;1;3
CHECKSUM: 8A7D3024DF44525A6277ACA62C14232F
PRODUCT: MATLAB;Simulink;Stateflow
PRODUCT_BASECODE: SL
ANNOTATION:
A common modeling pattern is to schedule the execution of functions using a Stateflow chart. Simulink Messages provides intrinsic support for creating and managing priority queues which may be used to model the situation in which the execution order of the functions may change between execution intervals. Additionally, the Sequence Viewer allows you to visualize execution sequences. To view the dynamically changing execution sequence: 1) Double-click on the Sequence Viewer block 2) Click the Run button once  Dynamic Priority Scheduling of Functions Copyright 2017 The Mathworks, Inc.

BLOCK:
 Demux ; SFunction ; Terminator ;Callback Button;Chart;Constant;Data Type Conversion;Mux;Out;Reference;Repeating Sequence;Sequence Viewer;SubSystem;f;f1_priority;f2_priority;f3_priority

BLOCKTYPE:
Constant;CustomCallbackButton;DataTypeConversion;Demux;Inport;MessageViewer;Mux;Outport;Repeating table;S-Function;Terminator;TriggerPort


MODELNAME: slexFocZynqExample
PATH: examples/simulink_features/main/slexFocZynqExample.slx
BLOCKTYPE: ModelReference
BLOCKTYPE_FREQUENCY: 4
CHECKSUM: BAFA6B5AB3A7D5560D03F79EE5CA8332
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2015 - 2020 The MathWorks, Inc. Multicore Programming of a Field-Oriented Control on Zynq Plant Field-Oriented Control

BLOCK:
Invertor and Motor;More Info;Peripherals;Speed Controller;Speed and Torque Inputs;SubSystem;Torque Controller;UDPReceiver

EXTERNALFILE_REFERENCE:
slexFocZynqPlant2InfMdlRef.slx___Model_Block___slexFocZynqPlantMdlRef.slx___Model_Block___slexFocZynqSpeedController.slx___Model_Block___slexFocZynqVect.slx___Model_Block___


MODELNAME: slexFocZynqPlantMdlRef
PATH: examples/simulink_features/main/slexFocZynqPlantMdlRef.slx
ANNOTATION: Invertor and Motor
BLOCKTYPE_FREQUENCY: 1;1;1;1;4;1;2;15;3;7;1;6;1;1;1;1;19;1;1;4;7;12;1;1;2;1;1;2;3;5;1;1;5;1;1;1;2;1;1;1;6;2;1
CHECKSUM: 1C192C7AE28A37CE4AACCE1E4345AFE0
PRODUCT: Embedded Coder;MATLAB;Simscape;Simscape Electrical;Simulink
PRODUCT_BASECODE: SL
BLOCK:
+;-;220V 60Hz;Angle;Aviod ;Bus Creator;Bus Selector;C;Compare To Constant;Controlled Current Source;Counter Free-Running;Ctrl;Current Sensor;DC link;Data Type Conversion;Electrical Reference;From;Gain;Goto;Ia*;Iabc;Ib*;Ic*;Ideal Rotational Motion Sensor;Ideal Torque Sensor;Ideal Torque Source;Input Data Conversion;Iref;Line Voltage Sensor;Mechanical Rotational Reference;Motor & load inertia;Mux;Output Data Conversion;PMSM;PS Divide;PS Product;PS Subtract;PS Terminator;PS-Simulink Converter;Peripherals;Phase Splitter;R;Rectifier;Ref;Reference;Resistor;Rg;Rotational Damper;Rotor_angle;Rotor_speed;Scope;Selector;Signals*;Simulink-PS Converter;Solver Configuration;Speed;Speed sensor;Stop Simulation;SubSystem;Te;Te sensor;Three Element Demux;Three-phase Inverter;Tm;Torque_In;Tref;UDP Send;Unit Delay;VI sensors;Vdc;Voltage Sensor;ia*;ib*;ic*;wr;~

BLOCKTYPE:
BusCreator;BusSelector;Capacitor;Compare To Constant;Controlled Current Source;Counter Free-Running;Current Sensor (Three-Phase);DataTypeConversion;Electrical Reference;From;Gain;Goto;Ideal Rotational Motion Sensor;Ideal Torque Sensor;Ideal Torque Source;Inertia;Inport;Line Voltage Sensor (Three-Phase);Mechanical Rotational Reference;Mux;Outport;PMIOPort;PMSM;PS Divide;PS Product;PS Saturation;PS Subtract;PS Terminator;PS Three-Element Demux;PS-Simulink Converter;Phase Splitter;Rectifier (Three-Phase);Resistor;Rotational Damper;Scope;Selector;Simulink-PS Converter;Solver Configuration;Stop;UDP Send;UnitDelay;Voltage Sensor;Voltage Source (Three-Phase)


MODELNAME: slexFocZynqSpeedController
PATH: examples/simulink_features/main/slexFocZynqSpeedController.slx
ANNOTATION: Speed Controller Copyright 2015 - 2017 The MathWorks, Inc.
BLOCKTYPE: DataTypeConversion;DiscreteIntegrator;Gain;Inport;Outport;Saturate;Sum;UnitDelay
BLOCKTYPE_FREQUENCY: 7;1;3;11;13;1;2;5
CHECKSUM: B0165B8731CF2EF8AE85FF1E590148DF
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Ctrl sat.;Data Type Conversion;Discrete-Time Integrator;Input Data Conversion;Integral gain;Output Data Conversion;Proportional gain;Ref;Ref_si;Rotor_speed;Rotor_speed_si;Speed;Speed Control;Speed_si;SubSystem;Sum;Torque;Torque*;Torque_out;Torque_si;Tref;Tref_si;Unit Delay;rad2rpm


MODELNAME: slexFocZynqVect
PATH: examples/simulink_features/main/slexFocZynqVect.slx
ANNOTATION: Copyright 2015 - 2017 The MathWorks, Inc. Torque Controller
BLOCKTYPE: Constant;DataTypeConversion;Demux;Gain;Inport;Mux;Outport;Product;Sum;Switch;Trigonometry;UnitDelay
BLOCKTYPE_FREQUENCY: 2;6;1;8;21;1;13;4;7;1;2;2
CHECKSUM: F465713BBAE1EB73807DDA263EEAC1C1
PRODUCT: Embedded Coder;Fixed-Point Designer;MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
ABC;Constant;DQ-ABC;Data Type Conversion;Demux;Gain;Gain_cos;Gain_sin;Ia*;Iabc*;Ib*;Ic*;Id* ;In;Input Data Conversion;Iq* ;Mux;Out;Output Data Conversion;Product;Rem_2pi;Rotor_angle;SubSystem;Sum;Switch;Theta;Torque*;Torque*_si;Trigonometric Function;Unit Delay;cos;i_a;i_b;i_c;ia;ib;id;iq;sin;te2iq


MODELNAME: slexMATLABSystemPWMExample
PATH: examples/simulink_features/main/slexMATLABSystemPWMExample.slx
ANNOTATION: Copyright 2017 The MathWorks, Inc. MATLAB System Block Example: Pulse Width Modulation
BLOCK: Manual Switch;More Info;Out;PWM;Scope;SubSystem;duty cycle (constant);duty cycle (varying);period
BLOCKTYPE: Constant;MATLABSystem;ManualSwitch;Outport;Scope;Sin
BLOCKTYPE_FREQUENCY: 2;1;1;1;1;1
CHECKSUM: 0BA56BF6588CB65ED1907F077B685DCE
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Pulse Width Modulation Using MATLAB System Block This example shows how to use MATLAB System block to generate Pulse Width Modulation (PWM) signals based on the input period and duty cycle signals by using controllable sample time and setNumTicksUntilNextHit. In this example, MATLAB System block registers a controllable sample time so that it can schedule the next hit while changing the output value. In this example, the MATLAB System block has two input ports and one output port. The first input port is the duty cycle signal and the second input port is the period signal. The MATLAB System block has two block parameters: the amplitude of the generated PWM signal and the resolution of the controllable sample time. In this example, the MATLAB System block demonstrates the use of the function: * createSampleTime(obj, Type, Controllable, TickTime, obj.Resolution) to register a controllable sample time in getSampleTimeImpl method. The resolution must be a positive finite integer that defines the fundamental step size that the MATLAB System block can schedule the next hit for this sample time. MATLAB System Block demonstrates the use of the method: * setNumTicksUntilNextHit(obj, numTicks) to schedule the next hit of the controllable sample time. The next hit happens after t = t_current + numTicks * resolution. numTicks must be a positive integer. The MATLAB System block can use this method to schedule the execution of the controllable sample time in setupImpl and stepImpl. 


MODELNAME: slexMultiInstanceFunctionsExample
PATH: examples/simulink_features/main/slexMultiInstanceFunctionsExample.slx
BLOCKTYPE_FREQUENCY: 2;1;4;4;8;2;4;3;2
CHECKSUM: 76282F433F3505029E4AE6258113C493
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: slexCounterFunctionMdlRef.slx___Model_Block___
ANNOTATION:
 Modeling Reusable Components using Multiply Instanced Simulink Functions Copyright 2017 The Mathworks, Inc.  In this example, the model slexCounterFunctionMdlRef contains a Simulink Function update() which maintains a counter. Multiple instancing provides the ability to reuse this logic as CounterA and CounterB in this application model. The qualified calling notation CounterA.update and CounterB.update is used to distinguish the two different instances of the counter logic. Note that each instance may be called from multiple caller blocks as illustrated in this example.

BLOCK:
C;CounterA;CounterB;Function Caller;Input;Lower;More Info;Out;OutA;OutB;Pulse Generator with Ts=0.;Pulse Generator with Ts=1.;ScopeA;ScopeB;ScopeC;SubSystem;Sum;UpdateCounterA;UpdateCounterB;Upper

BLOCKTYPE:
Constant;CustomCallbackButton;DiscretePulseGenerator;FunctionCaller;Inport;ModelReference;Outport;Scope;Sum


MODELNAME: slexMulticoreFPGAExample
PATH: examples/simulink_features/main/slexMulticoreFPGAExample.slx
BLOCKTYPE_FREQUENCY: 1;4;8;2;1;1;1;2;1;1;9;2
CHECKSUM: 219615FE1F0D88968F8D7A2BD7EFE53C
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: slexMulticoreInputMdlRef___Model_Block___
ANNOTATION:
 Newton-Raphson method: Solve f(x) = 0 using x(n+1) = x(n) - f(x(n)) / f(x(n)) where f(x) = sin(x). Simulate a computationally intensive algorithm using a For Iterator Subsystem Copyright 2013-2018 The MathWorks, Inc. Copyright 2013-2018 The MathWorks, Inc. Implement an FFT on a Multicore Processor and an FPGA

BLOCK:
Add;Butterfly;Divide;For Iterator;For Iterator Subsystem;Gain;In;Input;Memory;More Info;Mux;N/2 DFT;Out;Signal Conversion;Sub;SubSystem;Subsystem;Sum;Trigonometric Function

BLOCKTYPE:
ForIterator;Gain;Inport;MATLABSystem;Memory;ModelReference;Mux;Outport;Product;SignalConversion;Sum;Trigonometry


MODELNAME: slexPrinterExample
PATH: examples/simulink_features/main/slexPrinterExample.slx
ANNOTATION: Copyright 2014-2023 The Mathworks, Inc.
BLOCKTYPE_FREQUENCY: 2;1;1;1;1;4;1;2;1;1;5;1;1;2;1;1;2;3
CHECKSUM: D42FCE1F9AA8EDE39497F589D8370B61
PRODUCT: Embedded Coder;MATLAB;Simulink;Stateflow
PRODUCT_BASECODE: SL
BLOCK:
 Demux ; Ground ; SFunction ; Terminator ;Add;Computer ;Constant;Function Caller;More Info;Mux;Number of Pages;Out;Queueing and Processing Incoming Jobs;Relational Operator;Scope;Sequence Viewer;Simulink Function;SubSystem;addPrintJob;ink;ink_status;job;printerInk;work

BLOCKTYPE:
ArgIn;ArgOut;Constant;CustomCallbackButton;Demux;FunctionCaller;Ground;Inport;MessageViewer;Mux;Outport;RelationalOperator;S-Function;Scope;Sum;Terminator;TriggerPort;UniformRandomNumber


MODELNAME: slexResettableConfigurationExample
PATH: examples/simulink_features/main/slexResettableConfigurationExample.slx
ANNOTATION: Copyright 2015-2022 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 2;1;2;1;2;2;4;2;2;3
CHECKSUM: AB76C774B06E09F1227FE35FA7AB3732
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Discrete and Continuous Resettable Subsystems This example shows the comparison between behaviors of discrete and continuous resettable subsystems. After running the simulation, the two scopes show the results for the discrete resettable subsystem (top scope), and continuous enabled subsystems (bottom scope).

BLOCK:
Callback Button;Constant;Continuous Resettable Subsystem;Continuous Signals;Discrete Resettable Subsystem;Discrete Signals;Discrete-Time Integrator;Integrator;Pulse Generator;Reset;Reset States;Sine Wave;SubSystem;integration of 1 Cont. Output;integration of 1 Discrete Output;integration of sin Cont. Output;integration of sin Discrete Output

BLOCKTYPE:
Constant;CustomCallbackButton;DiscreteIntegrator;DiscretePulseGenerator;Integrator;Mux;Outport;ResetPort;Scope;Sin


MODELNAME: slexResettableSubsystemExample
PATH: examples/simulink_features/main/slexResettableSubsystemExample.slx
ANNOTATION: Resettable Subsystem Example Copyright 2015 The MathWorks, Inc.
BLOCKTYPE: CMBlock;DiscreteIntegrator;DiscretePulseGenerator;Inport;Mux;Outport;Ramp;ResetPort;Scope
BLOCKTYPE_FREQUENCY: 1;2;1;2;2;2;1;2;1
CHECKSUM: 4E33FAB46B71EB0599BCEA22F8EF33CE
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Resettable Subsystems This example shows what happens when a ramp signal is integrated using two resettable subsystems. After running the simulation, the scope shows three plots. The middle plot shows the original value of the reset signal. In this example, we are using a discrete sample time pulse signal. The rising and falling edges are what cause the two subsystems to reset. The top and bottom plots show the original ramp as a reference and its integration. The subsystems corresponding to the top and bottom plots reset on every rising and falling edge of the pulse, respectively. When each subsystem resets, the state of the integrator block is set to its initial condition value, which is 0. You can refer to the middle plot to determine when each subsystem resets. Notice how the reset happens for blocks within the subsystem, without the need for each block to have its own reset port. This provides a more convenient way of handling reset at a subsystem level. 

BLOCK:
Discrete Time Integrator Falling Reset;Discrete Time Integrator Rising Reset;Discrete-Time Integrator;In;Model Info;More Info;Mux;Out;Pulse Generator;Ramp;Reference;Reset;Scope;SubSystem


MODELNAME: slexVariableTransportDelay
PATH: examples/simulink_features/main/slexVariableTransportDelay.slx
BLOCKTYPE: CMBlock;Constant;Integrator;Product;Repeating table;Scope;Sin;VariableTransportDelay
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1;1;1
CHECKSUM: 88D58110885C6E4DB3ECD9EBF3917B1E
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
 Vertical displacement of the wheels of a one dimensional car A car is running along a road with speed v(t). A sensor is installed at the front wheel to measure the vertical displacement Hi(t) of the the front wheel caused by the road profile. If the wheels and road never lose contact, then the vertifical displacement of the rear wheel, Ho(t), can be seen as a variable transport delay of Hi(t), which is determined by the length L between the two wheels and the speed v(t).

ANNOTATION:
Vertical displacement of the wheels of a one dimensional car Copyright 1990-2018 The MathWorks, Inc. Front wheel measured vertical displacement x(t) Front wheel position

BLOCK:
Axial distance;Car Speed;Divide;Integrator;Model Info;More Info;Reference;Road profile;Scope;SubSystem;Variable Transport Delay


MODELNAME: triggeredsub
PATH: examples/simulink_features/main/triggeredsub.slx
ANNOTATION: Triggered Subsystem Demonstration Copyright 1990-2015 The MathWorks, Inc.
BLOCKTYPE: Ground;Inport;Mux;Outport;Scope;SignalGenerator;Sin;TriggerPort
BLOCKTYPE_FREQUENCY: 1;3;1;3;1;1;1;3
CHECKSUM: F858F4674FE444511546DA68A00B6B6F
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Triggered Subsystems This model shows triggered subsystems and describes the different trigger types. A triggered subsystem is executed for a single time step whenever the trigger port transitions from false to true in a specified direction. The transition of the trigger port may occur when the direction of the transition is rising, falling, or both rising and falling. A rising transition occurs when the trigger signal transitions from zero or below to a positive value. A falling transition occurs when the trigger signal transitions from zero or above to a negative value. After running the simulation, look closely at the top plot in the scope. This shows a sine wave, a waveform, and the grounded value of zero. As the waveform transitions through zero, each of the subsystems is triggered appropriately. The output of each subsystem is equal to the current value of the sine wave at that time. 

BLOCK:
Either;Falling;Ground;In;More Info;Mux;Out;Outputs;Rising;Signal Generator;Sine Wave;SubSystem;Trigger


MODELNAME: sldemo_mdlref_basic
ANNOTATION: Component-Based Modeling with Model Reference Copyright 1990-2023 The MathWorks, Inc.
BLOCKTYPE: Constant;CustomCallbackButton;ModelReference;Outport;Scope;SignalEditor
BLOCKTYPE_FREQUENCY: 2;1;3;3;3;3
CHECKSUM: C76AEB9AF97000C0DF136EC311830A2F
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: sldemo_mdlref_counter___Model_Block___sldemo_mdlref_counter.slx___Model_Block___
PATH:
examples/simulink_features/projects/src/ComponentBasedModelingUsingModelReference/sldemo_mdlref_basic.slx

BLOCK:
C;Callback Button;CounterA;CounterB;CounterC;OutA;OutB;OutC;Reference;ScopeA;ScopeB;ScopeC;Ts=0.;Ts=1.


MODELNAME: sldemo_mdlref_counter
ANNOTATION: Copyright 1990-2023 The MathWorks, Inc.
BLOCKTYPE: CustomCallbackButton;From;Goto;Inport;Logic;Outport;RelationalOperator;Scope;Sum;Switch;UnitDelay
BLOCKTYPE_FREQUENCY: 1;4;2;3;1;1;2;1;1;2;1
CHECKSUM: 53AFE64C41832E75D1E55FC0C8C22B97
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
PATH:
examples/simulink_features/projects/src/ComponentBasedModelingUsingModelReference/sldemo_mdlref_counter.slx

BLOCK:
 input; input GE lower; limit; upper;Add;And;Callback Button;From;Goto;Previous Output;ScopeA;Switch;lower;output;upper GE input


MODELNAME: LimitedCounter
PATH: examples/simulink_features/projects/src/MultiInstance/models/LimitedCounter.slx
ANNOTATION: Copyright 1990-2023 The MathWorks, Inc.
BLOCKTYPE: CustomCallbackButton;From;Goto;Inport;Logic;Outport;RelationalOperator;Scope;Sum;Switch;UnitDelay
BLOCKTYPE_FREQUENCY: 1;4;2;3;1;1;2;1;1;2;1
CHECKSUM: 6EB3AE512E04757474AB551969C3BD69
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
 input; upper;Add;And;Callback Button;ChooseLimit;From;Goto;PassOrLimit;Previous Output;Scope;input GE lower;input LE upper;lower;output


MODELNAME: MultiInstanceModelExample
PATH: examples/simulink_features/projects/src/MultiInstance/models/MultiInstanceModelExample.slx
ANNOTATION: Copyright 1990-2023 The MathWorks, Inc.
BLOCKTYPE: Constant;CustomCallbackButton;DiscretePulseGenerator;ModelReference;Outport
BLOCKTYPE_FREQUENCY: 2;1;3;3;3
CHECKSUM: 6BBCEADB482D4BB632F7D1CD3C08BFA3
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: LimitedCounter___Model_Block___
BLOCK:
Callback Button;CounterA;CounterB;CounterC;Out;Pulse GeneratorA;Pulse GeneratorB;Pulse GeneratorC;lower;upper


MODELNAME: HouseThermalExample
PATH: examples/simulink_features/projects/src/blocksetdesigner/HouseThermalExample.slx
ANNOTATION: Thermal Model of a House Copyright 1990-2019 The MathWorks, Inc. Note: Time given in units of hours
BLOCKTYPE: BusCreator;CelsiusToFahrenheit;Constant;Energy2Cost;FahrenheitToCelsius;Scope;Sin;Sum
BLOCKTYPE_FREQUENCY: 1;1;2;1;2;1;1;2
CHECKSUM: 263ED94BB46E9E1477BD5586534C3224
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Avg Outdoor Temp;Bus Creator;Celsius to Fahrenheit;Daily Temp Variation;Energy2Cost;Fahrenheit to Celsius;Fahrenheit to Celsius ;Flow2Energy;Heater;House;PlotResults;Reference;Set Point;Sum;Thermostat


MODELNAME: slexMulticoreExample
PATH: examples/simulink_features/projects/src/slexMulticoreExample/models/slexMulticoreExample.slx
DESCRIPTION: Assign code to cores
BLOCK: Fcn;From;Goto;In;More Info;Out;SubSystem;Subsystem
BLOCKTYPE: From;Goto;Inport;MATLABSystem;ModelReference;Outport
BLOCKTYPE_FREQUENCY: 1;1;2;1;2;2
CHECKSUM: E5060BB27AFB1DE61ED916D8A650DF54
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: slexMulticoreFcn1___Model_Block___slexMulticoreFcn2___Model_Block___
ANNOTATION:
Slower rates - Core 1 Fast rate - Core 0 Assigning Tasks to Cores for Multicore Programming Copyright 2015 The MathWorks, Inc.


MODELNAME: slexMulticoreFcn1
PATH: examples/simulink_features/projects/src/slexMulticoreExample/models/slexMulticoreFcn1.slx
DESCRIPTION: Algorithm Design
BLOCKTYPE: ForIterator;Gain;Inport;Memory;Outport;Product;Sum;Trigonometry;UnitDelay
BLOCKTYPE_FREQUENCY: 1;1;2;1;2;1;2;2;1
CHECKSUM: 72AAD0E4D4409B625C808D2BB2F7E554
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 Newton-Raphson method: Solve f(x) = 0 using x(n+1) = x(n) - f(x(n)) / f(x(n)) where f(x) = sin(x). Simulate a computationally intensive algorithm using a For Iterator Subsystem Copyright 2015-2018 The MathWorks, Inc.

BLOCK:
Add;Adder;Delay;Divide;For Iterator;For Iterator Subsystem;Gain;Memory;SubSystem;Sum;TicToc;Trigonometric Function;U


MODELNAME: slexMulticoreFcn2
PATH: examples/simulink_features/projects/src/slexMulticoreExample/models/slexMulticoreFcn2.slx
DESCRIPTION: Algorithm Design
BLOCKTYPE: ForIterator;Gain;Inport;Memory;Outport;Product;Sum;Trigonometry;UnitDelay
BLOCKTYPE_FREQUENCY: 1;1;2;1;2;1;2;2;2
CHECKSUM: 18D66EB973B0958DD19F2FD408043FBB
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 Newton-Raphson method: Solve f(x) = 0 using x(n+1) = x(n) - f(x(n)) / f(x(n)) where f(x) = sin(x). Simulate a computationally intensive algorithm using a For Iterator Subsystem Copyright 2015-2018 The MathWorks, Inc.

BLOCK:
Delay;Divide;For Iterator;For Iterator Subsystem;Gain;Memory;SubSystem;Subtract;Subtracter;Sum;TicToc;Trigonometric Function;Unit Delay;u


MODELNAME: FeedbackMatrix
PATH: examples/simulink_general/main/FeedbackMatrix.slx
ANNOTATION: Cx Copyright 2023 The MathWorks, Inc.
BLOCKTYPE: CustomCallbackButton;Gain;Inport;Integrator;Outport;Scope;Step;Sum;ToWorkspace
BLOCKTYPE_FREQUENCY: 1;5;1;2;2;1;1;3;1
CHECKSUM: 9C9C5C36B6768D1A33CEC4FC6EC022CE
PRODUCT: MATLAB;Simulink;Simulink 3D Animation Documentation
PRODUCT_BASECODE: SL;VR
BLOCK:
Callback Button;Gain;In;Integral Gain ;Integrator;K;OutputVoltage;Plant;Scope;Step;SubSystem;Sum;To Workspace;states


MODELNAME: SpiralGalaxyExample
PATH: examples/simulink_general/main/SpiralGalaxyExample.slx
ANNOTATION: Initialize Galaxies Copyright 1990-2024 The MathWorks, Inc.
BLOCKTYPE: Concatenate;Constant;CustomCallbackButton;Delay;Demux;ForEach;Inport;Outport;S-Function;Terminator
BLOCKTYPE_FREQUENCY: 4;8;1;1;3;1;10;7;3;3
CHECKSUM: F1440D886346B8979203F1F4ED18547D
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Spiral Galaxy Formation Simulation with MATLAB Function Blocks This model was inspired by the classic paper Galactic Bridges and Tails (Toomre & Toomre 1972). The original paper explained how disc shaped galaxies could develop spiral arms. Two disc shape galaxies originally are far apart. They then fly by each other and almost collide. Once the galaxies are close enough, mutual gravitational forces cause spiral arms to form. Except for the PlotAll visualization blocks use of plotting routines, all MATLAB function blocks in this model support code generation with Simulink Coder(TM) and Embedded Coder(TM). * Demo Requirements: During this demonstration, Simulink generates code for the simulation in a Simulink project directory created in the current working directory (pwd). If you do not want to affect the current directory (or if you cannot generate files in this directory), you should change your working directory. 

BLOCK:
 Demux ; SFunction ; Terminator ;Apply Newtonian Gravitation;Center of Mass;CenterMass of Galaxy1 (Solar);CenterMass of Galaxy2 (Solar);Construct Galaxies;Construct Galaxy;Delay;For Each;M;Open Documentation;Plot Galaxies;Position;Position of Galaxy1 (Parsec);Position of Galaxy2 (Parsec);Radius;Radius of Galaxy1 (Parsec);Radius of Galaxy2 (Parsec);SubSystem;Vector Concatenate;Velocity;Velocity of Galaxy1 (meters per second);Velocity of Galaxy2 (meters per second);bodies;cm;pos;rp;vel


MODELNAME: buck_cl_paper
PATH: examples/simulink_general/main/buck_cl_paper.slx
ANNOTATION: Copyright 2022 The MathWorks, Inc.
BLOCKTYPE: Constant;Gain;Inport;Integrator;Mux;Outport;Product;Relay;Repeating table;Scope;Sum
BLOCKTYPE_FREQUENCY: 3;6;4;3;1;3;2;1;1;3;6
CHECKSUM: 073451B1766226049566356D5BB6B046
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
BLOCK:
Constant;Divide;Gain;In;Input voltage;Integrator;Load resistor;Mux;PWM;Product;Reference;Relay;Repeating Sequence;Scope;SubSystem;Subsystem;Subtract;Sum;Vc;Vg;c;d;iL


MODELNAME: buck_ol
PATH: examples/simulink_general/main/buck_ol.slx
ANNOTATION: Copyright 2022 The MathWorks, Inc.
BLOCKTYPE: Constant;Gain;Inport;Integrator;Mux;Outport;Product;Relay;Repeating table;Scope;Sum
BLOCKTYPE_FREQUENCY: 3;4;4;2;1;3;2;1;1;2;5
CHECKSUM: 3206FB731520AA70AA5AE2EDFC830535
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
BLOCK:
Divide;Duty cycle D;Gain;In;Input voltage;Integrator;Load resistor;Mux;PWM;Product;Reference;Relay;Repeating Sequence;Scope;SubSystem;Subsystem;Sum;Vc;Vg;c;d;iL


MODELNAME: canonicalform
PATH: examples/simulink_general/main/canonicalform.slx
ANNOTATION: Input data Multiplication Canonical Form Inverse Copyright 2023 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 2;3;1;4;5;7;5;1;8;6;9;4;1;4
CHECKSUM: 9EE8D7E3C1FDAFC308F992E9F62E4BDC
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
BLOCK:
 Demux ; SFunction ; Terminator ;A;B;C;Callback Button;ControllabilityMatrix;From;Goto;IdentityMatrix;In;MATLAB Function;Matrix Concatenate;Matrix Divide;Matrix Multiply;P;Pinv;Q;Reference;SubSystem;Submatrix;Subsystem;u;y

BLOCKTYPE:
Concatenate;Constant;CustomCallbackButton;Demux;Display;From;Goto;IdentityMatrix;Inport;Outport;Product;S-Function;Submatrix;Terminator


MODELNAME: penddemo
PATH: examples/simulink_general/main/penddemo.slx
ANNOTATION: Inverted pendulum on cart with animation Copyright 1990-2023 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 1;1;2;5;5;4;1;1;4;4;1;1;1;1;1;5;2;1;1
CHECKSUM: 356B036FEF8AA860E852A643F862D564
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Inverted Pendulum with Animation This example shows how to model an inverted pendulum. The animation is created using MATLAB(R) Handle Graphics(R). The animation block is a masked S-function. For more information, use the context menu to look under the Animation blocks mask and open the S-function for editing.

BLOCK:
Add;Animation;Cart;Clock;Fcn;Feedforward Gain;Gain;In;Input;Integrator;Level-2 MATLAB S-Function;More Info;Mux;Out;Outport;PID Controller ;Pendulum;Reference;Reference Position;Saturation;Scope;Signal Gen.;State Estimator;State Feedback Controller;SubSystem;Subtract;Sum;To Workspace;U;Unit Delay;in_

BLOCKTYPE:
Clock;Constant;Fcn;Gain;Inport;Integrator;Inverted Pendulum Dynamics;M-S-Function;Mux;Outport;PID 1dof;Pendulum plot;Saturate;Scope;SignalGenerator;Sum;ToWorkspace;TransferFcn;UnitDelay


MODELNAME: sldemo_VariableTransportDelay
PATH: examples/simulink_general/main/sldemo_VariableTransportDelay.slx
BLOCKTYPE: CMBlock;Constant;Integrator;Product;Repeating table;Scope;Sin;VariableTransportDelay
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1;1;1
CHECKSUM: 2E496A6A1DABDCC4C1EB5FC3059D3870
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
 Vertical displacement of the wheels of a one dimensional car A car is running along a road with speed v(t). A sensor is installed at the front wheel to measure the vertical displacement Hi(t) of the the front wheel caused by the road profile. If the wheels and road never lose contact, then the vertifical displacement of the rear wheel, Ho(t), can be seen as a variable transport delay of Hi(t), which is determined by the length L between the two wheels and the speed v(t).

ANNOTATION:
Vertical displacement of the wheels of a one dimensional car Copyright 1990-2013 The MathWorks, Inc. Front wheel measured vertical displacement x(t) Front wheel position

BLOCK:
Axial distance;Car Speed;Divide;Integrator;Model Info;More Info;Reference;Road profile;Scope;SubSystem;Variable Transport Delay


MODELNAME: sldemo_VariableTransportDelay_pipe
PATH: examples/simulink_general/main/sldemo_VariableTransportDelay_pipe.slx
ANNOTATION: Incompressible flow through a fixed length pipe Copyright 1990-2013 The MathWorks, Inc.
BLOCKTYPE: CMBlock;Constant;Product;Ramp;Scope;Step;VariableTransportDelay
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1;1
CHECKSUM: D262CC42D65429ACAA6C3A2EF7ACAA93
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
 Incompressible flow through a fixed length pipe An incompressible flow goes through a pipe of length L with speed v(t). At the inlet the flow temperature is Ti, then the temperature at the outletTo can be modeled as an variable transport delay of Ti. At time t=0, the pipe is empty and until t=2, there is no flow at the outlet. Thus the output temperature before t=2 is the initial output temperature. 

BLOCK:
Divide;Flow speed;Inlet Temperature;Model Info;More Info;Pipe length;Reference;Scope;SubSystem;Variable Transport Delay


MODELNAME: sldemo_adc_quantize
PATH: examples/simulink_general/main/sldemo_adc_quantize.slx
BLOCKTYPE: Bias;Gain;HitCross;IdealADC;Inport;Outport;Repeating table;Rounding;Sum
BLOCKTYPE_FREQUENCY: 2;1;1;1;2;5;1;1;1
CHECKSUM: FEDEEDCAC4F08B0FD09028BFEF07BECF
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Analog-to-Digital Converter Quantization Algorithm The quantization algorithm in the model takes in a 0 to 5 volt signal and outputs a 12-bit digital word in a 16-bit signed integer. A value of 0 corresponds to 0 Volts and a value of 4096 would correspond to 5 Volts. A change in the least significant bit (LSB) is about 1.2 mV. As 12 bits can only reach the value of 4095, the highest voltage that can be read by this device is approximately 4.9988 Volts. In order to have no more than 1/2 LSB error, the quantizer changes values midway between each voltage point, resulting in a 1/2-width interval at 0 Volts and a 3/2-width interval just below 5 Volts. 

ANNOTATION:
Analog to Digital Converter (ADC) quantization algorithm (zero conversion time) The blocks driving outports 1 and 3 convert the continuous reference signal into equivalent bit units to capture bit transitions in time so the plot shows the transitions clearly. Run the simulation. Visualize quantization effects with the plot created after the run. Copyright 1990-2013 The MathWorks, Inc.

BLOCK:
Bias;E_bit_units;E_volts_in_bit_units;Find edges of bit transitions in time;Hit Crossing;Idealized ADC quantizer;More Info;Re-Scale;Reference;Rescale volts to match ADC signal;SubSystem;Sum;Sweep Across Voltage Range (Reference signal);V;bit_edges;bit_units;hits;setround;transition;v


MODELNAME: sldemo_bangbang
PATH: examples/simulink_general/main/sldemo_bangbang.slx
BLOCK: Gain;Integrator;More Info;Phase Plane Plot;Sign;SubSystem
BLOCKTYPE: Gain;Integrator;Record;Signum
BLOCKTYPE_FREQUENCY: 1;2;1;1
CHECKSUM: 8E78A58E59F7A63F40F826360CA3C8EF
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
State Events This example shows how to handle state events. Run the simulation and see the phase plane plot, where the state x1 is along the X-axis and the state x2 is along the Y-axis. 

ANNOTATION:
State-Event Handling Example courtesy of James H. Taylor, Dept. of Elec Engr., UNB (For more information, double click on the ? or open the Model Explorer) Copyright 1990-2019 The MathWorks, Inc.


MODELNAME: sldemo_boiler
PATH: examples/simulink_general/main/sldemo_boiler.slx
BLOCKTYPE_FREQUENCY: 3;1;2;1;1;2;5;1;1;6;1;1;1;1;1;1;1;1
CHECKSUM: 8777414642A6E93D0D14B8F8E3DEB28C
PRODUCT: Embedded Coder;MATLAB;Simulink;Stateflow
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Bang-Bang Control Using Temporal Logic This example shows how to use Stateflow(R) to model a bang-bang temperature control system for a boiler. The boiler dynamics are modeled in Simulink(R). The Bang-Bang Controller Stateflow chart shows how to use functions and Subcharts within Stateflow. 

ANNOTATION:
This subsystem models a typical 8-bit analog-to-digital converter having an input range of 0-5 volts This subsystem models a digital thermometer composed of a simple temperature sensor and an ADC. The transfer function of the sensor is: V = .05 * T + 0.75 for T in degrees C. The conversion block inverts the combined transfer function of the sensor and ADC so that the output is an sfix(8) code representing T in degrees C. Bang-Bang Control Using Temporal Logic for Temperature Control of a Boiler Copyright 1990-2020 The MathWorks, Inc.

BLOCK:
 Demux ; SFunction ; Terminator ;1 sec Timer;ADC;Bang-Bang Controller;Boiler Command;Boiler Plant model;Data Type Conversion;Gain;Integrator;LED;Linear fixed point conversion;More Info;Scope;SubSystem;Switch;Temperature (C);Temperature Set Point;actual temp;boiler;cooling rate;digital temp;digital thermometer;heating rate;limit;on/off;pcm;quantize;reference;scale;sec;sensor;temp;voltage

BLOCKTYPE:
Constant;CustomWebBlock;DataTypeConversion;Demux;DiscretePulseGenerator;Gain;Inport;Integrator;LampBlock;Outport;Polyval;Quantizer;S-Function;Saturate;Scope;Switch;Terminator;TriggerPort


MODELNAME: sldemo_bounce_two_integrators
PATH: examples/simulink_general/main/sldemo_bounce_two_integrators.slx
BLOCKTYPE: Compare To Zero;Constant;Gain;Ground;InitialCondition;Integrator;Scope;Terminator
BLOCKTYPE_FREQUENCY: 1;1;1;1;2;2;1;1
CHECKSUM: A378B6DB67A3F52562418E5DED307721
PRODUCT: MATLAB;Simulink;Simulink Coder
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Bouncing Ball Model This model calculates the trajectory, over time, of a ball thrown upward with a velocity of 15 meters per second from a height of 10 m. The position of the ball is plotted in the upper axis of the scope while the velocity of the ball is plotted in the lower axis. For the recommended approach to modeling a bouncing ball, type sldemo_bounce at the MATLAB prompt. 

ANNOTATION:
Bouncing Ball Model Two separate Integrators are less efficient than a single Second-Order Integrator for simulating a bouncing ball. Click here to see sldemo_bounce for the recommended modeling approach. Copyright 1990-2022 The MathWorks, Inc.

BLOCK:
Coefficient of Restitution;Compare To Zero;Gravitational Acceleration;Ground;Initial Position;Initial Velocity;More Info;Position;Reference;Scope;SubSystem;Terminator;Velocity


MODELNAME: sldemo_counters
PATH: examples/simulink_general/main/sldemo_counters.slx
ANNOTATION: Counters Using Conditionally Executed Subsystems Copyright 1990-2023 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 2;3;3;1;3;1;1;2;1;1;5;1;2;1;1;2;2
CHECKSUM: 367687CCCE90E5ED7956D15792B2C92C
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Counters Using Conditionally Executed Subsystems This model shows the contrast between enabled subsystems and triggered subsystems for the same control signal, through the use of counter circuits. After running the simulation, the scope shows three plots. The first of these plots shows the control signal which is the output of the discrete pulse generator. The second plot shows the output of the counter circuit in the enabled subsystem. The counter increments while the subsystem is enabled and then holds its output when the subsystem is disabled. The counter resets to zero when the subsystem is re-enabled because the enable port was configured to reset states when enabling. The third plot shows the output of the counter circuit in the triggered subsystem. The counter increments every rising edge of the control signal. The signals are shown in a Signal Viewer scope that does not require a scope block to be put into the block diagram. Instead, the scope icon notation on the ports show that a Signal Viewer is attached. Double click on the scope icon to make the Signal Viewer appear if it is hidden. 

BLOCK:
Bias;Callback Button;Check if Tank level stays higher than limit for more than 30 seconds;Check if tank level goes above limit;Check if tank level goes below limit;Close Intake Valve;Compare To Constant;Constant;Constant Outflow;Cumulative Flow;Emergency Indicator;Enable;Flow Difference;Merge;Number of times overflow occurs;Open Intake Valve;Overflow Counter;Overflow detected;Reference;Scope;Sensor sample time = 1sec;SubSystem;Tank Area;Tank Dynamics;Tank Height;Tank Inflow;Tank Outflow;Terminator;Trigger;Unit Delay;Valve Cmd;ValveCmd;ValveCmd & TankHeight;Water Tank

BLOCKTYPE:
Bias;Compare To Constant;Constant;CustomCallbackButton;CustomWebBlock;EnablePort;Gain;Inport;Integrator;Merge;Outport;RateTransition;Scope;Sum;Terminator;TriggerPort;UnitDelay


MODELNAME: sldemo_dblcart1
PATH: examples/simulink_general/main/sldemo_dblcart1.slx
ANNOTATION: Double Mass-Spring System Copyright 1990-2023 The MathWorks, Inc.
BLOCKTYPE: Demux;Gain;M-S-Function;Mux;Scope;SignalGenerator;StateSpace;Sum;Terminator
BLOCKTYPE_FREQUENCY: 2;1;1;3;2;1;2;1;2
CHECKSUM: 33E56F6DEB4A8ED4D2379ECCA7502909
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Double Spring Mass System This example shows how to model a double spring-mass-damper system with a periodically varying forcing function. Associated with the example is an animation function that will automatically open a figure window and display to it. In this system, the only sensor is attached to the mass on the left, and the actuator is attached to the mass on the left. State estimation and LQR control are used.

BLOCK:
Actual Position;Animation function;Demux;Estimated Position;Estimator;Feedback Gain Using LQR Design;More Info;Mux;Plant;Signal Gen.;SubSystem;Sum;Terminator


MODELNAME: sldemo_doublebounce
PATH: examples/simulink_general/main/sldemo_doublebounce.slx
BLOCKTYPE_FREQUENCY: 4;2;2;2;4;12;4;1;2;2;3;6;2;1;2;2;2
CHECKSUM: 5D1C2ECCEFDE18C6CBBA1B9E529333BB
PRODUCT: MATLAB;Simulink;Simulink Coder
PRODUCT_BASECODE: SL;VR
ANNOTATION:
Passing Zeno : Double Bouncing Ball Copyright 1990-2013 The MathWorks, Inc. Toggle Sound (off by default) Toggle Sound (off by default)

BLOCK:
Animation;Animation ;Ball Position ;Collision position;Compare;Data Type Conversion;Elasticity;Free Drop Ball ;Gravity;Ground;Ground 1 Level;Ground 2 Level;Hit trigger;In;Initial Position;Initial Velocity;MATLAB Fcn;Manual Switch;More Info;Mux;Out;Position;Position of Ball ;Scope;Sound ;Sound Control Adjust this if sound is not good. =0 Disable sound;SubSystem;Terminator;Trigger;Velocity;ground ;sound delay;trigger

BLOCKTYPE:
Constant;DataTypeConversion;Gain;Ground;InitialCondition;Inport;Integrator;M-S-Function;MATLABFcn;ManualSwitch;Mux;Outport;RelationalOperator;Scope;Step;Terminator;TriggerPort


MODELNAME: sldemo_foucault
PATH: examples/simulink_general/main/sldemo_foucault.slx
BLOCKTYPE: Constant;DegreesToRadians;Gain;Product;Scope;SecondOrderIntegrator;Sum;Trigonometry
BLOCKTYPE_FREQUENCY: 1;1;4;2;1;2;2;1
CHECKSUM: BA3A58049EA21FBBEEBF373B4AEEDC11
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
ANNOTATION:
 vy  vx  x  y This model solves the differential equations for the Foucault Pendulum problem and plots the position of the pendulum bob in the XY plane. You can access or modify the parameters (g, \Omega, L and initial conditions) in MATLAB workspace. Foucault Pendulum Model Copyright 1990-2023 The MathWorks, Inc.

BLOCK:
Add;Animation;Degrees to Radians;Gain;Integrator, Second-Order;Latitude +North;More Info;Product;Reference;Scope;Sin;SubSystem


MODELNAME: sldemo_foucault_vr
PATH: examples/simulink_general/main/sldemo_foucault_vr.slx
BLOCKTYPE_FREQUENCY: 6;2;5;2;5;1;2;2;1;1;2;1;3;2
CHECKSUM: 900C4CB881D6FFA9C7BB17E848002A94
PRODUCT: MATLAB;Simulink;Simulink 3D Animation;Simulink 3D Animation Documentation
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Foucault Pendulum Model with VRML Visualization This model solves the differential equations for the Foucault Pendulum problem and displays the pendulum bob movement in the VRML scene. You can modify the Pendulum location by changing the Latitude / Longitude constant values in the model and other parameters (g, \Omega, L and initial conditions) in MATLAB(R) workspace. There are two VRML scenes associated with this model. The first scene shows the Foucault pendulum itself, the second shows geographical position of the pendulum on the Earth. During the simulation, two arrow markers indicate the current and the initial position of the pendulum in the Earth coordinate system.

ANNOTATION:
This model solves the differential equations for the Foucault Pendulum problem and displays the pendulum bob movement in the VRML scene. You can modify the Pendulum location by changing the Latitude / Longitude constant values in the model and other parameters (g, \Omega, L and initial conditions) in MATLAB(R) workspace. Foucault Pendulum Model with VRML Visualization lambda Copyright 1998-2012 The MathWorks, Inc.

BLOCK:
Constant;Degrees to Radians;Down vector;Earth Rotation Speed;Gain;Integrator;Latitude +North;Length of Rope + Bob;Longitude +East;More Info;Mux;Pendulum Length;Product;Reference;Rope Angle;Rotation Between 2 Vectors;Scope;SubSystem;Sum;Trigonometric Function;VR Coords Transformations;VR Signal Expander;VR Sink - Geodetic Location;VR Sink - Pendulum Scene;x;y

BLOCKTYPE:
Constant;DegreesToRadians;Gain;Inport;Integrator;Mux;Outport;Product;Rotation Between 2 Vectors;Scope;Sum;Trigonometry;VR Signal Expander;Virtual Reality Sink


MODELNAME: sldemo_hardstop
PATH: examples/simulink_general/main/sldemo_hardstop.slx
BLOCKTYPE_FREQUENCY: 1;2;1;1;3;1;1;1;4;2;2;1;1;6;2;1;2;1;1
CHECKSUM: 8BE306EFE56E89EA210420D556B6AB74
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Friction Model with Hard Stops This example shows how to model friction one way in Simulink(R). The two integrators in the model calculate the velocity and position of the system, which is then used in the Friction Model to calculate the friction force. Running the simulation shows the initial condition response on the Scope. 

ANNOTATION:
Use direct state access to break algebraic loop Friction Model with Hard Stops Copyright 1990-2023 The MathWorks, Inc.

BLOCK:
Abs;Against Limit;F_fr;Fn;Force;Force to Velocity;Friction Model;From;Goto;Hit Crossing;IC;Kspring;Min;More Info;Normal Force;Product;Reset Velocity at non-zero time;ResetLogic;Scope;Sign;Stuck;SubSystem;Sum;Switch;Velocity;Velocity to Position;Velocity_stateport;X;cast;mu_kinetic;mu_static

BLOCKTYPE:
Abs;Constant;DataTypeConversion;From;Gain;Goto;HitCross;InitialCondition;Inport;InportShadow;Integrator;Logic;MinMax;Outport;Product;Scope;Signum;Sum;Switch


MODELNAME: sldemo_househeat
PATH: examples/simulink_general/main/sldemo_househeat.slx
BLOCKTYPE_FREQUENCY: 1;1;3;1;2;1;4;1;5;2;1;3;1;1;3;1;5
CHECKSUM: BDCE5B0AF80847785D668A9CCB0F1261
PRODUCT: MATLAB;Simulink;Simulink Test Documentation
PRODUCT_BASECODE: SL;VR
ANNOTATION:
Heater Subsystem Thermodynamic Model for the House Thermostat Subsystem Thermal Model of a House Copyright 1990-2023 The MathWorks, Inc.

BLOCK:
1/Mc;Avg Outdoor Temp;Blower switch;Bus Creator;Celsius to Fahrenheit;Cost Calculator;Daily Temp Variation;Fahrenheit to Celsius;Fahrenheit to Celsius ;From;Goto;Heat Losses;HeatCost;HeatFlow;HeatGain;Heater;Heater Air Temperature;Heater QDot In;Heater Switch;House;Integrator;Knob;More Info;On/Off;Outdoor Temp Tout;PlotResults;Reference;Relay;Room Temp Troom;Scope;Set Point;SubSystem;Sum;Terr;Thermostat;Troom

BLOCKTYPE:
BusCreator;CelsiusToFahrenheit;Constant;Display;FahrenheitToCelsius;From;Gain;Goto;Inport;Integrator;KnobBlock;Outport;Product;Relay;Scope;Sin;Sum


MODELNAME: sldemo_hydcyl4
PATH: examples/simulink_general/main/sldemo_hydcyl4.slx
ANNOTATION: Four Cylinder Simulation Copyright 1990-2012 The MathWorks, Inc.
BLOCKTYPE: BusCreator;Clock;Gain;Outport;Pump;Ramp;Scope;Sum;Terminator;Valve/Cylinder/Piston/Spring Assembly
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1;2;1;4;4
CHECKSUM: 7F511ABE39F1114D7753E1C0CF5F52ED
PRODUCT: MATLAB;Simulink;Simulink Test Documentation
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Four Hydraulic Cylinder Simulation This example uses Simulink(R) to create a model with four hydraulic cylinders. See two related examples that use the same basic components: * single cylinder model: sldemo_hydcyl * model with two cylinders and load constraints: sldemo_hydrod 

BLOCK:
A;Bus Creator;Clock;Control Valve Command;Gain;Load Flow;More Info;Positions (m) x1 (yellow) x2 (purple) x3 (blue) x4 (red);Pump;Reference;SubSystem;Supply Pressure p1 (Pa);Terminator;Valve/Cylinder/Piston/Spring Assembly 


MODELNAME: sldemo_hydrod
PATH: examples/simulink_general/main/sldemo_hydrod.slx
ANNOTATION: Two Cylinder with Connecting Rod Simulation Copyright 1990-2020 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 1;1;6;2;2;1;2;1;2;2;1;2;2
CHECKSUM: 3AAADDC28BC2A1193575B3E794BE7712
PRODUCT: MATLAB;Simulink;Simulink Test Documentation
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Two Cylinder Model with Load Constraints In this model, a rigid rod supporting a large mass interconnects two hydraulic actuators. The model eliminates the springs as it applies the piston forces directly to the load. These forces balance the gravitational force and result in both linear and rotational displacement. See two related demos that use the same basic components: * four cylinder model: sldemo_hydcyl4 * single cylinder model: sldemo_hydcyl 

BLOCK:
A;B;Bus Creator;Constant;Cylinder B;Mechanical Load;More Info;Orifice A;Orifice B;Pressure A (PSI);Pressure B (PSI);Pressure sensor B;Reference;Selector;SubSystem;Terminator;Valve/Cylinder/Piston Force Assembly ;Vertical Gauge;load flow;orifice A;orifice B;pump;theta (rad);z (purple), za (blue) & zb (yellow) (m)

BLOCKTYPE:
BusCreator;Constant;CustomWebBlock;Gain;Inport;Pump;Repeating table;Rod;Scope;Selector;Sum;Terminator;ValveCylinderPistonForceAssy


MODELNAME: sldemo_metro
PATH: examples/simulink_general/main/sldemo_metro.slx
BLOCKTYPE_FREQUENCY: 3;26;22;8;1;3;1;2;14;12;1;7;6
CHECKSUM: A4AAF6A28A1339DA05B2863ACD1458AC
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
ANNOTATION:
Acceleration of moving base Exploring the Solver Jacobian Structure of a Model Copyright 2010-2015 The MathWorks, Inc.

BLOCK:
-m/(M+n*m);Add;Gain;In;Integrator;Math Function;Metronome;Metronome Animation;More Info;Moving base;Mux;Product;S-Function;Scope;SubSystem;Trigonometric Function;d2/dt2(sin(theta);d2/dt2(sin(theta1));d2/dt2(sin(theta2));d2/dt2(sin(theta3));escapement angle;friction;in_;intertia;r;theta;thetadot;thetadotdot;x;xdotdot

BLOCKTYPE:
Bias;Gain;Inport;Integrator;M-S-Function;Math;Metronome animation plot;Mux;Outport;Product;Scope;Sum;Trigonometry


MODELNAME: sldemo_solvers
PATH: examples/simulink_general/main/sldemo_solvers.slx
BLOCK: Gain;Integrator;More Info;Mux;NormalizeEnergy;Scope;SubSystem;Sum
BLOCKTYPE: Fcn;Gain;Integrator;Mux;Scope;Sum
BLOCKTYPE_FREQUENCY: 1;4;4;1;1;2
CHECKSUM: 95D3670A7CDAEA6486A115B1874C83F9
PRODUCT: MATLAB;Simulink;Simulink Coder
PRODUCT_BASECODE: SL;VR
ANNOTATION:
This model simulates a Foucault pendulum (a stiff system). The model calculates the normalized pendulum energy, E. Model of a Stiff System Copyright 1990-2013 The MathWorks, Inc.


MODELNAME: sldemo_tank
PATH: examples/simulink_general/main/sldemo_tank.slx
ANNOTATION: Flow Difference Tank Fill and Empty Example / Animation Copyright 1990-2022 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 1;1;1;5;1;3;1;9;1;1;2;2;8;1;1;1;1;2;1;4
CHECKSUM: 2F0C0D3B116D936D60FE8B105313A4B4
PRODUCT: MATLAB;Simulink;Simulink 3D Animation Documentation
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Tank Fill and Empty with Animation This example shows how to model the dynamics of liquid in a tank. The associated animation provides a graphical display of the tank as it empties and refills, based on user-defined tank parameters. The tank empties at the start of the simulation and again part way through the simulation. When the simulation is stopped, a plot is generated showing the liquid height and the states of the two valves. 

BLOCK:
 ;!Q;Abs;Animation;Cumulative Flow;Data Type Conversion;Demux;Flow Rate - In;Flow Rate - Out;Flush Signal;In Valve;In Valve Position;In Valve Setpoint;Logic;Memory;More Info;Mux;Out Valve;Outflow Rate;Outvalve;Q;R;Reference;S;S-Function;S-R Flip-Flop;Scope;Signal Editor;SubSystem;Sum;Tank Area;Tank Dynamics;Tank Height;Tank Height Crosses Lower Limit;Tank Inflow;Tank Outflow;Terminator;To Workspace;Valve Position;ValveFlow;Water Height

BLOCKTYPE:
Abs;CombinatorialLogic;Constant;DataTypeConversion;Demux;Gain;HitCross;Inport;Integrator;M-S-Function;Memory;Mux;Outport;RelationalOperator;S-R Flip-Flop;Scope;SignalEditor;Sum;Terminator;ToWorkspace


MODELNAME: sldemo_tc
PATH: examples/simulink_general/main/sldemo_tc.slx
BLOCKTYPE_FREQUENCY: 3;2;2;1;1;3;1;1;1;4;1;1;1;2;1;1
CHECKSUM: AAEB4D85142A58F5F0487914DC3BC93B
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Thermocouple Modeling and Signal Conversion The thermocouple is one of the popular analog transducers today, along with other devices such as position sensors, strain gages, pressure transducers, and resistance temperature devices (RTDs). Operating under the principle of the Seebeck (or thermoelectric) effect, thermocouples have an empirically determined nonlinear behavior that is well known over each junction types useful operating range. If you run the model, you will be able to see the cumulative effect of each component on dynamic measurement accuracy. This demonstration will focus on models for each of these components in a dynamic temperature measurement system for a Type S (Platinum-10% Rhodium(+) versus Platinum(-) ) : a thermocouple device and probe assembly, a signal conditioning method, an analog to digital converter (ADC), and a software specification for converting the ADC output back into a temperature value. An additional section shows how to obtain and use standard NIST ITS-90 thermocouple data with Simulink models. Look-up tables and a polynomial block are used in this design to capture the nonlinear behavior of the thermocouple. Note that the polynomial block is a viable alternative to look-up tables for some applications, minimizing ROM usage at the cost of some additional computation for the full polynomial representation. 

ANNOTATION:
12 bits in full scale range corresponds to an LSB size on the order of ~0.5 degC and an in-range error of ~0.25 degC. Input: 0 to 4095 integer counts , where 0 counts corresponds to 0 input volts and -0.236 thermocouple millivolts 4096 counts corresponds to 5 input volts and 18.661 thermocouple millivolts Tables derived from ITS-90 thermocouple reference data from NIST Standard Database 60 related to NIST Monograph 175 (ITS-90).  Direct look-up table is fast and has no numerical precision issues, but requires 4096 data points in table Interpolated table look-up uses far fewer data points, but loses some accuracy and requires more computation. This block intentionally has no contents. This block intentionally has no contents. This block intentionally has no contents. Temperature measurement system A chain of components from physical phenomenon to software values  1) The thermocouple model has a polynomial for a Type S thermo- couple using data from NIST Standard Database 60 as well as a simple model of the probe and bead time constant. 2) The analog to digital converter (ADC) subsystemincludes analog scaling and filtering, plus a sampled data quantizer. Conversion time is not modeled as it is typically ~2 orders of magnitude smaller in time scale compared to the rest of the simulation. 3) Two conversion techniques are used in the software specification to show some of the options available for modeling nonlinear behavior. Continuous time Discrete time Continuous & Discrete (mixed) Look inside each subsystem: Copyright 1990-2015 The MathWorks, Inc.

BLOCK:
1 Type S Thermocouple model;2 ADC input and hardware model;3 Software specification for converting ADC values to temperature;Anti-aliasing filter;Clocked Sample and Hold;Data Type Conversion;E_bits;E_tc;E_tc_Volts;Idealized ADC quantizer;More Info;Mux;Reference;Scope;Square wave source for generating temperature values;SubSystem;T_actual;Thermocouple probe time constant is 30 msec;Tmeas_direct;Tmeas_interp;Type S direct conversion;Type S interpolated conversion;Type S thermocouple polynomial model;analog bias;analog scaling gain for 0-5 Volts full scale range (ignore amplifier dynamics);bias;bits;cvt_uV_to_V;z: jump to ADC example;z: jump to prebuilt models;z: jump to table data file

BLOCKTYPE:
ADC quantizer details;Bias;DataTypeConversion;Gain;IdealADC;Inport;LookupNDDirect;Lookup_n-D;Mux;Outport;Polyval;Scope;SignalGenerator;TransferFcn;UnitConversion;ZeroOrderHold


MODELNAME: sldemo_tc_blocks
PATH: examples/simulink_general/main/sldemo_tc_blocks.slx
BLOCKTYPE: Inport;Lookup_n-D;Outport;Switch
BLOCKTYPE_FREQUENCY: 1;17;1;1
CHECKSUM: 4E06FEE5EBF013391690CEE1CCFF94FF
PRODUCT: MATLAB;Simulink;Simulink 3D Animation Documentation
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
ITS-90 Thermocouple Models Full-Range 2 degrees Celsius Interpolated Thermocouple Tables created using one ITS-90 Interpolating Polynomial and one inverse polynomial per junction type. 

ANNOTATION:
Full-Range 2 degrees Celsius Interpolated Thermocouple Tables created from ITS-90 Interpolating Polynomials Note: this model has data in its Model Workspace. Browse/Edit the model workspace from the View / Model Explorer menu item. To use these blocks, load data into the model workspace or base workspace: >> load sldemo_tc_blocks_data.mat Copyright 1990-2013 The MathWorks, Inc.

BLOCK:
More Info;SubSystem;Switch;Thermocouple conditioning ;Thermocouple conditioning B lower;Thermocouple conditioning B upper;Thermocouple model ;degC;u


MODELNAME: sldemo_tonegen
PATH: examples/simulink_general/main/sldemo_tonegen.slx
BLOCKTYPE: Counter Limited;Gain;LookupNDDirect;Lookup_n-D;Outport;Sum;Trigonometry
BLOCKTYPE_FREQUENCY: 1;3;1;1;3;3;2
CHECKSUM: A4D3A76FD2F115B7301990904498E07B
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Tone Generation Algorithm Comparison Uses a sampled sine wave designed using ssinthd.m to see how it works as a direct lookup, with linear interpolation and with CORDIC approximation. This model compares the output of the floating point tables to the sin() function. As expected from the THD calculations, the linear interpolation has a lower error than the direct table lookup in comparison to the sin() function. The CORDIC approximation has a lower error than linear interpolation. 

ANNOTATION:
Comparison in approximate sine wave accuracy between direct lookup, linear interpolation, and CORDIC approximation versus reference signal Copyright 1990-2013 The MathWorks, Inc.

BLOCK:
 ;CORDIC approximation;Counter Limited;More Info;Reference;SubSystem;Sum;direct sine table;double_approximation;double_direct;double_linear;index to angle;linear sine table;quarter steps


MODELNAME: sldemo_tonegen_fixpt
PATH: examples/simulink_general/main/sldemo_tonegen_fixpt.slx
BLOCKTYPE_FREQUENCY: 1;1;3;4;1;1;7;3;1;4;2
CHECKSUM: 94B9FDB9DED5D06F2C0400A26172467F
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Generating Sine Waves with Floating Point and Fixed Point Data This model lets you compare a variety of techniques available in Simulink for generating sine waves.Simulink includes a sine wave source block with continuous and discrete modes, plus fixed point sine and cosine function blocks that implement the function approximation with a linearly interpolated lookup table that exploits the quarter wave symmetry of sine and cosine. The model also compares fixed point sine CORDIC approximation from Trigonometric Function block with the reference signal. 

ANNOTATION:
Additional blocks to calculate sine and approximate sine using various algorithms Copyright 1990-2013 The MathWorks, Inc.

BLOCK:
 ;CORDIC approximation;Clock;Counter Limited;Reference;Sine;Sine Wave;Sine Wave ;Sum;direct sine table;fixpt_approximation;fixpt_direct;fixpt_linear;index to angle;linear sine table;omega cycles_per_sec;omega rad_per_sec;quarter steps;sampled sine wave;sine wave;time based sin() vs reference;to fixpt;to fixpt 

BLOCKTYPE:
Clock;Counter Limited;DataTypeConversion;Gain;LookupNDDirect;Lookup_n-D;Outport;Sin;Sine and Cosine;Sum;Trigonometry


MODELNAME: sldemo_zeroxing
PATH: examples/simulink_general/main/sldemo_zeroxing.slx
ANNOTATION: Zero-Crossing Detection Demonstration Copyright 1990-2013 The MathWorks, Inc.
BLOCKTYPE: Abs;Clock;Constant;Mux;Outport;RelationalOperator;Saturate;Scope;Sin;Switch
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1;1;1;1;1
CHECKSUM: 920257FE3E0044C6A2C8CE0D5D61C5E4
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
DESCRIPTION:
Accurate Zero-Crossing Detection This example shows how zero crossings work in Simulink(R). In this model, three shifted sine waves are fed into an absolute value block and saturation block. At exactly t = 5, the output of the switch block changes from the absolute value to the saturation block. Zero crossings in Simulink will automatically detect exactly when the switch block changes its output, and the solver will step to the exact time that the event happens. This can be seen by examining the output in the scope. 

BLOCK:
Abs;Clock;Constant;More Info;Mux;Relational Operator;Saturation;Scope;Sine Wave;SubSystem;Switch;t <= 


MODELNAME: ASVDemo
PATH: examples/simulink_general/projects/src/MarineVessel/Model/ASVDemo.slx
CHECKSUM: 1702A5C2C8E4C241D4B27D7D8B2C67F5
PRODUCT: Aerospace Blockset;MATLAB;Simulink;Stateflow;UAV Toolbox
PRODUCT_BASECODE: SL;VR
ANNOTATION:
 % kinematic differential equation  % along-track and cross-track errors (x_e, y_e) expressed in NED  % psi_d = ILOSpsi(x,y,Delta,kappa,h,R_switch,wpt,psi) computes the desired % heading angle when the path is straight lines going through the waypoints % (wpt.pos.x, wpt.pos.y). The desired heading angle psi_d is computed using % the ILOS guidance law by Børhaug et al. (2008), % % psi_d = pi_p - atan( Kp * y_e + Ki * y_int), Kp = 1/Delta, Ki = kappa * Kp % % Dy_int = Delta * y_e / ( Delta^2 + (y_e + kappa * y_int)^2 ) % % where pi_p is the path-tangential angle with respect to the North axis % and y_e is the cross-track error expressed in NED.   T. I. Fossen and T. Perez (2004). Marine Systems Simulator (MSS). URL: https://github.com/cybergalactic/MSS  This demo uses the ground truth from the vessel states. To use synthesized sensor data and navigation algorithms, please read: - https://www.mathworks.com/help/fusion/sensor-models.html - https://www.mathworks.com/help/fusion/inertial-sensor-fusion.html?s_tid=CRUX_lftnav  Reference: Guidance System for Autonomous Surface Vehicles, Thomas Stenersen, NTNU https://ntnuopen.ntnu.no/ntnu-xmlui/bitstream/handle/11250/2352498/12747_FULLTEXT.pdf  % Use yaw angle for now instaed of course angle.   Reference: Guidance System for Autonomous Surface Vehicles, Thomas Stenersen, NTNU https://ntnuopen.ntnu.no/ntnu-xmlui/bitstream/handle/11250/2352498/12747_FULLTEXT.pdf  Reference: Guidance System for Autonomous Surface Vehicles, Thomas Stenersen, NTNU https://ntnuopen.ntnu.no/ntnu-xmlui/bitstream/handle/11250/2352498/12747_FULLTEXT.pdf  Reference: Guidance System for Autonomous Surface Vehicles, Thomas Stenersen, NTNU https://ntnuopen.ntnu.no/ntnu-xmlui/bitstream/handle/11250/2352498/12747_FULLTEXT.pdf  % Use yaw angle for now instaed of course angle.   % Use yaw angle for now instaed of course angle.   % Use yaw angle for now instaed of course angle.   This demo uses the ground truth from the vessel states. To use synthesized sensor data and perception algorithms, please read: - https://www.mathworks.com/help/uav/ref/uavscenariolidar.html - https://www.mathworks.com/help/fusion/multi-object-trackers.html  T. I. Fossen and T. Perez (2004). Marine Systems Simulator (MSS). URL: https://github.com/cybergalactic/MSS Waypoint Following Start/Stop  START/STOP Remote Control  REMOTE CONTROL  Waypoint Following   T. I. Fossen and T. Perez (2004). Marine Systems Simulator (MSS). URL: https://github.com/cybergalactic/MSS [-67, 120] N for each [-102, 104] rad/s  T. I. Fossen and T. Perez (2004). Marine Systems Simulator (MSS). URL: https://github.com/cybergalactic/MSS  Collision Avoidance and Trajectory Tracking of a Marine Vessel  Copyright 2023 The MathWorks, Inc.

BLOCK:
 ; Demux ; Payload Mass (kg) ; SFunction ; Terminator ; X; X ; mass (kg); mass (kg) ;1/k_pos;6DOF (In CO);ASV Scenario Configuration;ASV Scenario Motion Read Vessel;ASV Scenario Motion Write;ASV Scenario Scope ;Abs;Acc X (m/s2);Acc Y (m/s2);Acc Z (m/s2);Add;Added Mass (Hydrodynamcis);Added Mass (Hydrodynamics);Added Mass (Hydrodynamics) ;Angular Acc X (rad/s2);Angular Acc Y (rad/s2);Angular Acc Z (rad/s2);Atan;B;Ballast;Behavior Planning;Bus Creator;Bus Element In;Bus Element Out;Bus Selector;CA;CG corrected for payload;CG corrected for payload (m);CG hull only (m);CG hull only (m) ;COLREGs Rules;COLREGs Situation;COLREGs Situation Vessel;CRB;Closest Point of Approach;Collision Avoidance;Collision Avoidance (bool);Collision Avoidance Mode;CollisionAvoidance_bool;Compute CA;Compute tau_crossflow;Comupute CRB;Constant;Control ;Control Allocation;Controller;Coordinate Transformation Conversion;Coriolis;Coriolis ;Course Angle;Create 3x3 Matrix;Create Diagonal Matrix;Crossflow;Current;Current Direction (rad);Current Speed (m/s);Current direction (deg);Current speed (m/s);Damping;Damping (Hydrodynamics);Degrees out;Degrees to Radians;Demux;Desired Speed (m/s);Desired Yaw Angle (rad);Desired moment in yaw (Nm);Desired moment in yaw (Nm) ;Desired thrust in surge (N);Desired thrust in surge (N) ;Discrete PID Controller;Discrete-Time Integrator;Distance to avoid collision (m);Divide;Dot Product;Draft (m);Draft (m) ;Earth;Environment ;Equal;Flat Earth to LLA;Forces and Moments;From;G;GM;GM_L;GM_T;G_CF;G_CF (spring stiffness matrix in the CF);Gain;Goto;Gravity (m/s2);Gravity (m/s2) ;Ground;Ground Truth;Guidance ;H;HMI;HMI (Remote Control);Heading Control;Heave Velocity (m/s);Hydrodynamics;Hydrostatic;IC;ILOS guidance law;Idld Mode;Idle;Ig;Inertial Matrix (hull and payload) in CO;Inertial Matrix (hull and payload) in CO ;Inertial Matrix in CG;Inertials;Inertials ;Initial Condition;Initial States;Input Processing;Integrator;Ki;Kinematics;Knob;Kp;L;Location of payload (m);Look ahead distance (m);Look ahead distance (m) ;M;MA;MATLAB System;MRB_CG;Matrix Concatenate;Matrix Multiply;Mode;Mode Transitions;Mux;NOT;Natural Frequencies;Natural Frequencies ;Navigation;Output Processing;PID Controller;Payload ;Payload Location (m);Payload Location (m) ;Payload Mass (kg);Payload Mass (kg) ;Payload mass (kg);Pitch Angle (rad);Pitch Rate (rad/s);Planning ;Product;Propeller Dynamics;Propeller Dynamics ;Push Button;R_switch;Radians to Degrees;Rate Limiter;Reference;Relational Operator;Relative Bearing;Relative Velocity;Relative Velocity ;RelativeVelocity;Remote Control;Remote Controlled (bool);Reshape;Rocker Switch;Roll Angle (rad);Roll Rate (rad/s);Rotation Angles to Direction Cosine Matrix;Rotation Angles to Quaternions;S;Saturation Dynamic;Scenario;Selector;Sign;Signed Square Root;SinCos;Situation;Situation Assessment;Situational Awareness;Slider;Smtrx;Smtrx ;Speed Control;Spring Stiffness Matrix in CO;Sqrt;Start/Stop (bool);Steering to avoid collision (deg);Stop;SubSystem;Sum;Sum of Forces and Moments;Surge Velocity (m/s);Sway Velocity (m/s);Switch;T;Td;Terminator;Threshold of Boundary Distance (m);Threshold of Distance of CPA (m);Threshold of Time of CPA (sec);Thrust;Thrust configuration matrix;Toggle Switch;Transfer Fcn;Transform CF to CO;Transform CG to CO;Transform CG to CO ;Transpose;Trigonometric Function;V_c;Velocity;Vessel Platform;VesselCommand;VesselStates;Volume;Volume (m3);Water;Water Density (kg/m3);Water Density (kg/m3) ;Waves and Crossflow;Waypoint Following (bool);Waypoint Reset (bool);WaypointFollowing_bool;WaypointReset_bool;Waypoints (x,y);X;X ;Yaw Angle (rad);Yaw Rate (rad/s);a;angle;angle_pipi;beam pontoon (m);beam pontoon (m) ;beam_pontoon_m;beta;beta_c;beta_rad;block coefficient;collision_b;collision_bool;course;course (rad);d;d_CPA;d_CPA_m;d_boundary;d_min;dot_x_y_z_phi_theta_psi;g;go to next waypoint threshold (m);integral gain;length (m);length (m) ;length_m;lever_arm_left_propeller_m;lever_arm_right_propeller_m;mass (kg);mass (kg) ;mp;n * abs(n);nabla;norm;nu_r;pA;pA ;pB;pB ;pqr;r;rg;rho;rp;sector;speed (signed m/s);ssa ;steer;t_CPA;t_CPA_s;t_max;tau;tau_crossflow;vA;vB;vector;w3 w4 w;waypoints_m;x;x (m);xRef_COLREGs;xRef_COLREGs_m;xRef_WaypointFollowing_m;xRef_m;xRef_m ;xRef_next_COLREGs;xRef_next_COLREGs_m;xRef_next_WaypointFollowing_m;xRef_next_m;x_m;y;y (m);yRef_COLREGs;yRef_COLREGs_m;yRef_WaypointFollowing_m;yRef_m;yRef_m ;yRef_next_COLREGs;yRef_next_COLREGs_m;yRef_next_WaypointFollowing_m;yRef_next_m;y_m;z (m)

BLOCKTYPE:
Abs;Ang2DCM;Ang2Quat;BusCreator;BusSelector;Concatenate;Constant;Create 3x3 Matrix;Create Diagonal Matrix;DegreesToRadians;Demux;DiscreteIntegrator;DotProduct;Flat Earth to LLA;From;Gain;Goto;Ground;Inport;InportShadow;Integrator;KnobBlock;Logic;MATLABSystem;Math;Mux;Outport;PID 1dof;Product;PushButtonBlock;RadiansToDegrees;RateLimiter;RelationalOperator;Reshape;RockerSwitchBlock;S-Function;Saturation Dynamic;Selector;Signum;SliderBlock;Sqrt;Sum;Switch;Terminator;ToggleSwitchBlock;TransferFcn;Transpose;Trigonometry;UAV Scenario Configuration;UAV Scenario Motion Read;UAV Scenario Motion Write;UAV Scenario Scope;robotics.slcore.internal.block.CoordinateTransformationConversion

BLOCKTYPE_FREQUENCY:
2;2;1;4;17;15;112;7;2;2;37;1;2;1;25;35;17;6;302;26;1;2;1;3;2;41;253;2;50;1;5;1;2;17;3;13;1;36;1;1;5;37;5;15;1;5;6;10;1;3;1;1;4


MODELNAME: BMSCurrPowerLimCalc
PATH: examples/simulink_general/projects/src/UseMBDtoBuildaBMS/Design/BMSCurrPowerLimCalc.slx
ANNOTATION: Copyright 2023 The MathWorks, Inc.
BLOCKTYPE: Gain;Inport;Lookup_n-D;MinMax;Outport
BLOCKTYPE_FREQUENCY: 4;10;6;6;8
CHECKSUM: 3C77EE7205F7EC86074ECF16CA4E0D6F
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
BLOCK:
Bus Element Out;CalculateMinMaxCells;CellTemperatures;CellVoltages;ChargeCurrentLimit;ChargeCurrentLimitCalc;DischargeCurrentLimit;DischargeCurrentLimitCalc;HighTempChrgCurrentLim;HighTempDchrgCurrentLim;In Bus Element;LowTempChrgCurrentLim;LowTempDchrgCurrentLim;MaxCellVoltChrgCurrentLim;MaxChrgCurrLim;MaxDchrgCurrLim;MinCellVoltDchrgCurrentLim;MinMax;Np;SubSystem


MODELNAME: BMSSOCEstimation
PATH: examples/simulink_general/projects/src/UseMBDtoBuildaBMS/Design/BMSSOCEstimation.slx
BLOCKTYPE: Constant;DiscreteIntegrator;Gain;Inport;Lookup_n-D;Outport;Product;Selector
BLOCKTYPE_FREQUENCY: 1;2;2;7;1;4;2;1
CHECKSUM: C3DCB1EBF05C865764458E6D09BD5924
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL;VR
ANNOTATION:
Capacity value should match what is used in Battery Model. Value obtained from Simscape Battery (Table-Based) parts info from a Panasonic NCR18650BD. Copyright 2023 The MathWorks, Inc.

BLOCK:
1-D Lookup Table;Bus Element Out;Capacity Dependent on Temperature;CellTemperatures;Constant;Constant Capacity;Coulomb Counting;Curr;Discrete-Time Integrator;Divide;Gain;PackCurrent;SOC;SubSystem;Temp


MODELNAME: BMSSwArchitecture
ANNOTATION: Copyright 2023 The MathWorks, Inc.
BLOCKTYPE: Inport;ModelReference;Outport
BLOCKTYPE_FREQUENCY: 12;2;8
CHECKSUM: 86DA5E6B5D52485C4ECCBC481A8614EA
PRODUCT: MATLAB;Requirements Toolbox;Simulink
PRODUCT_BASECODE: SL;VR
EXTERNALFILE_REFERENCE: BMSCurrPowerLimCalc.slx___Model_Block___BMSSOCEstimation.slx___Model_Block___
PATH:
examples/simulink_general/projects/src/UseMBDtoBuildaBMS/FunctionalityAndArchitecture/BMSSwArchitecture.slx

BLOCK:
Adapter;BatteryManagementSystem;Bus Element In;Bus Element Out;Cell_Temperatures;Cell_Voltages;Current Limits;CurrentandPowerLimitCalculation;EnergyManagementSystem;In Bus Element;Out Bus Element;Pack_Current;Pack_Voltage;SOC;SOCEstimation;Sensors;SubSystem


MODELNAME: sldemo_antiwindup
PATH: examples/simulink_industrial/main/sldemo_antiwindup.slx
ANNOTATION: Anti-Windup PID Control Example Copyright 2009-2022 The MathWorks, Inc.
BLOCKTYPE: Outport;PID 1dof;Saturate;Scope;Step;Sum;TransferFcn;TransportDelay
BLOCKTYPE_FREQUENCY: 1;1;1;2;1;1;1;1
CHECKSUM: C3A1C991AE3F9CF2C8A0D64B2773851D
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Dead Time;First Order Process;More Info;PID Controller;Plant Actuator;Reference;Scope;Step;SubSystem;Sum;yout


MODELNAME: sldemo_antiwindupactuator
PATH: examples/simulink_industrial/main/sldemo_antiwindupactuator.slx
ANNOTATION: Anti-Windup PID Control Example with Actuator Dynamics Copyright 2009-2022 The MathWorks, Inc.
BLOCKTYPE: Outport;PID 1dof;Saturate;Scope;Step;Sum;TransferFcn;TransportDelay
BLOCKTYPE_FREQUENCY: 1;1;1;2;1;1;3;1
CHECKSUM: 2B46399FE302B476B7B4A85B04AD08D9
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Actuator input dynamics;Actuator output dynamics;Dead Time;First Order Process;More Info;PID Controller;Plant Actuator;Reference;Scope;Step;SubSystem;Sum;yout


MODELNAME: sldemo_antiwindupfeedforward
PATH: examples/simulink_industrial/main/sldemo_antiwindupfeedforward.slx
ANNOTATION: Anti-Windup PID Control Example with Feedforward Control Copyright 2009-2022 The MathWorks, Inc.
BLOCKTYPE: Gain;Outport;PID 1dof;Saturate;Scope;Step;Sum;TransferFcn;TransportDelay
BLOCKTYPE_FREQUENCY: 1;1;1;1;3;1;3;1;1
CHECKSUM: 63E2A980825BE37B26F1203F985682FE
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Dead Time;Feedforward;First Order Process;More Info;PID Controller;Plant Actuator;Reference;Scope;Step;SubSystem;Sum;yout


MODELNAME: sldemo_bumpless
PATH: examples/simulink_industrial/main/sldemo_bumpless.slx
ANNOTATION: Bumpless Control Transfer Copyright 2009-2023 The MathWorks, Inc.
BLOCKTYPE: Outport;PID 1dof;Ramp;Saturate;Step;Sum;Switch;TransferFcn;TransportDelay
BLOCKTYPE_FREQUENCY: 1;1;3;1;1;2;1;1;1
CHECKSUM: 0A922F323494926510C71A14D8749989
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Add;Control Mode;Dead Time;First Order Process;More Info;PID Controller;Ramp;Reference;Saturation;Setpoint;SubSystem;Switch


MODELNAME: sldemo_hevc
PATH: examples/simulink_industrial/main/sldemo_hevc.slx
BLOCKTYPE_FREQUENCY: 1;1;1;1;3;3;5;1;4;1;1;1;1;4;1;5;1;6;1;1
CHECKSUM: EAC5866A840CAE9703DF9F635B66A5B9
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Motor Speed [rad/s] Desired Power  Vehicle acceleration a=F/m Hybrid Electrical Vehicle Control Copyright 2021 The MathWorks, Inc.

BLOCK:
 Force To Tire;Actual Speed [m/s];Aero Drag;Callback Button;Derivative;DriveTrain Power Output;Driver ;Engine Power;Engine Power [kW];Equivalent Efficiency Mot and Gen;Fcn;Gain;Integrator;MAX Power on Motor;Max Powertrain Force;Motor Power;Motor Power Limits [0 ~300];Motor Power Output;Motor Power [kW] ;Mux;Not Pass the Torque Limit;PeakPower;Plus;Power demand estimation;Power provided by Engine;Power provided by Mtor;Road Resistence;Scope;SubSystem;Sum;Target Speed [m/s];Transfer Fcn;Uncovered Torque from E-motor;Vehicle Dynamic;Vehicle Speed;Vehicle Speed ;Vehicle Speed [m/s];a=F/m;cmd;comand from -100% to 100% of the peak Motor Torque;driver cmd;kW to Watts;target speed [m/s];w_wh_rear

BLOCKTYPE:
Abs;Constant;CustomCallbackButton;Derivative;Fcn;From;Gain;Goto;Inport;Integrator;Lookup;ModelReference;Mux;Outport;Product;Saturate;Scope;Sum;Switch;TransferFcn


MODELNAME: sldemo_pid2dof
PATH: examples/simulink_industrial/main/sldemo_pid2dof.slx
ANNOTATION: \omega V_emf Td 2DOF PID Control Copyright 2009-2023 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 1;1;1;2;1;1;1;1;3;2;2;1
CHECKSUM: F53F8327752181810E96D9D478843F61
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Armature;DC Motor;Gain;Load;Load Torque;More Info;PID Controller (2DOF);Reference;Scope;Setpoint changes between 60 and 30 rpm;Signal Conversion;Signal Specification;Speed;SubSystem;Sum;Voltage

BLOCKTYPE:
DC Motor;DiscretePulseGenerator;Gain;Inport;Outport;PID 2dof;Scope;SignalConversion;SignalSpecification;Sum;TransferFcn;WaveformGenerator


MODELNAME: smart4iRobotDynamics
PATH: examples/simulink_industrial/main/smart4iRobotDynamics.slx
BLOCKTYPE_FREQUENCY: 4;4;2;9;11;4;2;2;12;10;2;2;2;71;2;2;10;5;8;78;2;8;7;2;8;1;12;2;14;9;2;2;2;2
CHECKSUM: 1ED03867BAA8C050A0DCD8CCC1F62E17
PRODUCT: MATLAB;Robotics System Toolbox;Simulink;Simulink Documentation;Stateflow
PRODUCT_BASECODE: SL
ANNOTATION:
Specify Hierarchical Actor Poses Copyright 2023-2024 The MathWorks, Inc. Manipulator Motion  qe  dqe  Velocity Product Torque + Gravity Torque  MassMatrix(ddqd - Kd*dqe - Kp*qe) Compute Robot Configuration from Target Pose Specify Hierarchical Actor Poses Copyright 2023-2024 The MathWorks, Inc. Manipulator Motion  qe  dqe  Velocity Product Torque + Gravity Torque  MassMatrix(ddqd - Kd*dqe - Kp*qe) Compute Robot Configuration from Target Pose System Control Logic Simulink 3D Actor Visualization Scene Creation & Configuration Copyright 2023-2024 The MathWorks, Inc.

BLOCK:
 Demux ; Ground ; SFunction ; Terminator ;Action Port;Add;Angles;Applied Joint Torques;Applied Torque;Attach Ball;Attach Cup;Ball Instance;Chart;Clock;Constant;Coordinate Transformation Conversion;Demux;Desired Configuration;Desired Joint Acceleration;Desired Joint Velocity;Detach Ball ;Detach Cup ;Discrete-Time Integrator;Display;Find Ball;Find Cup;Gain;Get Transform;Gravity Torque;Home Configuration;ID;If;In;Interpreted MATLAB Function;Inverse Kinematics;Joint Space Mass Matrix;Kd;Kp;L;MATLAB Function;Manipulator Dynamics;Manipulator Forward Dynamics;Matrix Concatenate;Measured Acceleration;Measured Configuration;Measured Velocities;Measured Velocity;Memory;Mux;Out;Prepare World;Product;R;Reference;Reshape;Robot;Robot1 Dynamics & Control;Robot1 Motion Control;Robot1 Reference Waypoints;Robot2 Dynamics & Control;Robot2 Motion Control;Robot2 Reference Waypoints;Saturation;Shuttle;Shuttles;Simulation 3D Actor;Simulation 3D Scene Configuration;SubSystem;Subsystem;Switch;Task Scheduling;Task Scheduling & Waypoint Generation;Terminator;Torque Controller;Trajectory Generation;Trapezoidal Velocity Profile Trajectory;Trigger;Unit Delay;Velocity Product Torque;XY-rotation;Z-location;Zero;atBall;atCup;atShuttle;ballIn;ballInst;ballLoc;clock;cupLoc;destroyCupPhys;f;findBall;r1Go;r1Pos;r1Sh;r1State;r2Go;r2Pos;r2Sh;r2State;r2state;state;t;time;waypoint;waypoints;wptsRef

BLOCKTYPE:
ActionPort;Clock;Concatenate;Constant;Demux;DiscreteIntegrator;Display;Forward Dynamics;Gain;Get Transform;Gravity Torque;Ground;If;Inport;Inverse Kinematics;Joint Space Mass Matrix;MATLABFcn;Memory;Mux;Outport;Product;Reshape;S-Function;Saturate;Simulation 3D Actor;Simulation 3D Scene Configuration;Sum;Switch;Terminator;TriggerPort;UnitDelay;Velocity Product Torque;robotics.slcore.internal.block.CoordinateTransformationConversion;robotics.slcore.internal.block.TrapVelTrajSys


MODELNAME: slexMaskCallbackFileExample
PATH: examples/simulink_masking/main/slexMaskCallbackFileExample.slx
DESCRIPTION: Mask Callbacks This example shows the sequence of various Mask Callbacks.
BLOCK: Bias;Constant;Display;Gain;Masked Block Using a Mask Callback File;SubSystem;Subsystem;u;y
BLOCKTYPE: Bias;Constant;Display;Gain;Gain with optional offset;Inport;Outport
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1;1
CHECKSUM: F8133BC1099C4A78F138ED5D075E43C2
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2012 The MathWorks, Inc.  This example shows the usage of a MATLAB callback file to author mask callbacks (mask initialization, parameter callbacks and dialog control callbacks).  Mask Callback File Copyright 2022-2023 The MathWorks, Inc.


MODELNAME: slexMaskCallbacksExample
PATH: examples/simulink_masking/main/slexMaskCallbacksExample.slx
DESCRIPTION: Mask Callbacks This example shows the sequence of various Mask Callbacks.
BLOCKTYPE: Callback execution in a mask without icon;Gain;Inport;Outport
BLOCKTYPE_FREQUENCY: 1;3;9;9
CHECKSUM: 5052BA5A3F15671DD42C8F1199FF304E
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. In this example, the Allow library block to modify its content option is enabled. Case D: Subsystem containing masked library block Observe the MATLAB command window to view the output when a callback is executed. Case C: Subsystem containing mask with icon Case B: Mask with icon Open the Mask Parameter dialog to execute parameter dialog callbacks. The checkbox in the Mask Parameter dialog triggers the checkbox dialog callback. Click Apply in the Mask Parameter dialog to executes initialization callback. During simulation, if the subsystem has never been opened, the callbacks are executed twice. This double execution maintains consistency, in case the library block modifies itself. Open this example to execute mask initialization commands. These commands are executed because icon drawing commands may be using mask parameters to generate the icon. Case A: Mask without icon This example shows the conditions that trigger the execution of various mask callbacks. Display statements have been added to the mask callbacks in this example. Mask Callbacks Open the subsystem to execute mask initialization commands. These commands are executed because icon drawing commands may be using mask parameters to generate the icon. Copyright 2012-2020 The MathWorks, Inc.

BLOCK:
Case A;Case B;Case C;Case D;Gain;In;Out;Reference;SubSystem;Subsystem;Subsystem Containing Case C;Subsystem Containing Case D;u;y


MODELNAME: slexMaskConstraints
PATH: examples/simulink_masking/main/slexMaskConstraints.slx
BLOCKTYPE: Inport;Outport
BLOCKTYPE_FREQUENCY: 12;12
CHECKSUM: 921E91E4245D946F45F2DDFC33807F04
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 Cross parameter constraint  Create shared constraints to reuse constraints across blocks or models. Use the Constraint manager to create and save the constraints to a mat file present in the MATLAB path. You can browse the mat file and load the constraint using the Constraint attribute in the Property Editor pane of the Mask Editor. In this example, realScalarPositiveConstraint is present in the mat file sharedConstraint.mat.This constraint is associated with RealScalarPositiveParam1 of SharedConstraintBlock1 and RealScalarPositiveParam2 of SharedConstraintBlock2.   Custom Constraint  Shared constraint  Define and associate constraint to mask edit parameter  Single constaint to edit and combobox parameters  You can associate a single constraint with edit and combo box parameters. For combo box parameter, the attribute Evaluate must be set before associating a constraint. In this example, numericConstraint is associated to numericParam1 and numericParam2; int8Constraint is associated to int8Param1 and int8Param2. If the validation involves multiple mask parameters, create cross parameter constraint.In this example, GreaterThanConstraint validates that value of Parameter1 must begreater than Parameter2.  Create a custom constraint in the Constraint Manager if the attributes provided does not suite your needs. Create the constraint by providing a MATLAB expression and Error Message(optional) in the Custom Constraint section and associate it with the mask parameter. If the custom constraint needs to be associated with multiple parameters, you can provide an argument named “value” as a place holder in the MATLAB expression. During constraint validation, this argument is replaced with evaluated value of the parameter. Error Message accepts these values - No value is provided- default error message is shown. - Valid message catalog id- the corresponding message from message catalog is shown. - String- the same is shown. In this example, evenNumberConstraint is associated to evenNoParam1 and evenNoParam2.  Create constraints using the Constraint Manager dialog box in the Mask Editor. Use the Constraint attribute in the Property editor pane of the Mask Editor to associate a constraint to a parameter. In this example, the mask parameter RealScalarPositiveParam is associated with the constraint realScalarPositiveConstraint. This constraint has attributes real, scalar, and positive. Error is thrown if the parameter value violates any of these attributes. 

BLOCK:
ConstraintToEditAndComboBoxBlock;CrossParameterConstraintBlock;CustomConstraintBlock;In;Out;RealScalarPositiveParamBlock;SharedConstraintBlock;SubSystem;Subsystem


MODELNAME: slexMaskCrossPortConstraints
PATH: examples/simulink_masking/main/slexMaskCrossPortConstraints.slx
BLOCK: Display;Input_;Mask_CrossPortConstraints;Multiply;Product;SubSystem;a
BLOCKTYPE: Constant;Display;Inport;Outport;Product
BLOCKTYPE_FREQUENCY: 2;1;2;1;1
CHECKSUM: 407AABEC0F0075ACE7C468506BC7F115
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 The mask block expects Input_1 &amp; Input_2 to have same dimension and Input_1, Input_2 and Product to have same datatype. Copyright MathWorks 2022


MODELNAME: slexMaskDDGExample
PATH: examples/simulink_masking/main/slexMaskDDGExample.slx
DESCRIPTION: Dynamic Mask Dialog This example shows the creation of Dynamic Mask Dialogs.
BLOCKTYPE: Bias;Constant;Display;Gain;Gain with optional offset;Inport;Outport
BLOCKTYPE_FREQUENCY: 2;2;2;2;2;2;2
CHECKSUM: ED43667E7A8CE54D479B09E1F043C8CA
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. This example shows how to change the visibility of one mask parameter based on the value of another mask parameter. The checkbox Enable Bias is used to change the visibility of the Bias Value parameter. Examine the code in the Enable Bias dialog callback and in the Initialization pane. Dynamic Mask Dialog This example shows how to disable a mask parameter based on the value of another mask parameter. The checkbox Enable Bias is used to disable the Bias Value parameter, which is grayed out. Examine the code in the Enable Bias dialog callback and in the Initialization pane. Copyright 2012 The MathWorks, Inc.

BLOCK:
Bias;Constant;Disabling a Parameter;Display;Gain;Making a Parameter Invisible;SubSystem;Subsystem;u;y


MODELNAME: slexMaskDialogControlExamples
PATH: examples/simulink_masking/main/slexMaskDialogControlExamples.slx
BLOCK: SubSystem;Subsystem;TreeControl
CHECKSUM: 8536AFD5B606C7361E2E39092799A170
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 Example showcasing Tree Dialog Control in masking to display a hierarchical list.  Tree Dialog Control Copyright 2019-2021 The MathWorks, Inc.


MODELNAME: slexMaskDisplayAndInitializationExample
PATH: examples/simulink_masking/main/slexMaskDisplayAndInitializationExample.slx
BLOCKTYPE: Constant;Display;Example Masked Subsystem;Gain;Inport;Outport
BLOCKTYPE_FREQUENCY: 4;4;1;1;4;4
CHECKSUM: 4E4A19198D28DD61E49EE63876F3D4D3
PRODUCT: MATLAB;Simulink;Simulink Test Documentation
PRODUCT_BASECODE: SL
DESCRIPTION:
Mask Display and Mask Initialization This example shows the use of Mask Display and Mask Initialization sections in various scenarios.

ANNOTATION:
Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Icon dependent on mask parameters The icon display code used in these examples is placed in the Icon Drawing commands pane of the Mask Editor. Image as icon In the Initialization pane of the Mask Editor, a mask parameter is used to compute a derived parameter (multiplied by 4). This derived parameter is used in the icon drawing commands. In this example, a parameter of type popup is used to determine the shape of the patch and a parameter of type edit is used to determine the intensity of the patch. Static icon Mask Display and Mask Initialization Copyright 2012 The MathWorks, Inc. Icon dependent on mask workspace variables

BLOCK:
Constant;Display;Gain;Icon Dependent on Mask Workspace;Icon Dependent on Parameters;Image as Icon;In;Independent Static Icon;Out;SubSystem;Subsystem


MODELNAME: slexMaskDrawingExamples
PATH: examples/simulink_masking/main/slexMaskDrawingExamples.slx
DESCRIPTION: slexMaskDrawingExamples This example highlights various features of mask icon.
BLOCKTYPE: Assertion;Constant;Display;Gain;Inport;Outport
BLOCKTYPE_FREQUENCY: 1;4;3;1;5;4
CHECKSUM: BBB377813FE0AD780293E8B151F95BBA
PRODUCT: MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc.  Specify the value of Run Initialization as Off if the mask icon drawing commands do not have dependency on the mask workspace. Run Initialization  If you select the Icon transparency as Opaque with ports for a subsystem block, the port labels are visible. Opaque mask with visible port lables Copyright 2016-2020 The MathWorks, Inc.  Specify the value of Run Initialization as On if the mask icon drawing commands have dependency on the mask workspace.  The mask of the subsystem block uses the block_icon drawing command to promote the icon of underneath Assertion block. Promoting child blocks icon on Subsystem  This block illustrates how to use multiple images on a masked block. For illustration, the image on the bottom left corner indicates block capabilities like whether the block can generate the code. The image on right can be the company logo or product logo.  Multiple image commands 

BLOCK:
Assertion;Constant;Display;Gain;In;Opaque with ports;Out;RunInitOff;RunInitOn;SubSystem;Subsystem;masked_block_with_multiple_images


MODELNAME: slexMaskLayoutOptionsExample
PATH: examples/simulink_masking/main/slexMaskLayoutOptionsExample.slx
DESCRIPTION: Tabbed Parameters This example shows how to associate Mask Paramters to a tab in the Mask Dialog
BLOCKTYPE: Constant;Display;Gain;Inport;Outport
BLOCKTYPE_FREQUENCY: 5;5;9;5;5
CHECKSUM: 530999912C728DD3E4680B1033CD81A6
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. If your mask contains multiple parameters, you can group them into multiple tabs. Tabbed Parameters Horizontal Stretch Property  If the Horizontal stretch property is On, the controls on the mask dialog box stretch horizontally when you resize the mask dialog box. This example shows few combinations that impact the horizontal stretch property. Consider these scenarios: Group 1: Button 1: Horizontal Stretch is Off. Button 2: Horizontal Stretch is On. Result: Button 1 does not stretch horizontally whereas, Button 2 stretches. Group 2: Button 3 and Button 6: Horizontal Stretch is Off. Button 4 and Button 5: Horizontal Stretch is On. Result: The value selected in the last row propagates to the controls of the corresponding column. Hence, Button 3 and Button 4 inherit the horizontal stretch value from Button 5 and button 6 respectively. Group 3: Button 7 and Button 8: Horizontal Stretch is On. Button 9 and Button 10: Horizontal Stretch is Off. Result: All the four buttons stretch horizontally when you resize the mask dialog box.  You can use MATLAB code to configure the Popup parameter to dynamically control values of a dependent parameter. This example shows the use of Popup parameter to control the components of child box based on the selections made in the parent box.  Dynamic Popup Parameter Copyright 2012-2015 The MathWorks, Inc.  This example shows the use of Collapsible Panel containers for designing the mask dialog box layout. Collapsible Panels allow you with the flexibility of having expanded or collapsed sections in the mask dialog box.   Collapsible Panel You can use the Table container to group the Edit, Check box, and the Popup parameter types. A Table container helps you organize your mask dialog box when you have large number of parameters. You can use the search option to find an item in the table.   Table Parameter

BLOCK:
CollapsiblePanel;Constant;Display;Gain;Gain A;Gain B;Gain C;Horizontal Stretch Property;Popup Parameter;SubSystem;Subsystem;Tabbed Parameters;Table;u;y


MODELNAME: slexMaskLookupTableControlExample
PATH: examples/simulink_masking/main/slexMaskLookupTableControlExample.slx
BLOCKTYPE: Constant;Display;Inport;Lookup_n-D;Outport;S-Function
BLOCKTYPE_FREQUENCY: 15;8;14;7;7;1
CHECKSUM: DC2DEC19DAB92E5B6D55A3EABA814BCF
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example shows how to add LookupTable control with parameters for table lookup s-function mask. Lookup Table Control Examples LookupTable Control Referencing Simulink.LookupTable object Data Specification Mode Multi-dimensional Lookup Tables  This example shows how to add LookupTable control for table and breakpoint data parameters and show the data units.  This example shows how to add LookupTable control for parameter referencing a Simulink.LookupTable object in model or base workspace.  This example shows how to setup a LookupTable control with Data specification parameter and allow user to switch from Explicit data mode and Referencing mode.  This example shows how the LookupTable control appears with slice selector for multi-dimensional lookup table control.  This example shows LookupTable control setup for explicit breakpoint data sharing between lookup tables. Sharing explicit breakpoint data  This example shows how the LookupTable Control can be added for built-in lookup table block parameters promoted to mask. LookupTable Control for promoted parameters LookupTable Control for table lookup s-function parameters Copyright 2021 The MathWorks, Inc.

BLOCK:
2-D Lookup Table;2-D Table Lookup S-Function;3-D Lookup Table;4-d LUT Control;Constant;Display;Fuel flow (kg/s);Inport;LUT Control with Data Specification Mode;LUT Control with Explicit Data;Lookup Table Control For Promoted Parameters;Outport;Referencing Simulink.LookupTable;Sharing Breakpoints;SubSystem;Subsystem;Torque(Nm), Speed(rpm)


MODELNAME: slexMaskParameterOptionsExample
PATH: examples/simulink_masking/main/slexMaskParameterOptionsExample.slx
DESCRIPTION: Mask Parameters This example shows the use of various kinds of Mask Parameters and their options.
BLOCKTYPE: Constant;Display;Gain;Inport;Outport;UnitConversion
BLOCKTYPE_FREQUENCY: 14;14;8;15;17;2
CHECKSUM: C4DF7D4006ED0912A3463343BC61E800
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. This block has a popup with 5 options Copyright 2012 The MathWorks, Inc. Copyright 2012 - 2015 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. This example shows the effect of the Tunable option for mask parameters. Simulate this model with a stop time of inf. Open the Mask Parameter dialogs of both blocks. Notice that the non-tunable block is grayed out while the model is running When a parameter is not evaluated, the mask sees it directly as a string. Mask with an edit and evaluated parameter. This type of parameter is evaluated in MATLAB and, therefore, must be a valid MATLAB expression. In this example, a string (between single quotes) is passed to the mask. During simulation, the display block shows the evaluated value. Mask Parameters Evaluate Option Tunable Option Here, a parameter of type popup is used to set the numeric value of a block parameter. Popup Parameters Here, a parameter of type popup is used to set another parameter of type popup. The top mask limits the number of choices of the original popup parameter between 5 and 3. Slider and Dial Parameters  Slider and Dial can be used to display the value range for a giving parameter. This example shows the use of Slider and Dial parameters to display few parameters of a Boiler dashboard.   This example shows how to add an image on the button controls. Add Image on Button Copyright 2012 - 2020 The MathWorks, Inc. Here, the Combo box parameter is used to set the units for a value. You can either select from the list of available options or type a value of your choice. The Combo box parameter value is not evaluated. Combo box Parameter  This examples shows dynamic control of the slider range parameter from the linked block without having to edit the underneath library block. You can provide minimum and maximum values on the linked block dialog box to change the slider range. Change Slider Range Dynamically In this example, the Combo box parameter references a block parameter underneath the mask.  This example shows how to associate the Edit, Min, and Max parameters with the DataTypeStr parameter. The DataTypeStr parameter allows you to specify the acceptable data types while the Min and Max parameters specify the range for the Edit mask parameter. DataTypeStr Parameter CustomTable Parameter  This example shows how to create a CustomTable parameter. The parameter values for CustomTable parameter is a string in the cell array format. Unit Parameter  This example shows how to create a Unit parameter on a masked subsystem and passing its value to an inport/outport block inside the subsystem. 

BLOCK:
Angular Velocity;ComboBox;ComboBoxWithEvaluate;Constant;Custom Table;DataTypeStr;Decimal Output;Decimal Output.;Display;Dynamic Slider Range;Evaluated Parameter;Gain;Gain Controlled from Popup;Gain Controlled from popup;Image on Button;In;Non-Evaluated Parameter;Non-Tunable Parameter;Out;Popup Controlled from Popup;Promoted Unit Parameter;Reference;Slider and Dial;Slider_Dial_Example;SubSystem;Subsystem;Tunable Parameter;Unit Conversion;Unit Parameter;u;y


MODELNAME: slexMaskParameterPromotionExample
PATH: examples/simulink_masking/main/slexMaskParameterPromotionExample.slx
BLOCK: Gain;In;Out;Promote Many to One;Selective Promotion of Parameters;SubSystem;Subsystem
BLOCKTYPE: Gain;Inport;Outport
BLOCKTYPE_FREQUENCY: 6;4;4
CHECKSUM: C57E173D13C08170DF1CAF623084EDD5
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Parameter Promotion This example shows few scenarios where Mask Parameter Promotion is useful and the explains the procedure to promote the parameters

ANNOTATION:
Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Parameter Promotion This subsystem comprises 3 gain blocks sharing a common gain value. For this, 3 gain parameters of the underlying gain blocks are promoted as a single parameter on the subsystem mask. This subsystem comprises 3 gain blocks. However, the value of one of the gain blocks is fixed for all possible configurations. To simplify the user interface, the parameters of the variable gain blocks are promoted to the mask and the parameter of the static gain block is set in the mask initialization. Copyright 2012 The MathWorks, Inc.


MODELNAME: slexMaskPreserveTunabilityOfMaskInitVariable
PATH: examples/simulink_masking/main/slexMaskPreserveTunabilityOfMaskInitVariable.slx
BLOCK: CalculateForce;Constant;DataRounding;Display;Out;SubSystem
BLOCKTYPE: Constant;Display;Outport
BLOCKTYPE_FREQUENCY: 2;2;4
CHECKSUM: C8DA0341C6B4B2320DF9A51B9FA541CC
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example shows how tunability is preserved in the generated code for parameters that are modified or updated in the mask iniialization code. In the mask initialization code, the data is rounded to the preferred rounding method.  Preserve tunability for variables created in Mask init code  Preserve tunability for variables modified in Mask init code  This example shows how tunability is preserved in the generated code for parameters that are created in the mask iniialization code. In the mask initialization code, the force is calculated as the product of mass and acceleration. This expression is emitted in the generated code. Copyright 2022-2023 The MathWorks, Inc.


MODELNAME: slexMaskSelfModifiableExample
PATH: examples/simulink_masking/main/slexMaskSelfModifiableExample.slx
BLOCK: Constant;Display;Reference;Self-Modifying block;SubSystem;Subsystem;Variants blocks
BLOCKTYPE: Constant;Display
BLOCKTYPE_FREQUENCY: 2;2
CHECKSUM: 050F28854CA726AB42416B8097DB7453
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Self Modifying Library Block This example shows the need of self modifying library blocks and the steps to create them.

ANNOTATION:
 This example shows the use a linked Subsystem containing a Variants Sink and Variants Source blocks. This allows you to have multiple implementations of a model in a single, unified block diagram. These implementations can be controlled using different Variant Choices. Depending on the Time domain choice, the blocks associated with that choice are activated.   A self-modifiable linked block is created when you add a self-modifiable masked subsystem block from the library to your model. Such linked blocks allow structural changes within the subsystem block. Observe that in this example if you change the Time domain on the mask dialog box, the block within the Subsystem is replaced accordingly. For example, if you select the Time domain as Discrete, the continuous integrator block is replaced with a discrete integrator block and vise-versa. This dynamic change in the structure of the self-modifiable linked block is controlled using the MATLAB code that is added in the Initialization pane of the Mask Editor. The structural changes take place only if the option Allow library block to modify its contents available on the Initialization pane is selected. It is recommended that you use Variants to achieve a similar dynamic behavior. The next example demonstrates this behavior using Variants.  Self Modifiable Library Block Copyright 2012-2016 The MathWorks, Inc. Variants Instead of Self-Modifiable Library Block


MODELNAME: slexMaskSelfModifiableInterfaceBlocks
PATH: examples/simulink_masking/main/slexMaskSelfModifiableInterfaceBlocks.slx
BLOCKTYPE_FREQUENCY: 2;1;12;1;4;4;6;2;2;3
CHECKSUM: FD615D79A4C5D5F699FB5C1402D265A3
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This is a fairly complex example of mask initialization and block callbacks to manage the concept of an Interface Connector. This illustrates - how to do edit time operations outside of the masked subsystem using mask initialization - how to check for structural errors at update diagram time using mask initialization code - how to invoke the mask initialization code of another block from a callback This example consists of the following blocks Interface In - accepts a signal name identifying the name of a root Inport, which the Interface In reads. Interface Out - accepts a signal name identifying the name of root Outport block to write to, multiple Interface Out blocks can write to the same root Outport and will be automatically merged. Interface Connector - manages the connections from the Interface In and Interface Out blocks to the root Inports. Interface In blocks can be placed within virtual subsystems in your model and the signal name specified within the Interface In block will come from a root Inport block with the same name. Similarly, Interface Out blocks can be placed within virtual subsystems in your model and the signal name specified within the Interface Out block will write to a root Outport block with the same name. Multiple Interface Out blocks with the same signal name will write to the same root Outport via a Merge block. The Interface Connector block which must reside in the root window of your block diagram. The Interface Connector dynamically manages connections for the Interface In and Interface Out blocks. As the Interface In and Interface Out blocks are edited, the Interface Connector automatically updates. Some key points As a general rule, mask blocks which have &quot;[x] Allow library block to modify its contents&quot; selected (mask self-modifiable blocks) are allowed to edit their contents via the mask initialization action. When they modify the contents, the interface of the masked block should not change during update diagram. Furthermore, the mask initialization code must not modify structure outside of the mask block. The mask initialization action is always invoked during update diagram. Mask initialization action of mask self-modifiable can change the masked block interface or make modifications outside of the contents of the masked block during edit only. This example illustrates this. This model contains Variant blocks. During model compile the variant conditions are analyzed before Simulink runs the mask initialization action code, thus the structure of the model cannot change when the mask initialization action is run by model compile. This example illustrates how to do all mask initialization actions at edit time. During compile the mask initialization code of the Interface Connector validates that the connections are valid and if not, an error is produced aborting the model compile. Copyright 2016-2021 The MathWorks, Inc.

BLOCK:
Add;Component;Constant;Gain;In;Init;InitFCSS;Interface Connector;Interface In;Interface Out;Out;Reference;Run;RunFCSS;SubSystem;Variant Source;init;run

BLOCKTYPE:
Constant;Gain;Inport;InterfaceConnector;InterfaceIn;InterfaceOut;Outport;Sum;TriggerPort;VariantSource


MODELNAME: slexMaskSharedPortConstraint
PATH: examples/simulink_masking/main/slexMaskSharedPortConstraint.slx
BLOCK: Engine_;In;Out;SubSystem
BLOCKTYPE: Inport;Outport
BLOCKTYPE_FREQUENCY: 4;4
CHECKSUM: B81C3D5917D45100742EB9BCBF8E33FB
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 Blocks Engine_1 and Engine_2 share same port constraint ScalarInt8SharedConstraint inside the shared constraint file sharedPortChecks.xml. This constraint is associated with Input port 1 for both the blocks. Open the shared port constraint XML file in the Mask Editor. Modify the input signal types (Datatype/complexity/dimension) of the blocks to see port contraint validation results. The parameter condition specified for ScalarInt8SharedConstraint port constraint is valid for both the blocks sharing this constraint. Copyright 2012-2023 The MathWorks, Inc.


MODELNAME: slexMaskTunablePopupExample
PATH: examples/simulink_masking/main/slexMaskTunablePopupExample.slx
BLOCK: Associate Variable;Constant;Display;EnumClass;ExternalEnum;ListofOptions;Out;SubSystem;Subsystem
BLOCKTYPE: Constant;Display;Outport
BLOCKTYPE_FREQUENCY: 4;4;8
CHECKSUM: 0D1CF16963CA9E59D0FB789981F3C59B
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example shows how to create a tunable popup parameter with associated variable. The parameter values and display strings are populated from external enumeration file XFactor. Tunable popup parameter is associated with model workspace variable workspaceVar  Tunable popup parameter with associated variable  Tunable popup parameter with list of options  This example shows how to create a tunable popup parameter with list of options.  Tunable popup parameter referencing an enumeration file  This example shows how to create a tunable popup parameter .The parameter values and display strings are populated from the external enumeration file XFactor.  This example shows how to create a tunable popup parameter with enumeration class created from user provided data.  Tunable popup parameter referencing enumeration class created from user provided data 


MODELNAME: slexMaskUnsafeCallbacksErrorExample
PATH: examples/simulink_masking/main/slexMaskUnsafeCallbacksErrorExample.slx
DESCRIPTION: Unsafe Mask Callbacks This example shows few bad practices in using Mask Callbacks.
BLOCK: Complex Configurable Gain block;Gain;In;Out;SubSystem;Subsystem;System Configurator
BLOCKTYPE: Gain;Inport;Outport
BLOCKTYPE_FREQUENCY: 3;3;3
CHECKSUM: BD80B18C7DDA922898DE0E2B8E31BC3D
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2012 The MathWorks, Inc. In this example, the mask initialization code calls MATLAB function slexCalculateComplexGainExample This function calls assignin for variable complexGainVal in the caller workspace. The variable, instead of being assigned to the mask workspace, is assigned to the base workspace. To visualize this behavior, click the block, change the parameter value, and click OK. The mask initialization code executes a whos command, but variable complexGainVal is not visible in the mask workspace. If you execute the whos command in the MATLAB command window, you will see the variable complexGainVal.  Use of assignin in Callback System Configurator block configuring the Gain block In this example, the System Configurator is a masked subsystem that is used to configure the Gain block. Such use of Mask callbacks, where the callback modifies entities outside of its scope may result in unexpected behavior. Unsafe Mask Callbacks Copyright 2012 The MathWorks, Inc.


MODELNAME: slexMaskUnsafeNestedUsageErrorExample
PATH: examples/simulink_masking/main/slexMaskUnsafeNestedUsageErrorExample.slx
DESCRIPTION: Unsafe Nested Mask Usage This example shows few bad practices of using Nested Masks.
BLOCKTYPE: Gain;Inport;Outport
BLOCKTYPE_FREQUENCY: 6;6;6
CHECKSUM: 746DD68D35941191C4807AFAA37315FB
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Copyright 2012 The MathWorks, Inc. Unsafe Nested Mask Usage Unsafe Usage Suggested Usage This example shows a subsystem Simplified Multi Gain System containing another subsystem Multi Gain System. The objective is to tweak the parameter of the gain block in Multi Gain System through the mask parameters of Simplified Multi Gain System.  Setting the parameter of the gain block directly through the mask initialization code of Simplified Multi Gain System might lead to unexpected behaviour, because the mask on Multi Gain System might also set the same parameter of the gain block. The mask on Simplified_Multi_Gain_System can set a parameter on the mask of Multi_Gain_System, which in turn can set the parameter of the contained gain block. It is safer to set the parameters within the hierarchical boundary. Copyright 2012 The MathWorks, Inc.

BLOCK:
In;Multi Gain System;Multi_Gain_System;Out;Primary_Gain;Secondary_Gain;Simplified Multi Gain System;Simplified_Multi_Gain_System;SubSystem;Subsystem;Tertiary_Gain


MODELNAME: slexMaskingExamples
PATH: examples/simulink_masking/main/slexMaskingExamples.slx
ANNOTATION: Simulink Masking Examples Copyright 2012-2023 The MathWorks, Inc. Bad Practices
CHECKSUM: 1F4EBECB490837411047DDABBF9189CB
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Simulink Masking This example shows the correct usage of various masking features and also points out few commonly known bad practices.

BLOCK:
 Nested mask error; Unsafe mask callbacks error;Create Simple Mask;Design a mask dialog box;Dialog Layout Options;Dynamic Mask Dialog;Mask Cross Port Constraints;Mask Dialog Controls;Mask Icon Drawing Commands;Mask Icon and Initialization;Mask Lookup Table Control;Mask Parameter Constraints;Mask Parameter Promotion;Mask Parameters;Mask Port Constraints;Mask Shared Port Constraints;Mask Tunable Popup Parameter;Self Modifiable Interface Blocks;Self Modifying Library Mask;Sequencing of Mask Callbacks;SubSystem


MODELNAME: MsgEthernetMdl
PATH: examples/simulink_messages/main/MsgEthernetMdl.slx
BLOCKTYPE_FREQUENCY: 3;9;3;3;1;6;3;6;3;7;7;4;1;3;6;6;18;3;33;3;3;6;1;3;11;3;9
CHECKSUM: 653E3EAAE17B8E99A19A3FB06C1821DC
PRODUCT: MATLAB;Simulink;Stateflow;Stateflow Documentation
PRODUCT_BASECODE: SE;SL;SF
ANNOTATION:
Assemble Ethernet Frame Medium Access Control Medium Access Control Assemble Ethernet Frame Medium Access Control Assemble Ethernet Frame Computer 2 Computer 3 Computer 1 Copyright 2020 The MathWorks, Inc.

BLOCK:
 Demux ; Ethernet; SFunction ; Terminator ;Admit 1 Frame ;Admit 1 packet ;Assemble MAC Frame;Average Channel Utilization;Bus Selector;CSMA/CD;Callback Button;Combine;Constant;Copy Message;Copy Transmitted Frame;DataIn;DataOut;Digital Clock;Entity Input Switch;Ethernet Interface ;From;Goto;In;IsIdle;MATLAB Function;Merge;Merge ;Message Send;Out;Receive;Replicator;RxIn;Send to Channel;Simulink Function;Size;Software Component ;SubSystem;Terminator;To Workspace;Transmission Buffer;Transport Delay;TxIn;TxNext;TxRe;Wait for Channel;a;compUtil;d;gateControl;initPacket;isIdle;s;t;util

BLOCKTYPE:
ArgIn;ArgOut;BusSelector;Constant;CustomCallbackButton;Demux;DigitalClock;EntityGate;EntityGenerator;EntityInputSwitch;EntityReplicator;EntityServer;Ethernet Hub;Ethernet MAC Layer;From;Goto;Inport;ModelReference;Outport;Queue;Receive;S-Function;Scope;Send;Terminator;ToWorkspace;TriggerPort

EXTERNALFILE_REFERENCE:
mSoftwareComponent1___Model_Block___mSoftwareComponent2___Model_Block___mSoftwareComponent3___Model_Block___


MODELNAME: SimpleSimEventsStateflowMessagesModel
PATH: examples/simulink_messages/main/SimpleSimEventsStateflowMessagesModel.slx
ANNOTATION: Shared Channel with Delay Copyright 2020 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;2;1;4;2;3;1
CHECKSUM: B7AD9C5A8EDE2A52FDC2FBD77BF067C5
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SE;SL;SF
BLOCK:
Copy;In;Listener;Merge;Model Info;More Info;Out;Receive;Receive Buffer ;Reference;Scope (run based on message availability);Send;Send Buffer ;Sequence Viewer;Shared Channel with CommunicationDelay;Shared Channel with Delay;StateflowSend;SubSystem

BLOCKTYPE:
CMBlock;EntityInputSwitch;EntityReplicator;EntityServer;EntityTerminator;Inport;MessageViewer;ModelReference;Outport;Queue;Scope

EXTERNALFILE_REFERENCE:
ListenerComp___Model_Block___ReceiveComp___Model_Block___SendComp___Model_Block___StateflowSendComp___Model_Block___


MODELNAME: WirelessCommunicationChannelFailurePacketLossModel
PATH: examples/simulink_messages/main/WirelessCommunicationChannelFailurePacketLossModel.slx
ANNOTATION: Packet Loss Channel Failure Copyright 2020 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 1;1;2;3;1;1;2;1;4;3;3
CHECKSUM: 8FDB56799FA303B0D8D5FE55BD420038
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SE;SL;SF
BLOCK:
Control Gate;Gate;Model Info;More Info;Number of lost messages;Number of messages transmitted;Output Switch;Packet Loss;Probabilistic Packet Loss;Receive Buffer;Receive Buffer ;Reference;Scope;Send Buffer ;Sequence Viewer;Shared Channel (with Communication Delay);SubSystem;Transmisson Buffer;Wiirelessly Share Messages;Wireless Channel ;WirelessListener;WirelessReceive;WirelessSend;WirelessStateflowSend

BLOCKTYPE:
CMBlock;EntityGate;EntityGenerator;EntityMulticast;EntityOutputSwitch;EntityServer;EntityTerminator;MessageViewer;ModelReference;Queue;Scope

EXTERNALFILE_REFERENCE:
WirelessListenerComponent___Model_Block___WirelessReceiveComponent___Model_Block___WirelessSendComponent___Model_Block___WirelessStateflowSendComponent___Model_Block___


MODELNAME: mSoftwareComponent1
PATH: examples/simulink_messages/main/mSoftwareComponent1.slx
BLOCKTYPE: BusCreator;Constant;Demux;Ground;Outport;S-Function;Send;Terminator
BLOCKTYPE_FREQUENCY: 1;1;1;1;3;1;1;1
CHECKSUM: 9CD329F5AA5F9456DE61AC97CB54D79B
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SE;SL;SF
BLOCK:
 Demux ; Ground ; SFunction ; Terminator ;Bus Creator;Data;Data Destination Address;Generate Data ;Out;PayloadSize;Send;SubSystem


MODELNAME: mSoftwareComponent2
PATH: examples/simulink_messages/main/mSoftwareComponent2.slx
BLOCKTYPE: BusCreator;Constant;Demux;Ground;Outport;S-Function;Send;Terminator
BLOCKTYPE_FREQUENCY: 1;1;1;1;3;1;1;1
CHECKSUM: 97BFDCD241D35355D80C8C3C0C780451
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SE;SL;SF
BLOCK:
 Demux ; Ground ; SFunction ; Send; Terminator ;Bus Creator;Data;Data Destination Address;Generate Data ;Out;PayloadSize;SubSystem


MODELNAME: FogLightController
PATH: examples/simulink_variants/main/FogLightController.slx
ANNOTATION: Copyright 2023 The MathWorks, Inc.
BLOCKTYPE: Constant;Delay;From;Goto;Inport;Logic;Outport;RelationalOperator;Saturate;Scope;Switch
BLOCKTYPE_FREQUENCY: 2;2;1;1;7;1;10;2;1;1;1
CHECKSUM: 854FF44965BFEE41A4219595DBBA4CE2
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Variant Subsystems This model illustrates Simulink(R) variant subsystems. Variant subsystems let you provide multiple implementations to a subsystem where only one implementation is active during simulation. You can programmatically swap out the active implementation and replace it with one of the other implementations without modifying the model. 

BLOCK:
Constant;Controller;Delay;Driver Switch;DriverSwitch;From;Goto;LightCommand;Logical Operator;OverVolt;Saturation;Scope;Sensor;SensorFault;SensorOutput;Sensors Connected;SubSystem;Switch;UnderVolt;sensorVoltage


MODELNAME: ResetRefModel
PATH: examples/simulink_variants/main/ResetRefModel.slx
BLOCKTYPE: Constant;DiscreteIntegrator;EventListener;Inport;Outport;StateReader;StateWriter;Terminator
BLOCKTYPE_FREQUENCY: 2;1;3;1;1;1;2;1
CHECKSUM: AF81D53DDA9064C23CE7097F3FF5A351
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
BLOCK:
Constant;Discrete-Time Integrator;Event Listener;Initialize Function;Inport;Outport;Reset Function;State Reader;State Writer;SubSystem;Terminate Function;Terminator


MODELNAME: VMExperimental
PATH: examples/simulink_variants/main/VMExperimental.slx
ANNOTATION: Copyright 2023 The MathWorks, Inc.
BLOCK: In;Noise;Out;Reference;Scope;Sum;TF;Variant Source
BLOCKTYPE: Band-Limited White Noise.;DiscreteTransferFcn;Inport;Outport;Scope;Sum;VariantSource
BLOCKTYPE_FREQUENCY: 1;2;1;1;1;1;1
CHECKSUM: 4E898D6A8B030367EFE91B1B436F76B4
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Variant Management This model illustrates configuring variants in Simulink(R) models using variant configurations. Variant configurations can be defined and saved inside Simulink.VariantConfigurationData objects. These objects can store multiple variant configurations and the same can be used by one or many models. The variant configurations contain control variables and and submodel configurations to configure variant in a model or model hierarchy. When a model uses a variant configuration, the same is validated during model compilation. 


MODELNAME: fogLight
PATH: examples/simulink_variants/main/fogLight.slx
BLOCKTYPE_FREQUENCY: 5;4;8;4;10;2;17;4;2;4;1;2;1
CHECKSUM: D3B2C027DE8ABC75AC1689BD654E7F3C
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
DESCRIPTION:
Variant Subsystems This model illustrates Simulink(R) variant subsystems. Variant subsystems let you provide multiple implementations to a subsystem where only one implementation is active during simulation. You can programmatically swap out the active implementation and replace it with one of the other implementations without modifying the model. 

ANNOTATION:
 This example shows how to use mask paramers to control structural variations in a model. In this model we have two instances of a Variant Subsystem with a mask. The variant control variable of the Variant Subystem is defined as a mask parameter. In this example we have used the popup widget from the mask editor is used as the variant conrol parameter. The values of the popup widget are populated using the Enum InputType, which is available on path. Each instance of the Variant Subsystem can select the active choice from the popup dialog. The Variant subsystem block, Controller, contains two choices Sensors Connected and Driver Switch with conditions CTRL_MODE==InputType.Sensor and CTRL_MODE== InputType.Driver, respectively. When you choose Driver Switch as the active choice, the LightCommand output is a delayed DriverSwitch signal. This is the equivalent action of the driver manually switching on or off the fog light. When you choose Sensors Connected as the active choice, the LightCommand output is high until the SensorOutput is high, independent of the Driver Switch signal. This is equivalent to sensors overriding the manual switching based on the light available. This demo contains two instances of the fog light controller. One instance of the Fog Light Controller uses the InputType.Sensor variant and the other instance uses the InputType.Driver variant. Simulation of this fog light controller is illustrated in this example. You can set the instance parameter values of the model reference block by opening the block parameter dialog of either the Model or the Model1 blocks in this demo. In the block parameter dialog, go to the Instance parameters tab and change the value of the CTRL_MODE and simulate the model in fast restart; then generate code with Simulink Coder or Embedded Coder. The generated code will contain regular If conditions.   Mask Parameters as variant controls for Variant Subsystem with startup activation Copyright 2023 The MathWorks, Inc.

BLOCK:
Build ERT;Build GRT;Constant;Delay;Driver Switch;DriverSwitch;From;Goto;Help;LeftController;LightCommand;LightCommandInst;Logical Operator;Out;OverVolt;ReadFromHardWare;Reference;RightController;Saturation;Scope;SensorFault;SensorOutput;Sensors Connected;Signal Editor;SubSystem;Switch;UnderVolt;Variant Source;sensorVoltage

BLOCKTYPE:
Constant;Delay;From;Goto;Inport;Logic;Outport;RelationalOperator;Saturate;Scope;SignalEditor;Switch;VariantSource


MODELNAME: sldemo_variant_initFcn
PATH: examples/simulink_variants/main/sldemo_variant_initFcn.slx
CHECKSUM: F464BEE111AC5AE40FF6C948AE3C91F4
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This model contains two demos The first model shows the recommended workflow in using the model InitFcn callback and how it should be used to define variables used in the variant control expressions The second model shows a degenerate case where the variable is defined in a referenced model. Copyright 2018-2021 The MathWorks, Inc.

BLOCK:
A degenerate case where the variant control variable is defined from the model InitFcn callback in referenced model;Recommended workflow to use model InitFcn with Variants;SubSystem


MODELNAME: sldemo_variant_initFcn_conflict_withMdlRef
PATH: examples/simulink_variants/main/sldemo_variant_initFcn_conflict_withMdlRef.slx
BLOCK: Constant;Model;Out;SubSystem;Subsystem;Variant Source
BLOCKTYPE: Constant;ModelReference;Outport;VariantSource
BLOCKTYPE_FREQUENCY: 3;1;1;1
CHECKSUM: 86DE4B97AC73C7AE5BAF3CA6F68E032F
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Coder
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: sldemo_variant_initFcn_conflict_withMdlRef_sub1.slx___Model_Block___
ANNOTATION:
 In this model the Variant Source uses the Variant control variable A. This variable is defined in the model InitFcn callback of the referenced model. This is a degenerate case and the model will fail with an error in the rtwbuild process. All the variables used by a model should be defined by the callbacks of the respective model. One model should not have to depend on the variables defined by another model.  Copyright 2021 The MathWorks, Inc.


MODELNAME: sldemo_variant_initfcn_recommended_workflow
PATH: examples/simulink_variants/main/sldemo_variant_initfcn_recommended_workflow.slx
BLOCKTYPE: DiscreteTransferFcn;Display;Inport;Lookup_n-D;Outport;Sin;Sum;VariantSource
BLOCKTYPE_FREQUENCY: 1;2;9;1;4;5;2;1
CHECKSUM: B66A94EE02F440FBE21F1A66422ADCE5
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2009-2021 The MathWorks, Inc.  In this model the variant control variable used by the Variant Subsystem Controller which is W is defined in the model InitFcn callback. Similarly the variant control variable V used by the Variant Source is also defined in the model InitFcn callback.  Variants with Model InitFcn Copyright 2019-2021 The MathWorks, Inc.

BLOCK:
1-D Lookup Table;Add;Controller;Discrete Transfer Fcn;Display;Linear Controller;Nonlinear Controller;Out;SubSystem;Variant Source;sensor;sine


MODELNAME: sldemo_variant_subsystems
PATH: examples/simulink_variants/main/sldemo_variant_subsystems.slx
BLOCKTYPE: DiscreteTransferFcn;Inport;Lookup_n-D;Outport;Scope;Sin;Sum
BLOCKTYPE_FREQUENCY: 1;9;1;4;1;3;2
CHECKSUM: 30EC3F964EA1EB3186F0BDAECA518520
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2009-2022 The MathWorks, Inc. This model illustrates Simulink variant subsystems. Variant subsystems let you provide multiple implementations for a subsystem where only one implementation is active during simulation. You can programmatically swap out the active implementation and replace it with one of the other implementations without modifying the model. Variant Subsystems Copyright 2010-2022 The MathWorks, Inc. Variant Subsystems

BLOCK:
1-D Lookup Table;Add;Controller;Discrete Transfer Fcn;Linear Controller;More Info;Nonlinear Controller;Out;Scope;SubSystem;sensor;sine


MODELNAME: sldemo_variant_subsystems_enum
PATH: examples/simulink_variants/main/sldemo_variant_subsystems_enum.slx
BLOCKTYPE_FREQUENCY: 6;1;18;1;12;1;6;3;2;6
CHECKSUM: FC4929D6B38D4E49D1B1DB489EFD6451
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Variant Subsystems - Enumerations and Reuse This model illustrates Simulink(R) variant subsystems using enumerations with Simulink.VariantExpression objects. Variant subsystems let you provide multiple implementations to a subsystem where only one implementation is active during simulation. You can programmatically swap out the active implementation and replace it with one of the other implementations without modifying the model. 

ANNOTATION:
Copyright 2009-2013 The MathWorks, Inc. 1) Only subsystems can be added as variant choices at this level 2) Blocks cannot be connected at this level as connectivity is automatically determined at simulation, based on the active variant 1) Only subsystems can be added as variant choices at this level 2) Blocks cannot be connected at this level as connectivity is automatically determined at simulation, based on the active variant 1) Only subsystems can be added as variant choices at this level 2) Blocks cannot be connected at this level as connectivity is automatically determined at simulation, based on the active variant 1) Only subsystems can be added as variant choices at this level 2) Blocks cannot be connected at this level as connectivity is automatically determined at simulation, based on the active variant This model illustrates Simulink variant subsystems. Variant subsystems let you provide multiple implementations for a subsystem where only one implementation is active during simulation. You can programmatically swap out the active implementation and replace it with one of the other implementations without modifying the model. Variant Subsystems Copyright 2010-2013 The MathWorks, Inc. Variant Subsystems - Enumerations and Reuse

BLOCK:
1-D Lookup Table;Add;Controller;Discrete Filter;Discrete Transfer Fcn;Filter;In;Linear Controller;More Info;Nonlinear Controller;Out;Production;Prototype;Scope;Signal Copy (to enable Merging);SubSystem;To Workspace;sensor;sine

BLOCKTYPE:
DiscreteFilter;DiscreteTransferFcn;Inport;Lookup_n-D;Outport;Scope;SignalConversion;Sin;Sum;ToWorkspace


MODELNAME: slexASARPostBuildVariant
PATH: examples/simulink_variants/main/slexASARPostBuildVariant.slx
BLOCKTYPE: Ground;Inport;Outport;Sum;Terminator;TriggerPort;UnitDelay;VariantSink;VariantSource
BLOCKTYPE_FREQUENCY: 3;12;8;2;2;2;2;2;3
CHECKSUM: A7A55960AF87D6610F46924B7D3FCC32
PRODUCT: AUTOSAR Blockset;Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example shows how to use Variant Source and Variant Sink to design AUTOSAR software components containing post-build variation points. In order to model postbuild variation points, we do the following : i) Setup the model for AUTOSAR Code Generation. ii) Setup a variant block, such as a Variant Source/Variant Sink/Variant Subsystem in startup activation time. You can do this by opening the variant block dialog and setting the Variant activation time to startup. iii) Define post-build variant criterions in the global workspace. You can do this by creating Normal MATLAB Variables in the global workspace. In this example, we define PBCritA and PBCritB in the global workspace. iv) Define post-build variant conditions, on the variant blocks, referencing one or more criterion objects. In this example, this variant sink uses PbCritA == 1 as a post-build variant condition. More information on configuring AUTOSAR software components for post-build variation is available here.   PostBuild Activation with Variant Blocks  help

BLOCK:
Ground;In Bus Element;Out Bus Element;Run;Runnable;SignalIn;SignalOut;SignlOut;SubSystem;Sum;Terminator;Trigger;Unit Delay;Variant Sink;Variant Source;help


MODELNAME: slexASARPostBuildVariantParameter
PATH: examples/simulink_variants/main/slexASARPostBuildVariantParameter.slx
DESCRIPTION: Code Variants Using Subsystems
BLOCK: Add;Gain;In;Out;Sine Wave;SubSystem;help
BLOCKTYPE: Gain;Inport;Outport;Sin;Sum
BLOCKTYPE_FREQUENCY: 1;1;1;1;1
CHECKSUM: 3796ED3DC4760E71087653C1391C6D4F
PRODUCT: AUTOSAR Blockset;Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example shows how to setup a Simulink.VariantVariable with AUTOSAR PostBuild Criterions to generation post build variation points. In order to model postbuild variation points on Simulink.VariantVariables, we do the following : i) Setup the model for AUTOSAR Code Generation. ii) Create a Simulink.VariantControl(MyPBCrit), that is used as a PostBuild Criterion, with the ValueType set to a Numeric and Value to a integer, and ActivationTime set to startup. iii) Create a Simulink.VariantVariable(k) with one or more choices. In this example, we create a Simulink.VariantVariable with three choices, ADAPTIVE, LINEAR and NONLINEAR. These are Simulink.VariantExpression objects with the condition formed by an expression containing the post build criterions (Simulink.VariantControl) defined above.  PostBuild(startup) Activation with Variant Parameter  help


MODELNAME: slexASARPreBuildVariantParameter
PATH: examples/simulink_variants/main/slexASARPreBuildVariantParameter.slx
DESCRIPTION: Code Variants Using Subsystems
BLOCK: Add;Gain;In;Out;Sine Wave;SubSystem;help
BLOCKTYPE: Gain;Inport;Outport;Sin;Sum
BLOCKTYPE_FREQUENCY: 1;1;1;1;1
CHECKSUM: F3300DCE5E8980D70972BEF2E023E6FD
PRODUCT: AUTOSAR Blockset;Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example shows how to setup a Simulink.VariantVariable with AUTOSAR System Constants to generation pre-build variation points. In order to model prebuild variation points on Simulink.VariantVariables, we do the following : i) Setup the model for AUTOSAR Code Generation. ii) Create a Simulink.VariantControl(MySys) with the Value set to an AUTOSAR.Parameter with SystemConstant storage class and ActivationTime set to code compile. iii) Create a Simulink.VariantVariable(k) with one or more choices. In this example, we create a Simulink.VariantVariable with three choices, ADAPTIVE, LINEAR and NONLINEAR. These are Simulink.VariantExpression objects with the condition formed by an expression containing the Simulink.VariantControl defined above.  PreBuild(code compile) Activation with Variant Parameter  help


MODELNAME: slexMaskVariantExample
PATH: examples/simulink_variants/main/slexMaskVariantExample.slx
BLOCK: Constant;Display;MaskedSubsystem;Reference;Subsystem;VariantSubsystem
BLOCKTYPE: Constant;Display
BLOCKTYPE_FREQUENCY: 4;4
CHECKSUM: 28575EB863C19290D0F51FB3D84C602E
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 Case 1:  This model contains a Subsystem block (Subsystem3) as a linked block. This block contains linked Variant Subsystem block nested within, in two levels. lvl1_1 and lvl1_2 are the variant choices of first level nested Variant Subsystem block and lvl2_1 and lvl2_2 are the variant choices of second level nested Variant Subsystem block. Popup mask parameter is used to record variant choices lvl1_1, lvl1_2, lvl2_1,and lvl2_2.  This model contains a masked Variant Subsystem (VariantSubsystem2) as a linked block. Initialization code in the mask sets the variant choice that is passed from the mask. Popup mask parameter is used to record variant choice V1 and V2. Copyright 2015 - 2022 The MathWorks, Inc. Masking a Variants Subsystem  This model contains masked Subsystem block (MaskedSubsystem) as a linked block. The masked Subsystem block contains a masked Variant Subsystem block within. Initialization code in the Variant Subsystem block mask sets the variant choice that is passed from the Subsystem block (MaskedSubsystem). Parameter promotion is used to record the variant choice (V1 &amp; V2) on the masked Subsystem block.  Case 2:  Case 3:  Case 4:  This model contains masked Subsystem block (MaskedSubsystem1) as a linked block. The masked Subsystem block contains a masked Variant Subsystem block within. Initialization code in the Variant Subsystem block mask sets the parameter value that is passed from the Subsystem block (MaskedSubsystem1). Parameter promotion is used to record the choice from the parent block on the masked Subsystem block.


MODELNAME: slexNestedVSSWithCCAndST
PATH: examples/simulink_variants/main/slexNestedVSSWithCCAndST.slx
BLOCKTYPE: DiscreteTransferFcn;Inport;Lookup_n-D;Outport;Scope;Sin;System Initialize
BLOCKTYPE_FREQUENCY: 2;7;2;8;1;1;1
CHECKSUM: 04D10DB0DD2DAD0FD377C3E648BB0974
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
 This example illustrates how code compile and startup variant activation time can be used together in two nested variant subsystems. Variant subsystem block Engine Controller has variant activation time set to code compile and has two variant subsystem choices namely, Diesel Engine and Petrol Engine controlled by the variant control expressions ENGINE_TYPE == 1 and ENGINE_TYPE == 2, respectively. One of the engine types can be selected while building the generated code. Each engine type variant subsystem has variant activation time set to startup and has two modes namely, Efficient Mode and Normal Mode. For Petrol Engine, different modes are controlled by variant control expressions PMODE == 1 and PMODE == 2, and for Diesel Engine, different modes are controlled by variant control expressions DMODE == 1 and DMODE == 2. One of the controller modes can be selected before the start of execution of the code. Click on Generate Code Using Embedded Coder to generate code with ERT target. In the generated code, it can be observed that variant conditions related to engine type appears with preprocessor if conditions like, #if ENGINE_TYPE == 1 but variant conditions related to the controller mode appears with regular if conditions like, if(PMODE == 1) { In the initialize function in the generated code, a user-defined function ChangeDieselEngineController is called to switch the diesel engine mode before the start of the execution of the step function. Note: Both the variant subsystems have Propagate conditions outside of variant subsystem and Allow zero active variant controls turned off. When these flags are turned on, this model will error out during compilation as the conditions with code compile and startup variant activation time will get mixed for the inport and outport blocks.   Nested Variant Subsystem with code compile and startup Variant activation time  help Copyright 2021 The MathWorks, Inc.

BLOCK:
1-D Lookup Table;Build ERT;Diesel Engine ;Discrete Transfer Fcn;Efficient Mode;Engine Controller;In;Normal Mode;Out;Petrol Engine ;Scope;SubSystem;System Initialize;Torque;help;sine


MODELNAME: slexStartupVariantVnVWorkflow
PATH: examples/simulink_variants/main/slexStartupVariantVnVWorkflow.slx
BLOCKTYPE_FREQUENCY: 7;3;1;27;1;24;5;2;1;7;4
CHECKSUM: 05A1C3C23BA023B272FDB3AA40DC2B3E
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Test;Stateflow
PRODUCT_BASECODE: SL
ANNOTATION:
 This model illustrates how Verification and Validation activites are done on Variant models configured for Startup time activation. Simulink Design Verifier and Simulink Test toolboxes are used to demonstrate these steps. In this example, ComputeTargetSpeed_Config1 and ComputeTargetSpeed_Config2 are two variant choices in the model. 1. Using Simulink Design Verifier to generate tests: Open Simulink Design Verifier settings and confirm that Analyze all Startup Variants option is selected under Parameters and Variants Run Test Generation analysis to generate tests covering blocks across all variant choices Highlight results on the model and verify that both variant choices are fully covered by test generation analysis 2. Using Simulink Test Manager to execute user-defined tests: Open Simulink Test Manager and Create a Test Suite and a new Baseline Test Associate the model and the Test harness: Each Parameter set aligns with a specific Variant (Startup) control value. Create Parameter Sets and add the Variant control variable The Simulink Test Manager allows iterations in the Iterations section of a test case. The Table Iterations provide a quick way to add iterations based items in your model or test case.Click on Auto-generate the Iterations, by clicking only selecting the Parameter set option When a baseline test case executes, Test Manager captures signal data from signals in the model marked for logging and compares them to the baseline data.Create a baseline test and select the option &quot;Capture Baselines for Iterations&quot; Notice that the Baseline get populated in the iterations corresponding to each parameter set. Ensure to click on &quot;Run Test Iterations in Fast Restart&quot; : Click on &quot;Run Test&quot; to run each Parameter set iteratively across the selected baseline. Access Simulink Test Workflow with Fast Restart and Startup Variants This button launches the Simulink Test Manager (STM) Window with predefined tests with Startup Variants. Please refer help for more information.  Simulink Test Workflow with Startup Variants and Fast Restart  help This button, will invoke SLDV and would generate test cases across all choices of variant subsystems present in this model in a single analysis run.  This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
 Demux ; SFunction ; Terminator ; engaged; tspeed;AccelResSw;AccelResSw ;Brake;Brake ;CoastSetSw;CoastSetSw ;ComputeTargetSpeed;ComputeTargetSpeed_Config;CruiseControl;CruiseOnOff;CruiseOnOff ;Data_Conversion_;Demux;FromWs;Harness Inputs;In_;Input Conversion Subsystem;Out_;Output Conversion Subsystem;Rate_Transition_;SigSpec_;Speed;Speed ;SubSystem;Terminator;engaged;help;slTestMgrOpen;slTestRun;sldvRun;tspeed

BLOCKTYPE:
DataTypeConversion;Demux;FromWorkspace;Inport;ModelReference;Outport;RateTransition;S-Function;Sigbuilder block;SignalSpecification;Terminator


MODELNAME: slexVariantAssemblySubsystemInExpression
PATH: examples/simulink_variants/main/slexVariantAssemblySubsystemInExpression.slx
BLOCK: Controller;Out;Scope;SubSystem;help;linearController;nonlinearController;sensor;sine;y
BLOCKTYPE: Inport;Outport;Scope;Sin
BLOCKTYPE_FREQUENCY: 3;2;1;3
CHECKSUM: 778E77911D14DE698E1920705872FB40
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: linearController___SubsystemReference_Block___nonlinearController___SubsystemReference_Block___
ANNOTATION:
 Define the interface using port blocks. Select files to define choices.  This example shows how to add or remove variant choices from a Variant Assembly Subsystem block that is in the expression mode. Maintain Variant Choices of Variant Assembly Subsystem Block in Model and Subsystem Files This model contains a Variant Assembly Subsystem block Controller. The block is in the expression mode and has two variant choices linearConroller.slx and nonlinearController.slx. The linearController and nonlinearController blocks are Subsystem Reference blocks that are saved as subsystem files in your current working folder. The linearController and nonlinearController blocks are added as choices to the Controller block using an enumeration that is created using one of these methods. Use a classdef block in a MATLAB™ file. Use the function Simulink.defineIntEnumType Use a Simulink® data dictionary to permanently store the enumeration definition. Define an Enumeration Class Using a classdef Block in a MATLAB File In this example, controllerTypesMfile.m is an integer-based enumeration class that is derived from built-in class Simulink.IntEnumType. The enumeration section specifies enumerated values linearController(0) and nonlinearController(1). To configure the Controller block, set the Variant control variable parameter to variantCtrlVar and the Variant choices enumeration parameter to controllerTypesMFile in the Block Parameters dialog box as shown below, or use set_param as shown below, set_param(vasBlkPath, VariantChoicesEnumeration, controllerTypesMfile) set_param(vasBlkPath, VariantControlVariable, variantCtrlVar) After successful validation, Simulink generates variant control expressions for the variant choices with variantCtrlVar on the left side and the enumerated names on the right side of the expression. To activate the linearController choice, set variantCtrlVar to controllerTypesMFile.linearController and then simulate the model. Similarly, to activate the nonlinearController choice, set variantCtrlVar to controllerTypesMfile.nonlinearController and simulate the model again. You can then add more variant choices to the Controller block by adding the variant choice filenames to the enumeration class. Similarly, you can remove choices from the Controller block by deleting the corresponding enumerated values from the enumeration class. Variant choices can be added or removed without modifying the model. Define a Dynamic Enumeration Class in Memory Using Simulink.defineIntEnumType Create an enumeration class controllerTypesInMem in the MATLAB workspace using Simulink.defineIntEnumType. Simulink.defineIntEnumType(controllerTypesInMem, {linearController, nonlinearController}, 0:1); To configure the Controller block, set the Variant control variable parameter to variantCtrlVar and the Variant choices enumeration parameter to controllerTypesInMem in the Block Parameters dialog box. set_param(vasBlkPath, VariantChoicesEnumeration, controllerTypesInMem) set_param(vasBlkPath, VariantControlVariable, variantCtrlVar) After successful validation, Simulink generates variant control expressions for the variant choices with variantCtrlVar on the left side and the enumerated names on the right side of the expression. To activate the linearController choice, set variantCtrlVar to controllerTypesInMem.linearController and then simulate the model. Similarly, to activate the nonlinearController choice, set variantCtrlVar to controllerTypesInMem.nonlinearController and simulate the model again. To add more variant choices to the Controller block, redefine the controllerTypesInMem class with the new variant choice filenames as enumerated values. Similarly, to remove a choice, redefine the class with the corresponding enumerated value removed. Variant choices can be added or removed without modifying the model. Permanently Store the Enumeration Definition in a Simulink Data Dictionary Create an enumeration class controllerTypesInDD and a variant control variable variantCtrlVarInDD in persistent repository data dictionary vas_controllersData.sldd as shown below. To configure the Controller block, set the Variant control variable parameter to variantCtrlVarInDD and the Variant choices enumeration parameter to controllerTypesInDD in the Block Parameters dialog box. set_param(vasBlkPath, VariantChoicesEnumeration, controllerTypesInDD) set_param(vasBlkPath, VariantControlVariable, variantCtrlVarInDD) After successful validation, Simulink generates variant control expressions for the variant choices with variantCtrlVarInDD on the left side and the enumerated names on the right side of the expression. To activate the linearController choice, set variantCtrlVarInDD to controllerTypesInDD.linearController in the data dictionary and then simulate the model. Similarly, to activate the nonlinearController choice, set variantCtrlVarInDD to controllerTypesInDD.nonlinearController and simulate the model again. vasDDObj = Simulink.data.dictionary.open(vas_controllersData.sldd); dDataSectObj = getSection(vasDDObj, Design Data); evalin(dDataSectObj, variantCtrlVarInDD.Value = controllerTypesInDD.linearController) You can then add more variant choices to the Controller block by adding the variant choice filenames to the enumeration class defined in the data dictionary. Similarly, you can remove choices from the Controller block by deleting the corresponding enumerated values from the enumeration class. Variant choices can be added or removed without modifying the model.  Variant Assembly Subsystem in Expression Mode Copyright 2023 The MathWorks, Inc.  help


MODELNAME: slexVariantAssemblySubsystemInLabel
PATH: examples/simulink_variants/main/slexVariantAssemblySubsystemInLabel.slx
BLOCK: Controller;Out;SubSystem;help;sensor;sine
BLOCKTYPE: Inport;Outport;Sin
BLOCKTYPE_FREQUENCY: 3;2;3
CHECKSUM: D37BD08B7977CD1DA431CC6CCD920B07
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example illustrates how you can configure a Variant Assembly Subsystem with a model and/or subsystem files as choices by setting Variant choices specifier in two different ways. Using a file name pattern Observe the following hierarchy of folders in the current working directory. Note: If you do not see the above folder structure, click here to generate the same in your current working folder. Add all the folders including the subfolders in MATLAB path using the following command, &gt;&gt; addpath(genpath(ControllersList)) To select all the model/subsystem files inside the folders ControllersList/linear and ControllersList/nonlinear set the value of the parameter Variant choices specifier to &quot;{ControllersList/*linear/*}&quot; in the block dialog, as shown below, To select all the files inside those folders including all the subfolders, set the value of the parameter Variant choices specifier to &quot;{ControllersList/*linear/**}&quot;. An additional model/subsystem file can be added as a choice of the Variant Assembly Subsystem block just by dropping a new file in any of those folders. This process will not modify the block or the model. Using a function Observe a MATLAB function named getMyListOfControllerChoices in the current working directory. This function returns a cell array of model names, linear_groupA_type1, linear_groupB_type2, nonlinear_generic1, controller_generic2. To determine the list of choices based on a user defined function, set the value of the parameter Variant choices specifier to the function name. For example, &quot;getMyListOfControllerChoices&quot;. An additional model/subsystem file can be added as a choice of the Variant Assembly Subsystem block just by modifying the function getListOfControllerChoices to include that new filename. This process will not modify the block or the model. After configuring the Variant Assembly Subsystem with some choices, this block can be used like a regular Variant Subsystem in label mode. Users can set the Label mode active choice from the block parameters dialog and then simulate or generate code for the model. More examples of using variant choices specifier can be found here.  Copyright 2022 The MathWorks, Inc.  Variant Assembly Subsystem in Label Mode  help


MODELNAME: slexVariantAssemblySubsystemWithMaskInExpression
PATH: examples/simulink_variants/main/slexVariantAssemblySubsystemWithMaskInExpression.slx
BLOCK: Controller;Out;Scope;SubSystem;help;linearController;nonlinearController;sensor;sine;y
BLOCKTYPE: Inport;Outport;Scope;Sin
BLOCKTYPE_FREQUENCY: 3;2;1;3
CHECKSUM: 0F234A71A2350FE81CA829480E863D4D
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: linearController___SubsystemReference_Block___nonlinearController___SubsystemReference_Block___
ANNOTATION:
 Define the interface using port blocks. Select files to define choices.  This example shows how to specify variant choices and set an active choice in a masked Variant Assembly Subsystem block in expression mode using a mask parameter object. In this example, you create one MATLAB™ class per variant choice. To activate a variant choice, you instantiate the corresponding class using a mask parameter object. You then access the class property to get the name of the variant file to be activated. Simulink® then compares the variant filename to the variant choice names by evaluating the variant control expressions and activates the variant choice for the expression that evaluates to true. Explore Model This model contains a masked VariantAssembly Subsystem block, Controller. There is only one parameter obj defined in the mask. Block parameters of the choices are extracted from obj. The Controller block has two Subsystem Reference choices, linearController and nonlinearController. The choices are added to the Controller block by setting Variant choices enumeration to slexVasExprControllerTypes enumeration class. To add more choices, add members to slexVasExprControllerTypes. The parameter Variant control variable is set to obj.variantFile. Define Classes for Variant Choices In this example, the slexVasExprControllerVariant class is a superclass that includes a property, variantFile, of enumerated type slexVasExprControllerTypes. The two classes slexVasExprLinearController and slexVasExprNonlinearController inherit from the slexVasExprControllerVariant superclass. The slexVasExprLinearController class represents the linearController variant. This class stores the name of the active choice as linearController in the inherited property variantFile. The class also stores numerator and denominator values used in the Discrete Transfer Fcn block of the linearController model. Similarly, the slexVasExprNonlinearController class represents the nonlinearController variant. It stores the name of the active choice as nonlinearController in variantFile. This class stores breakpoint and table values used in the 1-D Lookup Table of the nonLinearController model. Set Active Choice by Instantiating Classes Using Mask Parameter Object In this example, the value that you specify for ctrlObj in the mask dialog box of the Controller block is mapped to the mask parameter object obj. Using obj, you can instantiate the class slexVasExprLinearController or slexVasExprNonlinearController. You can then access its property, variantFile to get the filename of the variant choice to be activated. When you specify ctrlObj as slexVasExprLinearController, the class slexVasExprLinearController is instantiated.The class properties including variantFile are initialized. Similarly, to set nonlinearController active, set ctrlObj to slexVasExprNonlinearController.  Masked Variant Assembly Subsystem in Expression Mode  help Copyright 2023 The MathWorks, Inc.


MODELNAME: slexVariantAssemblySubsystemWithMaskInLabel
PATH: examples/simulink_variants/main/slexVariantAssemblySubsystemWithMaskInLabel.slx
BLOCK: Controller;Out;Scope;SubSystem;help;linearController;nonlinearController;sensor;sine;y
BLOCKTYPE: Inport;Outport;Scope;Sin
BLOCKTYPE_FREQUENCY: 3;2;1;3
CHECKSUM: 616C343AB586590286D1588C266FFE97
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: linearController___SubsystemReference_Block___nonlinearController___SubsystemReference_Block___
ANNOTATION:
 Define the interface using port blocks. Select files to define choices.  Masked Variant Assembly Subsystem This example illustrates how you can mask a Variant Assembly Subsystem block. In this example, the subsystem is parameterized using a MATLAB object. There are two MATLAB classes vas_linearController and vas_nonlinearController that specifies which subsystem file must be referenced, along with numerical values. classdef vas_linearController &lt; vas_controller properties numerator denominator end methods function obj = vas_linearController() obj.numerator = [1 .7]; obj.denominator = [1 .09 0.5]; obj.subsystemFile = linearController; end end end Those two classes are subclassing vas_controller that provides two methods: getVariantChoices: This function is used as variant choices specifier and returns a cell array containing the list of files that can be referenced by the subsystem setActiveVariant: This function is used in the mask initialization to specify which variant must be active. classdef (Abstract) vas_controller properties subsystemFile char end methods (Static) function list = getVariantChoices() list = {linearController,nonlinearController}; end end methods function setActiveVariant(obj,blk) set_param(blk,LabelModeActiveChoice,obj.subystemFile) end end end The block is a masked Subsystem with one parameter obj: In the Block Parameters of the block, the method getVariantChoices is specified as variant choices specifier: and the method setActiveVariant is used in the mask initialization code: In the mask dialog, a variable vssObj is specified When simulating the model, the variant will correspond to the Subsystem File specified in the object assigned to vssObj: modelName = slexVariantAssemblySubsystemWithMaskInLabel; open_system(modelName) vssObj = vas_linearController; out = sim(modelName); plot(out.tout, out.yout); xlabel(Time (seconds)) ylabel(data) vssObj = vas_nonlinearController; out = sim(modelName); plot(out.tout, out.yout); xlabel(Time (seconds)) ylabel(data)   help  Masked Variant Assembly Subsystem in Label Mode Copyright 2022 The MathWorks, Inc.


MODELNAME: slexVariantCondPropToSubsystems
PATH: examples/simulink_variants/main/slexVariantCondPropToSubsystems.slx
BLOCKTYPE_FREQUENCY: 3;3;6;9;3;12;2;14;4;4;3;1;4
CHECKSUM: FA22C26DF2EEFB3B90FE706D6499408E
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Reset Reset Reset Copyright 2016 The MathWorks, Inc.    This illustrates the behavior of forward and backward variant condition propagation onto subsystems. In the base workspace, yout can change the value of W, the variant control varianble used by the Variant Source and Variant Sink by setting W.Value = 1 % (2 or 3)  Virtual subsystems by default behave like a &quot;grouped&quot; collection of blocks where all the blocks contained inside the subsystem have the same variant condition. This is true when the TreatAsGroupedWhenPropagatingVariantConditions parameter is &quot;on&quot; (default setting). Here, the MinMax(Grouped) block gets the condition W==1 and so do all the blocks inside it. This ensures that when this is placed in a library (for reuse) it behaves as a system of equations. library blocks, they behave as entities. Virtual subsystems behave like an ungrouped collection of blocks when the TreatAsGroupedWhenPropagatingVariantConditions parameter is &quot;off&quot;. A dotted line for the MinMax(Ungrouped) block icon indicates this setting. In this example, the behavior of the MinMax(Ungrouped) may not be what one expects in that the block never becomes conditional. Similar for the Bias5(Ungrouped) block in that it does not become conditional. Nonvirtual subsystems always behave like an entity and the contents only execute when the condition assigned to the subsystem is satisfied, i.e. nonvirtual subsystems, Model blocks, and grouped virtual subsystems behave the same.  This illustrates the propagation of variant conditions to subsystems. Variant Source1 has conditions V==1 and V==2 for its input ports. GainA1 is propagated the condition V==1. Similarly, Sine2 is propagated the condition V==2. Notice that Sine1 is unconditional. This is because the To Workspace1 block is unconditional and therefore its input which is the Sine1 must be unconditional. If we were to comment-out the To Workspace1 block, then Sine1 would be propagated the condition V==1. Subsystem1 and Subsystem2 are virtual subsystems and have identical contents, a Sine Wave connected to a To Workspace and Outport blocks. Subsystem1 has its parameter &quot;Treat as grouped when propagating variant conditions&quot; selected. To access this parameter by right-clicking and selecting the Subsystem1 parameter dialog. This setting specifies that the subsystem represents a well-defined system of equations and therefore the system is propagated the condition V==1. Since Subsystem1 is a system, the condition also applies the blocks within the system. Subsystem2 has its parameter, &quot;Treat as grouped when propagating variant conditions&quot; unselected. This instructs Simulinks variant condition propagation engine to treat the contents of the subsystem as an ungrouped collection of blocks, i.e. it is not meant to represent a system of equations. There is no condition assigned to the Subsystem2 and the conditions are propagated into Subsystem2, resulting in the same conditions as if the subsystem were expanded in place. The dotted lines on the Subsystem2 icon indicate that blocks inside will have ungrouped semantics and do not behave like a system. Nonvirtual subsystems (and Model blocks) are always represent a system of equations and thus are handled as a system by variant condition propagation. For example, the conditions propagated to Subsystem1 and the Atomic Subsystem are the same. The Atomic Subsystem contains the same contents as Subsystem1, a Sine Wave connected to a To Workspace and Outport blocks. The system is assigned condition V==1 and therefore its contents only execute when V==1. The propagations of conditions to subsystems is the same when backwards propagation as shown to the left, or forward propagation as shown in the Summary subsystem.   Variant Condition Propagation to Subsystems Copyright 2016 The MathWorks, Inc.    help

BLOCK:
Add;Atomic Subsystem;Bias5(Grouped);Bias5(Nonvirtual) ;Bias5(Ungrouped);Cst;Data Type Duplicate;GainA;GainB;MinMax;MinMax(Grouped) ;MinMax(Nonvirtual);MinMax(Ungrouped) ;Out;R;Reference;Scope;Sine;SubSystem;Subsystem;Summary;To Workspace;Unit Delay With Preview Resettable;Variant Sink;Variant Source;help;sum;u;y

BLOCKTYPE:
Constant;DataTypeDuplicate;Gain;Inport;MinMax;Outport;Scope;Sin;Sum;ToWorkspace;Unit Delay With Preview Resettable;VariantSink;VariantSource


MODELNAME: slexVariantConfigurationAnalysis
PATH: examples/simulink_variants/main/slexVariantConfigurationAnalysis.slx
BLOCKTYPE: Constant;DiscreteTransferFcn;Inport;Math;ModelReference;Outport;Saturate;VariantSink;VariantSource
BLOCKTYPE_FREQUENCY: 1;2;6;1;1;6;1;2;3
CHECKSUM: 71C819A86B02505168B130F0CB381856
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: slexVariantFuzzyLogic___Model_Block___
ANNOTATION:
 This illustrates the Variant Configuration Analysis which is an extension to the Variant Manager. You access the Variant Manager from the MODELING tab, design section and, if licensed, you can run the Variant Configuration Analysis using the &quot;Analyze&quot; button. In this example, we have seven variant configurations defined in variant manager. These configurations are saved in the variant configuration data object, &quot;sensor_configs&quot; that is in turn saved in the sensor_data.sldd. In the Variant manager select Analyze and you can select which configurations to analyze. You can also use the command-line APIs, Simulink.VariantConfigurationData class and set_param(model, ‘VariantConfigurationObject’, vcd) to associate the variant configuration data object with a model. See doc Simulink.VariantConfigurationData Simulink.VariantConfigurationAnalysis(...) to analyze models. See doc Simulink.VariantConfigurationAnalysis For example, you can analyze a model programmatically Create variant configuration analysis object: &gt;&gt; varConfigObj = Simulink.VariantConfigurationAnalysis(slexVariantConfigurationAnalysis, NamedConfigurations, {VendorACtrlLinear, VendorACtrlNonLinear, VendorACtrlFuzzy}) Analyze and open the analysis report: &gt;&gt; varConfigObj.showUI See doc Simulink.VariantManager.findVariantControlVars to determine the variant control variables used by a model. Copyright 2020 The MathWorks, Inc.  help  Variant Configuration Analysis

BLOCK:
Controller;F1_Sat;F1_Unsat;Fuzzy;In;InternalData;Linear;Linear_Control;Model;NonLinear;Out;Out_A;Out_B;Reference;Saturation;Select Vendor;Square;SubSystem;Variant Sink;Variant Source;Vendor A;Vendor B;help


MODELNAME: slexVariantControlPorts
PATH: examples/simulink_variants/main/slexVariantControlPorts.slx
BLOCK: Enable;Gain;In;Out;Sine;SubSystem;Subsystem;Variant Source;help
BLOCKTYPE: EnablePort;Gain;Inport;Outport;Sin;VariantSource
BLOCKTYPE_FREQUENCY: 1;2;1;2;2;1
CHECKSUM: 515C0D4936DCF8A58F32D1CC3A7CC032
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This illustrates the propagation of variant conditions to conditionally executed subsystems. When a control port (Enable, Trigger, Function-Call, Action) of a conditionally executed subsystem or Model block becomes conditional, the block is assigned the variant condition of the signal connected to the control port. The condition assigned to the subsystem or block is then propagated to blocks connected to its signal input and output ports. In this example, this means the Sine2 and Out1 will have the same variant condition as the Enabled Subsystem.  Variant Condition Propagation to Conditionally Executed Subsystems Copyright 2016 The MathWorks, Inc.  help


MODELNAME: slexVariantControlVariableChoices
PATH: examples/simulink_variants/main/slexVariantControlVariableChoices.slx
BLOCK: Controller ;Delay;In;Out;SubSystem;Subsystem;Variant Source;help
BLOCKTYPE: Delay;Inport;Outport;VariantSource
BLOCKTYPE_FREQUENCY: 1;6;5;1
CHECKSUM: 8079649FA77C96013F36C350B3626807
PRODUCT: AUTOSAR Blockset;Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 1) Add Subsystem or Model blocks as valid variant choices. 2) You cannot connect blocks at this level. At simulation, connectivity is automatically determined, based on the active variant and port name matching.  This model illustrates the different types of variant control variables supported for code generation and simulation workflows. 1. Normal MATLAB variables: MATLAB variables present in the base workspace can be used for quickly simulating the model and generating code. Variant choices for normal control variables can be selected via compiler flag options or via an imported header file. 2. Simulink.Parameter Objects: These can be used when customizations for storage classes are required. Please refer to custom storage classes in the documentation for more details. 3. AUTOSAR.Parameter Objects: These are used when generating AUTOSAR compliant code. Note: The variables can reside in a data dictionary as well.   Different Choices for Variant Control Variables  help


MODELNAME: slexVariantDataStores
PATH: examples/simulink_variants/main/slexVariantDataStores.slx
BLOCKTYPE_FREQUENCY: 1;2;2;4;1;2;5;10;2;7;1;3;5;2;2
CHECKSUM: 281FA9D43A148596E4121831F166E26D
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Emulate a sensor system, read sensor, normalize the value, then map it. Also record the normalized sensor value for use by other parts of the model. Sensor X is a sensor from supplier X. Emulate a sensor system, read sensor, normalize the value, then map it. Also record the normalized sensor value for use by other parts of the model. Sensor X is a sensor from supplier X.  Conditions are propagated to Data Store Read and Data Store Write blocks. The condition of the Data Store Memory block is the logical or of the conditions assigned to the corresponding Data Store Read and Data Store write blocks. A global data store can be created by using a Simulink.Signal objects from the base workspace. Global data stores are accessible to every model, including all referenced models. Global data stores are always unconditional. The Enabled Subsystem1 and Enabled Subsystem2 contain Data Store Write blocks that write to DSM1 or the Data Store Memory1 block. The inherited conditions of these Data Store Write blocks are V==1 and V==2 respectively. Similarly, the condition on the Data Store Read1 block is assigned V==1 || V==2. This means the condition on the Data Store Memory1 block is V==1 || V==2. Note, we use block priorities to ensure the block sorting is correct such that the Data Store Read1 is stored after the enabled subsystems. In the Sensor Status region to the right, we are using data stores to report the value of sensor status. Suppose we have a model that works with sensors and actuators from different vendors. Sensor X and Actuator X are provided by vendor X. Likewise Sensor Y and Actuator Y are provided by vendor Y. The Variant Source2 and Variant Sink2 blocks let us create one model that can target different systems based on hardware from vendor X or Y. The sensors provide different data and have to be normalized to a sensor independent value so the controller can be vendor independent. The output of the controller (the control signal for the plant) is sent to either Actuator Y Processing or Actuator X Processing which takes the normalized control signal and conditions it for writing to a vendor dependent actuator. Within the sensor processing atomic subsystems, we save the normalized value in a Data Store so it can be used by other parts of the model in a sensor independent manner. For example, in our model we record the normalized sensor value, the control input and control output for post analysis.  Sensor Status  Copyright 2016 The MathWorks Inc.  Variant Conditions and Data Stores  help

BLOCK:
Actuator X;Actuator X Processing;Actuator Y;Actuator Y Processing;Condition Signal for Actuator X;Condition Signal for Actuator Y;Constant;Control Input;Control Output;Control Signal;Controller;Data Store Memory;Data Store Read;Data Store Write;Enable;Enabled Subsystem;Gain;In;Normalize Sensor Value;Normalized Sensor Value;Out;Pulse Generator;Record;Recorder;Scope;Sensor Map;Sensor X;Sensor X Processing;Sensor Y Processing;Sine Wave;SubSystem;Variant Sink;Variant Source;help

BLOCKTYPE:
Constant;DataStoreMemory;DataStoreRead;DataStoreWrite;DiscretePulseGenerator;EnablePort;Gain;Inport;Lookup_n-D;Outport;Scope;Sin;ToWorkspace;VariantSink;VariantSource


MODELNAME: slexVariantExamples
PATH: examples/simulink_variants/main/slexVariantExamples.slx
CHECKSUM: 69EB08A22F4B89BF634BA44F43DEC4E0
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 Simulink Variant Examples a set of concept examples that illustrate some of the Simulink variant capabilites Variant blocks and parameters  Variant condition propagation Variant control mode and usage of enums Variant block codegen examples requires Simulink Coder  Variants and masking Variant assembly subsystem Symbolic dimension examples Requires Simulink Coder AUTOSAR examples requires AUTOSAR  Variants and conditionally executed systems Variant Parameter examples Variant Manager examples Requires Variant Manager for Simulink support package  Startup variants SLDV - Simulink Test example requires VnV Toolset Copyright 2016-2023 The MathWorks, Inc.

BLOCK:
DimensionVariants;PreprocessorConditionalsUsingVariantModel;PreprocessorConditionalsUsingVariantSubsystem;SubSystem;sldemo_mdlref_variants;sldemo_mdlref_variants_enum;sldemo_variant_subsystems_enum;slexASARPostBuildVariant;slexASARPostBuildVariantParameter;slexASARPreBuildVariantParameter;slexMaskSelfModifiableInterfaceBlocks;slexMaskVariantExample;slexNestedVSSWithCCAndST;slexStartupVariantVnVWorkflow;slexVariantAssemblySubsystemInExpression;slexVariantAssemblySubsystemInLabel;slexVariantAssemblySubsystemWithMaskInExpression;slexVariantAssemblySubsystemWithMaskInLabel;slexVariantBus;slexVariantCondPropToSubsystems;slexVariantConfigurationAnalysis;slexVariantControlPorts;slexVariantControlVariableChoices;slexVariantDataStores;slexVariantExportedFcn;slexVariantIRTVariantCondProp;slexVariantManagement;slexVariantManualBlocks;slexVariantMdlRefCondProp;slexVariantParameterBank;slexVariantParameters;slexVariantParametersCC;slexVariantParametersStartup;slexVariantParamsUsingSlParamChoices;slexVariantReducer;slexVariantReducerWiper;slexVariantSensors;slexVariantSetupUsingInMemoryEnums;slexVariantSetupUsingIntEnums;slexVariantSimulinkFunctionInherit;slexVariantSimulinkFunctionSpecify;slexVariantSourceAndSink;slexVariantSourceAndSinkWithStartup;slexVariantSourceFunctionCall;slexVariantStopCondProp;slexVariantSubsystemCtrlFromMaskandModelWks;slexVariantSubsystemEnableChoice;slexVariantSubsystemExportFunction;slexVariantSubsystemFunctionCall;slexVariantSubsystemMaskIconPromotion;slexVariantSubsystemUsingMaskAndEnums;slexVariantSubsystems;slexVariantSubsystemsAdaptiveInterface;slexVariantSubsystemsWithParSim;slexVariantSymbolicDims;slexVariantVnVWorkflow;slexVariantWiper;slexVariantsWithStartup


MODELNAME: slexVariantExportedFcn
PATH: examples/simulink_variants/main/slexVariantExportedFcn.slx
DESCRIPTION: Simulink Variants
BLOCK: Add;Constant;Gain;In;Out;SubA;SubB;SubSystem;Variant Source;function;help
BLOCKTYPE: Constant;Gain;Inport;Outport;Sum;TriggerPort;VariantSource
BLOCKTYPE_FREQUENCY: 2;2;5;4;2;2;1
CHECKSUM: BBE4362628D938A3126C3C188D88F36F
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This illustrates how a single-input, single-output Variant Source can be used to make a variant Function-Call Subsystem. The Variant Source has condition V==1, where V is a Simulink.Parameter and is defined in &quot;File -&gt; Model Properties -&gt; Callbacks -&gt; PostLoadFcn&quot;. The condition on the function-call signal specifies the condition for SubA and this condition is back propagated to blocks connected to SubAs input ports and forward propagated to the blocks connected to SubAs output ports. If you run in the base workspace, V.Value=0 and then update diagram, then SubA will be inactive because V ~= 1. Also notice that Out1 is inactive. However, In2 remains active. This is because SubB is active and In2 is also connected to SubB. If we disconnect the line between In2 and SubB, then In2 will be inactive.  Copyright 2016 The MathWorks, Inc.  help


MODELNAME: slexVariantFuzzyLogic
PATH: examples/simulink_variants/main/slexVariantFuzzyLogic.slx
BLOCKTYPE: Derivative;DiscreteIntegrator;Gain;Inport;Mux;Outport;Sum
BLOCKTYPE_FREQUENCY: 1;1;4;3;1;3;1
CHECKSUM: 437381F2C4CE9303919EA5187C537EB5
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 Example model used as a reference model in slexVariantConfigurationAnalysis demo model. Copyright 2020 The MathWorks, Inc.  help

BLOCK:
Derivative;Discrete-Time Integrator;Gain;In;Mux;Out;SubSystem;Subsystem;Sum;Type-1 Fuzzy PID;e;help;u


MODELNAME: slexVariantIRTVariantCondProp
PATH: examples/simulink_variants/main/slexVariantIRTVariantCondProp.slx
BLOCKTYPE_FREQUENCY: 3;1;1;3;1;1;1
CHECKSUM: A07C32BD7DB1F04D5D30F5DA75BFF354
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: ResetRefModel.slx___Model_Block___
ANNOTATION:
 This model illustrates how the variant conditions propagate in IRT blocks.   Variant Condition Propagation with IRT Blocks  help

BLOCK:
Compare To Constant;Constant;Counter Free-Running;Function-Call Generator;Model;Outport;Reference;Scope;SubSystem;help

BLOCKTYPE:
Compare To Constant;Constant;Counter Free-Running;Function-Call Generator;ModelReference;Outport;Scope


MODELNAME: slexVariantManagement
PATH: examples/simulink_variants/main/slexVariantManagement.slx
BLOCKTYPE_FREQUENCY: 2;1;1;2;7;1;5;8;1;1;1
CHECKSUM: E71EE07DB44A86935A4490572BBA70EE
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Variant Management This model illustrates configuring variants in Simulink(R) models using variant configurations. Variant configurations can be defined and saved inside Simulink.VariantConfigurationData objects. These objects can store multiple variant configurations and the same can be used by one or many models. The variant configurations contain control variables and and submodel configurations to configure variant in a model or model hierarchy. When a model uses a variant configuration, the same is validated during model compilation. 

ANNOTATION:
This model illustrates Simulink variant subsystems. Variant subsystems let you provide multiple implementations for a subsystem where only one implementation is active during simulation. You can programmatically swap out the active implementation and replace it with one of the other implementations without modifying the model. Variant Subsystems This model illustrates model reference variants. A Model block is used to reference one Simulink model from another Simulink model. A Model block can have different variants. A variant describes one of N possible modes a Model block can operate in. Each variant of the Model block references a specific model with model specific arguments. Only one variant is active for simulation. You can switch the active variant of a Model block by changing the values of variables in the base workspace or manually overriding variant selection using the Model block dialog. Model Reference Variants  Define the interface using port blocks. Select files to define choices. Copyright 2013-2023 The MathWorks, Inc.  Variant Management

BLOCK:
1-D Lookup Table;AISensor;Change Variant Configuration Data;Controller;Discrete Transfer Fcn;Discrete-Time Integrator;External;FLSensor;Gain;In;Internal;Linear Controller;More Info;Nonlinear Controller;Out;Plant;Pulse Generator;Scope;Sensor Modifier;Smart Controller;SubSystem;Sum;Unit Delay;VMExperimental;VMStandard;sensor

BLOCKTYPE:
DiscreteIntegrator;DiscretePulseGenerator;DiscreteTransferFcn;Gain;Inport;Lookup_n-D;ModelReference;Outport;Scope;Sum;UnitDelay

EXTERNALFILE_REFERENCE:
VMExperimental___Model_Block___VMStandard___Model_Block___slexVMAISensorModifier___Model_Block___slexVMFLSensorModifier___Model_Block___slexVariantManagementExternalPlantMdlRef___Model_Block___


MODELNAME: slexVariantManagementExternalPlantMdlRef
PATH: examples/simulink_variants/main/slexVariantManagementExternalPlantMdlRef.slx
BLOCKTYPE: DiscreteTransferFcn;Inport;Outport;VariantSink;VariantSource
BLOCKTYPE_FREQUENCY: 3;3;3;1;1
CHECKSUM: 2077D2A776BFC6C34E4FD735FF7D032D
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
External Plant A simple model which represents a plant implementation abstracted out in a model itself.

ANNOTATION:
This model illustrates Simulink.VariantExpression Source and Sink blocks as a pair to define variant regions. This lets you provide multiple implementations for a system where only one implementation is active during simulation. You can programmatically swap out the active implementation and replace it with one of the other implementations without modifying the model. Variant Source and Sink blocks Copyright 2013-2023 The MathWorks, Inc.

BLOCK:
Change Variant Configuration Data;High Fidelity;In;Low Fidelity;Out;Plant;SubSystem;Variant Sink;Variant Source


MODELNAME: slexVariantManualBlocks
PATH: examples/simulink_variants/main/slexVariantManualBlocks.slx
BLOCKTYPE_FREQUENCY: 2;1;1;1;1;1;1;1;1;1
CHECKSUM: 8A367AAA0C4530B7315196738640E4DE
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This model illustrates two of the inline variant blocks, the Manual Variant Source and the Manual Variant Sink blocks, which define variant choice regions at their input and output ports respectively. Only one region is active during simulation and the blocks in the inactive regions are excluded from simulation. To toggle the active variant choice, double-click the Manual Variant Source or Manual Variant Sink block. You can also programmatically toggle the variant choice via open_system(modelName/path/to/block). For example, double-clicking the Manual Variant Source will toggle the active choice. Similarily, double-clicking the Manual Variant Sink will toggle its active choice. You can add additional input ports to the Manual Variant Source by opening the parameter dialog by right-clicking on the Manual Variant Source block and selecting &quot;Mask -&gt; Mask Parameters&quot;. Similarly, you can add additional output ports to the Manual Variant Sink by opening its parameter dialog. When using the Simulink Coder, the generated code contains only the code for the active region and the definition of the active region is defined at update diagram-time based upon the active port of the corresponding Manual Variant Source or Manual Variant Sink block.  Copyright 2016 The MathWorks, Inc.  Manual Variant Source and Sink Blocks  help

BLOCK:
Counter Free-Running;Data Type Conversion;Display;Manual Variant Sink;Manual Variant Source;Out;Reference;Scope;Sine Wave;SubSystem;Sum;Trigonometric Function;help

BLOCKTYPE:
Counter Free-Running;DataTypeConversion;Display;ManualVariantSink;ManualVariantSource;Outport;Scope;Sin;Sum;Trigonometry


MODELNAME: slexVariantMdlRefCondProp
PATH: examples/simulink_variants/main/slexVariantMdlRefCondProp.slx
BLOCK: Add;Gain;Out;Sine;SubSystem;Variant Source;help;sub
BLOCKTYPE: Gain;ModelReference;Outport;Sin;Sum;VariantSource
BLOCKTYPE_FREQUENCY: 3;2;4;3;1;1
CHECKSUM: DB431C058C2C36F81BF4998878D71C8A
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: slexVariantMdlRefCondProp_sub1___Model_Block___slexVariantMdlRefCondProp_sub2___Model_Block___
ANNOTATION:
 This illustrates Model Reference support for inline variants. Model block, sub1 is propagated the variant condition, V==1. However, this condition is not propagated to the blocks within sub1. The blocks within sub1 implicitly inherit the condition V==1. Model block sub2 propagates OUT variant conditions.  help  Variant Condition Propagation and Model Blocks Copyright 2016 The MathWorks, Inc.


MODELNAME: slexVariantParameterBank
PATH: examples/simulink_variants/main/slexVariantParameterBank.slx
BLOCK: 1D Lookup;2D Lookup;Constant;Gain;Out;Sine Wave;SubSystem;Sum;help
BLOCKTYPE: Constant;Gain;Lookup_n-D;Outport;Sin;Sum
BLOCKTYPE_FREQUENCY: 2;1;2;1;1;1
CHECKSUM: 3BC0ECC48DBB44AD45A4D091869E6AB1
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
DESCRIPTION:
Inlining Block Parameters and Propagating Constant Values This model shows parameter inlining. Parameter inlining is an important optimization for code generation, that causes constant values to be numerically inlined into the code. 

ANNOTATION:
 This example illustrates how to group variant parameters in the generated code by adding them to the same variant parameter bank. The variant parameters are defined as Simulink.VariantVariable objects in the MATLAB script slexVariantParameterBankData.m. VCtrl is defined as a variant control variable with startup activation time. TABLE_DIM_0, SHIFT_VALUE, T1Break, T1Data, T2Break and T2Data are defined as variant parameters. All variant parameters use VCtrl as variant control variable in their choices. Since VCtrl is defined with startup activation time, all choices of the Simulink.VariantVariables will be present in the generated code. LUTBank is defined as a variant bank with necessary variant conditions and its property BankCoderInfo set to LUTBankCoderInfo. LUTBankCoderInfo is defined as a variant bank coder info with header file set to &quot;slexVariantParameterBank_lut_params.h, definition file set to slexVariantParameterBank_lut_params.c. The #pragma directives for the variant bank are specified through pre-statement and post-statement properties of LUTBankCoderInfo. Simulink.VariantVariable objects that share the same variant bank are grouped into same structure in the generated code. The look-up table blocks slexVariantParameterBank/1D Lookup and slexVariantParameterBank/2D Lookup refer to base workspace parameters T1Break, T1Data, T2Break and T2Data. The Bank property of these variant parameters is set to LUTBank. In the generated code, these parameters are grouped in the same structure. The structure is generated in the header file lookup_table_params.h specified in bank coder info object. typedef struct { real_T T1Break[11]; real_T T1Data[11]; real_T T2Break[3]; real_T T2Data[9]; } LUTBpAndData; A structure array of type LUTBpAndData includes the choice values of T1Break, T1Data, T2Break and T2Data. The number of elements in the array is two as it depends on the number of variant conditions specified in the VariantConditions property of the parameter bank object LUTBank. A pointer LUTBpAndData_ptr of structure type LUTBpAndData is generated and holds reference to active element of structure array. They are guarded with pre-statement and post-statement as specified in the bank coder info object LUTBankCoderInfo. /* Variant parameter bank section */#pragma data_seg(.mydata)extern LUTBpAndData LUTBpAndData_ptr_impl[2];extern LUTBpAndData *LUTBpAndData_ptr;#pragma end The definition of structure array and the pointer are generated in the definition file lookup_table_params.c specified in bank coder info object LUTBankCoderInfo. The code for switching the active choice based on variant control value is generated in the model initialize function. In case of variant banks, the pointer reference to structure element is switched based on variant control value. if (VCtrl == 1) { LUTBpAndData_ptr = &amp;LUTBpAndData_ptr_impl[0U]; } else if (VCtrl == 2) { LUTBpAndData_ptr = &amp;LUTBpAndData_ptr_impl[1U]; } For more information, type &quot;doc Simulink.VariantBank&quot; in MATLAB command window.   Variant Parameter Bank (if in generated code doing pointer switching)  Variant Parameter Bank (if in generated code doing pointer switching)  help Copyright 2023 The MathWorks, Inc.


MODELNAME: slexVariantParameters
PATH: examples/simulink_variants/main/slexVariantParameters.slx
BLOCK: Gain;In;Out;SubSystem;help
BLOCKTYPE: Gain;Inport;Outport
BLOCKTYPE_FREQUENCY: 2;2;2
CHECKSUM: 591A168818511CE00A5E1B284DFEC41D
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example illustrates how variant parameters work with different variant activation times. The variant parameters are defined as Simulink.VariantVariables in the MATALB® script slexVariantParameterData.m. V is defined as a variant control variable. Variables K1 and K2 are defined as variant parameters. Both variant parameters use V as the variant control variable in their choices. By default, the activation time for V is set to update diagram. update diagram: For &quot;V.ActivationTime = update diagram&quot; activation time, the active choice of Simulink.VariantVariable is determined before simulation and code generation. The generated code would contain only the active value of the variant parameter. Also, each choice can have different attributes (for example, dimension, data type and so on) for update diagram activation time. For the given definition of &quot;K1&quot; and &quot;K2&quot;, the generated code and value of &quot;V&quot; set to 1, the generated code will contain the active value: slexVariantParameters_Y.Out1 = 3.5 * slexVariantParameters_U.In1;slexVariantParameters_Y.Out2 = 4.5 * slexVariantParameters_U.In2; update diagram analyze all choices: For &quot;V.ActivationTime = update diagram analyze all choices&quot;, the active choice of Simulink.VariantVariantVariable is determined before simulation and code generation. The generated code is same as in case of &quot;update diagram&quot; activation time. However, for this activation time, Simulink® ensures that all choices of Simulink.VariantVariable have consistent attributes (for example, dimension, data type and so on.). code compile: For &quot;V.ActivationTime = code compile&quot;, the active choice is determined before simulation and when compiling the generated code. The generated code contains all values of Simulink.VariantVariable emitted, guarded by their variant condition expressions. The variant condition expressions are generated in form of preprocessor if conditionals. The value of the variant parameter is represented by a macro, whose definition changes based on value of variant control variable passed during compilation. For this example, the generated code for variant parameter values &quot;K1&quot; and &quot;K2&quot; will be: #if V == 1#define rtCP_Gain_K1 (3.5)#elif V == 2#define rtCP_Gain_K1 (8.5)#endif #if V == 1#define rtCP_Gain1_K2 (4.5)#elif V == 2#define rtCP_Gain1_K2 (9.5)#endif slexVariantParameters_Y.Out1 = rtCP_Gain_K1 * slexVariantParameters_U.In1;slexVariantParameters_Y.Out1 = rtCP_Gain_K2 * slexVariantParameters_U.In1; The active choice can be selected when compiling the generated code, by passing value for variant control variable V as preprocessor macro. (-DV=1 OR -DV=2) startup: For &quot;V.ActivationTime = startup&quot;, all choices of Simulink.VariantVariable are analyzed and available at model start. The active choice will be selected at start of Simulation or during model initialization function in generated code. The variant condition expressions are generated as if conditions. For this example, the generated code for variant parameter values &quot;K1&quot; and &quot;K2&quot; will be: void slexVariantParameters_initialize(void) { if (V == 1) { slexVariantParameters_P.K1 = 3.5; slexVariantParameters_P.K2 = 4.5; } else if (V == 2) { slexVariantParameters_P.K1 = 8.5; slexVariantParameters_P.K2 = 9.5; }} slexVariantParameters_Y.Out1 = slexVariantParameters_P.K1 * slexVariantParameters_U.In1;slexVariantParameters_Y.Out2 = slexVariantParameters_P.K2 * slexVariantParameters_U.In2; For more information see Variant Parameters in the documentation.  Variant Parameters with Different Activation Times  help Copyright 2020-2021 The MathWorks, Inc.


MODELNAME: slexVariantParametersCC
PATH: examples/simulink_variants/main/slexVariantParametersCC.slx
BLOCK: 1D Lookup;2D Lookup;Constant;G;In;Out;SubSystem;Sum;help
BLOCKTYPE: Constant;Gain;Inport;Lookup_n-D;Outport;Sum
BLOCKTYPE_FREQUENCY: 2;2;1;2;1;1
CHECKSUM: EAAE7C1AD110E12A26187A87633DD6E9
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example illustrates how variant parameters can be defined and used in the block parameters for simulation and code generation. The variant parameters are defined as Simulink.VariantVariable objects in the MATLAB script slexVariantParameterCCData.m. VCtrl is defined as a variant control variable with code compile activation time. MAX_LIFT, SLIDER_POS, T1Break, T1Data, T2Break and T2Data are defined as variant parameters. All variant parameters use VCtrl as variant control variable in their choices. Since VCtrl is defined with code compile activation time, all choices of the Simulink.VariantVariables will be present in the generated code. Simulink.VariantVariables defined with Auto storage class are emitted as inline parameters by default, and the ones defined with non-Auto storage class are emitted as tunable parameters. To specify a custom storage class, create a Simulink.Parameter object with the required attributes and use the name of the object to set the Specification property of the Simulink.VariantVariable object. For example, the constant blocks: slexVariantParametersCC/Constant and slexVariantParametersCC/Constant1 refer to base workspace parameters MAX_LIFT and SLIDER_POS respectively. These parameters have Auto storage class. The code for these parameters will be inlined as macros. The definition of the macro will change based on the value of variant control variable VCtrl. For example: #if VCtrl == 1#define rtCP_Constant_MAX_LIFT (10.0)#elif VCtrl == 2#define rtCP_Constant_MAX_LIFT (20.0)#endif The look-up table blocks slexVariantParametersCC/1D Lookup and slexVariantParametersCC/2D Lookup refer to base workspace parameters T1Break, T1Data, T2Break and T2Data. These parameters have ExportedGlobal storage class set on them through Specification property. These parameters are generated as extern variables with their initialization dependent on value of variant control variable VCtrl. Variables T1Break and T1Data also have different size choice values. Their dimension is represented with symbolic dimensions in generated code. For example: #if VCtrl == 1real_T T1Break[T1Break_dim0] = { -5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0 } ;#elif VCtrl == 2real_T T1Break[T1Break_dim0] = { -10.0, -9.0, -8.0, -7.0, -6.0, -5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 } ;#endif T1Break_dim0 is auto-generated dimension symbol with following definition: #if VCtrl == 1#define T1Break_dim0 11#elif VCtrl == 2#define T1Break_dim0 21#endif For more information, see Simulink.VariantVariable and Compile Code Conditionally for all Values of Variant Parameters with Same and Different Dimensions in the documentation.  Variant Parameters with Code Compile Activation Time (#if in generated code)  help Copyright 2020 The MathWorks, Inc.


MODELNAME: slexVariantParametersStartup
PATH: examples/simulink_variants/main/slexVariantParametersStartup.slx
BLOCK: Add;Discrete Transfer Fcn;Out;PID Controller;Reference;Step;SubSystem;help
BLOCKTYPE: DiscreteTransferFcn;Outport;PID 1dof;Step;Sum
BLOCKTYPE_FREQUENCY: 1;1;1;1;1
CHECKSUM: 830083F9721E1AC17F24F1ABBF799823
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
 This example illustrates usage of variant parameters in startup activation time to run generated executables with different values of control variables. The generated code doesnt need to be compiled again for changing variant control values. Variant parameters &quot;Kp&quot; and &quot;Ki&quot; used in this model are defined in &quot;slexVariantParameterGains.m&quot;. Parameters Kp and Ki are used as gain values in the PID controller block. Variant control variable &quot;VCtrl&quot; is used to control the active choice of these variant parameters. The variant control variable is using GetSet storage class to read the control variable value from text file &quot;slexVariantParametersStartup_VCtrl.txt&quot;. The definition for control variable, and access functions are provided in &quot;slexVariantParametersStartup_VCtrl.c&quot;. After generating code, observe that model initialize function contains code to update variant parameter values. After generating executable, value specified in &quot;slexVariantParametersStartup_VCtrl.txt&quot; can be updated to run executable with different values of variant control variable. Refer to &quot;slexVariantParameters_script.m&quot; for example of running executable with four different values of variant control variable &quot;VCtrl&quot;. For more information see Variant Parameters in the documentation.  Variant Parameters with startup Activation Time (if in generated code) Copyright 2021 The MathWorks, Inc.  help


MODELNAME: slexVariantParamsUsingSlParamChoices
PATH: examples/simulink_variants/main/slexVariantParamsUsingSlParamChoices.slx
BLOCK: Gain;In;Out;SubSystem;help
BLOCKTYPE: Gain;Inport;Outport
BLOCKTYPE_FREQUENCY: 1;1;1
CHECKSUM: F3E8C93FD087D65F09E799FBB1B5DC34
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example illustrates how variant parameters can be defined using Simulink.Parameter variables as choice values. Using Simulink.Parameter variables as choice values enables customizing the values for simulation and code generation workflows. In this example, the choices get their values from imported parameters in generated code. The variant parameters are defined as Simulink.VariantVariables in the MATALB® script slexVariantParameterSlParamData.m. V is defined as a variant control variable. Variables kp1 and kp2 are Simulink.Parameter variables having imported storage class. Variable kv is defined as a Simulink.VariantVariable that uses the variables kp1 and kp2 as choice values. The value for Simulink.VariantVariable kv is resolved to the value of the active Simulink.Parameter. In the generated code, since kp1 and kp2 have imported storage class, the value of variable &quot;kv&quot; can be set from imported data. Example generated code: void slexVariantParamsUsingSlParamChoices_initialize(void){ /* Variant Parameters using Simulink.Parameter variables for choice values */ if (V == 1) { slexVariantParamsUsingSlParam_P.kv = kp1; } else if (V == 2) { slexVariantParamsUsingSlParam_P.kv = kp2; }... } For more information see Variant Parameters in the documentation.  Variant Parameters using Simulink.Parameter choice variables  help Copyright 2021 The MathWorks, Inc.


MODELNAME: slexVariantReducer
PATH: examples/simulink_variants/main/slexVariantReducer.slx
BLOCKTYPE: Bias;DiscreteTransferFcn;Gain;Inport;Outport;Sin;Sum;VariantSink;VariantSource
BLOCKTYPE_FREQUENCY: 1;1;6;3;4;5;2;1;1
CHECKSUM: 7ED24167BDD8E34F930DB43A4416D9C8
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
 1) Add Subsystem or Model blocks as valid variant choices. 2) You cannot connect blocks at this level. At simulation, connectivity is automatically determined, based on the active variant and port name matching.  This illustrates the Variant Reducer tool in Variant Manager for Simulink. In this example, we have two variant configurations, named config1 and config2. These two configurations are saved in the variant configuration data object, slexVariantReducer_config that is in turn saved in the slexVariantReducer_config.mat (see the File -&gt; Model properties -&gt; Callbacks -&gt; PostLoadFcn). In the Variant Manager toolstrip, in the Apps section, click Variant Reducer and you can select which configurations to reduce to. You can also use the command-line APIs, Simulink.VariantConfigurationData class and set_param(model, ‘VariantConfigurationObject’, vcd) to associate the variant configuration data object with a model. See doc Simulink.VariantConfigurationData Simulink.VariantManager.reduceModel(...) to reduce models. See doc Simulink.VariantManager.reduceModel See doc Simulink.VariantManager.findVariantControlVars to determine the variant control variables used by a model.  Variant Reducer Copyright 2016 The MathWorks, Inc.  help

BLOCK:
Add;Bias;Discrete Transfer Fcn;Gain;In;Out;Sine;SubSystem;Sum;Variant Sink;Variant Source;Variant Subsystem;choice;help


MODELNAME: slexVariantReducerWiper
PATH: examples/simulink_variants/main/slexVariantReducerWiper.slx
BLOCKTYPE: Inport;Outport
BLOCKTYPE_FREQUENCY: 4;4
CHECKSUM: A0EC1BF909498B8812D3170ED5B73E1A
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: slexVariantWiperSubsysRef___SubsystemReference_Block___
ANNOTATION:
 Overview: This example illustrates Variant Reducer capability for a model using Subsystem Reference. References: - For an overview of Variant Reducer, refer to slexVariantReducer example model to understand general capabilities of Variant Reducer. - Refer to Subsystem reference documentation page to know more about using subsystem reference. - The existing slexVariantWiper example model is extended here to demonstrate Variant Reducer capabilities with subsystem reference. Description: This example shows a car wiper skeleton model which uses subsystem reference to model front and rear wipers. Both front and rear wiper instances refer to same subsystem reference file, slexVariantWiperSubsysRef.slx which is the referred subsystem. The referred subsystem model uses variant control variable R to choose the type of windshield wipers. When R is 0 (or any value other than 1 or 2), a Manual Wiper Setting is used as the control set point. When R is 1, the Rain Sensor Model 1 block is used to sense the amount of rain on the wind shield. Similarly, when R is 2, Rain Sensor Model 2 block is used. You can reduce this model for a given set of choices using Variant Reducer. You can launch Variant Reducer from Variant Manager by selecting &quot;Reduce model&quot;. This model is setup to reduce for the current active configuration corresponding to &quot;R = 0&quot;. The model PostLoadFcn callback defines &quot;R&quot;. Variant Reducer creates reduced versions of the top model (by default slexVariantReducerWiper_r.slx) and referred subsystem (by default slexVariantWiperSubsysRef_r.slx).  Copyright 2020 The MathWorks, Inc.  help  Variant Reducer capabilities with Subsystem Reference Car wiper motor skeleton

BLOCK:
Front Wiper;Front Wiper Output;Front Wiper Speed;Input;Out;Rear Wiper;Rear Wiper Output;Rear Wiper Speed;SubSystem;Wiper;help


MODELNAME: slexVariantSensors
PATH: examples/simulink_variants/main/slexVariantSensors.slx
BLOCKTYPE: Constant;Inport;Outport;VariantSource
BLOCKTYPE_FREQUENCY: 8;1;2;6
CHECKSUM: 9396E80865E367D11B15EE257C80BC73
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This illustrates how you can cascade Variant Source blocks to provide variant selection on sensors. In this concept model, weve masked a constant block as a place holder for analog-to-digital converter (A/D) blocks. This example is showing sensor inputs. Alternatively, you could use Variant Sink blocks to create variation of actuator outputs. The variant control variables that parameterize the Variant Source blocks are defined in the PostLoadFcn of &quot;File -&gt; Model Properties -&gt; Callbacks&quot;. After opening up the example, if you update diagram, youll see that the AD5 is active. The Vendor is a Variant Source block which selects between two vendors, VENDOR==1 or VENDER==2 and in the base workspace, youll see that VENDOR is a Simulink.Parameter with VENDOR.Value=1. The Device Model is a Variant Source that selects between DEVICE_MODEL==1, DEVICE_MODEL==2, or DEVICE_MODEL==3 and in the base workspace, youll see that DEVICE_MODEL.Value=3. The C series is a Variant Source block that selects between C_SERIES==1 and C_SERIES==2 and in the base workspace, youll see that C_SERIES.Value=2.   Variant Sensors Copyright 2016 The MathWorks, Inc.  help

BLOCK:
A series;AD;B series;C series;Device Model;Filter;Normalized Sensor;Out;SubSystem;Vendor;X Sensor;help;s


MODELNAME: slexVariantSetupUsingInMemoryEnums
PATH: examples/simulink_variants/main/slexVariantSetupUsingInMemoryEnums.slx
BLOCKTYPE: DiscreteTransferFcn;Inport;Lookup_n-D;Outport;Sum;VariantSink;VariantSource
BLOCKTYPE_FREQUENCY: 3;4;1;4;1;1;1
CHECKSUM: 3A32E2F9FA0A810C29727952F6E55317
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 All supported simulink enumerations can be used in a variant condition expression. This demo model explains how to use an in-memory enumeration i.e. a Simulink.defineIntEnumType to setup a variant condition expression for simulation and code generation. The variant source and sink blocks use the enumeration Ctrl defined in the Preload function of this model. It defines two possible variations in controller choices, Linear and Nonlinear. A regular MATLAB variable V, chooses the current active controller.  Copyright 2020 The MathWorks, Inc.

BLOCK:
1-D Lookup Table;Discrete Transfer Fcn;In;Info;Linear controller;Nonlinear controller;Out;Plant;RefSig;SubSystem;Sum;Variant Sink;Variant Source


MODELNAME: slexVariantSetupUsingIntEnums
PATH: examples/simulink_variants/main/slexVariantSetupUsingIntEnums.slx
BLOCKTYPE: DiscreteTransferFcn;Inport;Lookup_n-D;Outport;Sum;VariantSink;VariantSource
BLOCKTYPE_FREQUENCY: 3;4;1;4;1;1;1
CHECKSUM: 31458D1319075B2C6F815A3F03F365FB
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 All supported simulink enumerations can be used in a variant condition expression. This demo model explains how to use an enumeration inheriting from the built-in integer type to setup a variant condition expression for simulation and code generation. The variant source and sink blocks use the enumeration ControllerChoice defined in the M-File ControllerChoice.m. It defines two possible variations in controller choices, Linear and Nonlinear. A regular MATLAB variable V, chooses the current active controller.  Copyright 2020 The MathWorks, Inc.

BLOCK:
1-D Lookup Table;Discrete Transfer Fcn;In;Info;Linear controller;Nonlinear controller;Out;Plant;RefSig;SubSystem;Sum;Variant Sink;Variant Source


MODELNAME: slexVariantSimulinkFunctionInherit
PATH: examples/simulink_variants/main/slexVariantSimulinkFunctionInherit.slx
BLOCK: Constant;Display;Function Caller;Gain;Simulink Function;SubSystem;Variant Source;help;timestwo;u;y
BLOCKTYPE: ArgIn;ArgOut;Constant;Display;FunctionCaller;Gain;TriggerPort;VariantSource
BLOCKTYPE_FREQUENCY: 1;1;2;2;2;1;1;2
CHECKSUM: 886250F88CB6253F21C177BB5CF2E24C
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 The Function-Call port block dialog within the Simulink Function specifies the Variant Control as &quot;(inherit)&quot;. &quot;(inherit)&quot; is a keyword that indicates that the variant condition on the Simulink Function block is derived from its Function Caller blocks. This enables the Simulink Function to be optimally defined. Run update diagram, and open variant condition legend. Notice that the Simulink Function block inherits a variant condition A == 1 || B == 1 which is OR of all the corresponding Function Caller blocks variant conditions in this model. Function Caller1 with condition A == 1 Function Caller2 with condition B == 1 Simulink Functions can also be used across Model Reference hierarchies. See slexVariantSimulinkFunctionSpecify that illustrates this modeling pattern.   help Copyright 2017 The MathWorks, Inc.  Variant Simulink Functions - Inherit Condition


MODELNAME: slexVariantSimulinkFunctionSpecify
PATH: examples/simulink_variants/main/slexVariantSimulinkFunctionSpecify.slx
BLOCK: Constant;Display;Function Caller;SubSystem;Variant Source;help;utils
BLOCKTYPE: Constant;Display;FunctionCaller;ModelReference;VariantSource
BLOCKTYPE_FREQUENCY: 1;1;1;1;1
CHECKSUM: 2347464EAC081A61948AEA796E1002EC
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: slexVariantSimulinkFunctionSpecifyRef.slx___Model_Block___
ANNOTATION:
 Simulink Function and Function Caller blocks can be used across model hierarchies. Variant Simulink Function block is defined in slexVariantSimulinkFunctionSpecifyRef which is referenced through the model block, utils. The Function-Call port block inside the Simulink Function specifies the Variant Control as V==1. This indicates that the Simulink Function is available only when variant control variable V is 1. The Function Caller block is connected to a SISO Variant Source with condition V==1 and conditionally invokes the Variant Simulink Function. Since, Function visibility of Variant Simulink Function is set to &quot;scoped&quot;, it is invoked using the model block name as scope &quot;utils.timestwo()&quot;. A Simulink Function can also inherit its variant condition. See slexVariantSimulinkFunctionInherit that illustrates this modeling pattern. Copyright 2017 The MathWorks, Inc.  Variant Simulink Functions - Specified Condition  help


MODELNAME: slexVariantSourceAndSink
PATH: examples/simulink_variants/main/slexVariantSourceAndSink.slx
BLOCK: Add;Gain;Out;Scope;Sine;SubSystem;Subtract;Sum;Terminator;Variant Sink;Variant Source;help
BLOCKTYPE: Gain;Outport;Scope;Sin;Sum;Terminator;VariantSink;VariantSource
BLOCKTYPE_FREQUENCY: 4;3;1;6;3;1;1;2
CHECKSUM: 4C1DEA01F9D5BB1D7AF6D9D22DCC27A7
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This illustrates how the Variant Source and Sink blocks define variant choice regions based on block connectivity. The variant regions are computed by Simulink when you run &quot;Simulation -&gt; Update Diagram&quot;. The process of computing the variant choice regions is called variant condition propagation. The Variant Source provides variation on the source of a signal and the Variant Sink block provides variation on the destination (sink) of a signal. You can select &quot;Display &gt; Blocks &gt; Variant Conditions&quot; to view the variant condition annotations with a legend as described below. For example, Variant Source1 has conditions W==1 and W==2 for its input ports. W is a variant control variable and is defined in the PostLoadFcn of &quot;File -&gt; Model Properties -&gt; Callbacks&quot;. The Sine3 block is active when W==1 and the Sine4 block is active when W==2. Examining the Variant Source2 block, we have the first input port active when V==1 and the second input port active when V==2. The Add1 block is active when V==2 and the propagation continues, when means the Variant Source1 is active when V==2, likewise the Sine3 and Sine4 can only be active when V==2, therefore the Sine3 is assigned the variant condition V==2 &amp;&amp; W==1 and the Sine4 is assigned V==2 &amp;&amp; W==2. If we select the &quot;Allow zero active variant controls&quot; on the Variant Source2 block parameter dialog, then the Gain3, Scope1, and Out1 will be assigned the variant condition, &quot;V==1 || V==2&quot;. The Variant Sink specifies conditions W==1 and W==2 for its output ports. These conditions are propagated forward to the connected blocks. The Gain5 block is assigned the condition, W==1. The Sum block illustrates two key concepts in variant condition propagation: Signals are only variant if explicitly marked or when all paths can be proven to be variant. To make the Sine6, Sum, Out2 variant you need to place a Single-Input Single-Output Variant Source before Out2 (or after Sine6) Reading an inactive signal is equivalent to reading &quot;ground&quot;. When W ~= 1, then the bottom input to the Sum block is inactive and Out2 = Sine6 + ground. The second output port of the Variant Sink block has the condition W==2 and this is propagated forward to the Gain2, Subtract, and Terminator blocks. If you select &quot;Allow zero active variant controls&quot; on the Variant Sink block parameter dialog, then the Sine5 and Gain4 will be assigned the variant condition W==2. The Variant Sink and the Variant Source2 blocks have the Variant activation time set as code compile. This means that the generated code from the Simulink Embedded Coder will have #if COND present in the generated code and you select the active choice at code compile-time. The Variant Source1 block has the Variant activation time set as update diagram. The generated code will have only the active choice present. Legend To view variant condition annotations for this model, from the Simulink editor menu, select &quot;Display &gt; Blocks &gt; Variant Conditions&quot;.If it is already selected, you can run Updated Diagram (^D) to compile the model and display the conditions. There is also a separate Variant Condition legend window. The Variant Condition legend displays on the block &quot;v:C&quot; where C represents the variant condition index on the legend. There are no annotations on unconditional blocks. The v:C labels in the legend are hyper-linked and highlight the blocks with condition, C. The condition in the Description field of the annotation wraps (uses multiple lines when it is long). The table shows the final propagated (computed) conditions for blocks. For example, conditions that you entered in Variant Source blocks may or may not appear in the table. They will only appear in the table if the condition was actually applied to a block. This reduces clutter in the legend. The conditions in the table are sorted. Conditions will be false if the Simulink variant condition expression engine can prove the blocks will never run. For example, Sine4 feeds the 2nd input of Variant Source1. If we change the condition of the 2nd input port on the Variant Source1 dialog, from W==2 to V==4, this will result in the condition V==4 &amp;&amp; V==2 for Sine4 which is always false. This condition arises because the Variant Source1 feeds the Add1 block which is connected to the 2nd input of Variant Source2, which says Variant Source1 will only be active when V==2, therefore Sine4 can only be active when V==4 &amp;&amp; V==2 which is always false.   Variant Source and Variant Sink Blocks Copyright 2016-2023 The MathWorks, Inc.  help


MODELNAME: slexVariantSourceAndSinkWithStartup
PATH: examples/simulink_variants/main/slexVariantSourceAndSinkWithStartup.slx
BLOCKTYPE: Gain;Outport;Scope;Sin;Sum;System Initialize;VariantSink;VariantSource
BLOCKTYPE_FREQUENCY: 3;4;1;6;2;1;1;2
CHECKSUM: 8622C82A05DE02419EAB6843DDFD4451
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
 This illustrates how the Variant Source and Variant Sink blocks with startup variant activation define variant choice regions based on block connectivity. The variant regions are computed by Simulink when you run &quot;Simulation -&gt; Update Diagram&quot;. The process of computing the variant choice regions is called variant condition propagation. The Variant Source provides variation on the source of a signal and the Variant Sink block provides variation on the destination (sink) of a signal. You can select &quot;Display &gt; Blocks &gt; Variant Conditions&quot; to view the variant condition annotations with a legend as described below. For example, Variant Source1 has conditions X==1 and X==2 for its input ports. Here, the Variant Source1 has update diagram activation. X is a variant control variable and is defined in the PostLoadFcn of &quot;File -&gt; Model Properties -&gt; Callbacks&quot;. The Sine3 block is active when X==1 is true and the Sine4 block is active when X==2 is true. Examining the Variant Source2 block, we have the first input port active when V==1 is true and the second input port active when V==2 is true. The Variant Source2 has startup activation. Since the Variant Source2 is in startup activation, all the choices are available in Simulink compile and active/inactive branch can be toggled just before simulation. The Add1 block is active in simulation when V==2 is true and the Sine1 block is active in simulation when V==1 is true. If we select the &quot;Allow zero active variant controls&quot; on the Variant Source2 block parameter dialog, then the Gain3, Scope1, and Out1 will be assigned the variant condition, &quot;V==1 || V==2&quot;. The Variant Sink specifies conditions W==1 and W==2 for its output ports. These conditions are propagated forward to the connected blocks. The Gain5 block is assigned the condition, W==1. The Sum block illustrates two key concepts in variant condition propagation: Signals are only variant if explicitly marked or when all paths can be proven to be variant. To make the Sine6, Sum, Out2 variant you need to place a Single-Input Single-Output Variant Source before Out2 (or after Sine6) Reading an inactive signal is equivalent to reading &quot;ground&quot;. With startup activation, the ground value assignment happens when W ~= 1, then the bottom input to the Sum block is inactive and Out2 = Sine6 + ground. The second output port of the Variant Sink block has the condition W==2 and this is propagated forward to the Out4 block. If you select &quot;Allow zero active variant controls&quot; on the Variant Sink block parameter dialog, then the Sine5 and Gain4 will be assigned the variant condition W==1 || W==2. Since the Variant Sink is in startup activation, all the choices are available in Simulink compile and active/inactive branch can be toggled just before simulation. The Gain5 block is active in simulation when W==1 is true and the Out4 block is active in simulation when W==2 is true. The Variant Sink and the Variant Source2 blocks have the Variant activation time set as startup. This means that the generated code from the Embedded Coder (ERT) or Simulink Coder (GRT) will have regular if condition present in the generated code and you select the active choice by writing custom code in model initialize function. We have ReadVarControl.c used in custom code section in configset, which has the below content, #include &quot;rtwtypes.h&quot; extern int32_T V; extern int32_T W; void SetValueOfVarControls() { // The values of V and W can be read from a sensor or hardware // for simplicity it is hardcoded. V = 2; W = 2; } In the Custom code -&gt; model initialize function, we can call this function to set the value of V and W. The Variant Source1 block has the Variant activation time set as update diagram. The generated code will have only the active choice present. Legend To view variant condition annotations for this model, from the Simulink editor menu, select &quot;Display &gt; Blocks &gt; Variant Conditions&quot;.If it is already selected, you can run Updated Diagram (^D) to compile the model and display the conditions. There is also a separate Variant Condition legend window. The Variant Condition legend displays on the block &quot;v:C&quot; where C represents the variant condition index on the legend. There are no annotations on unconditional blocks. The v:C labels in the legend are hyper-linked and highlight the blocks with condition, C. The condition in the Description field of the annotation wraps (uses multiple lines when it is long). The table shows the final propagated (computed) conditions for blocks. For example, conditions that you entered in Variant Source blocks may or may not appear in the table. They will only appear in the table if the condition was actually applied to a block. This reduces clutter in the legend. The conditions in the table are sorted. Conditions will be false if the Simulink variant condition expression engine can prove the blocks will never run. For example, Sine4 feeds the 2nd input of Variant Source1. If we change the condition of the 2nd input port on the Variant Source1 dialog, from X==2 to V==4, this will result in the condition V==4 &amp;&amp; V==2 for Sine4 which is always false. This condition arises because the Variant Source1 feeds the Add1 block which is connected to the 2nd input of Variant Source2, which says Variant Source1 will only be active when V==2, therefore Sine4 can only be active when V==4 &amp;&amp; V==2 which is always false.   Variant Source and Variant Sink Blocks with startup activation  help Copyright 2021 The MathWorks, Inc.

BLOCK:
Add;Build ERT;Build GRT;Gain;Out;Scope;Sine;SubSystem;Sum;System Initialize;Variant Sink;Variant Source;help


MODELNAME: slexVariantSourceFunctionCall
PATH: examples/simulink_variants/main/slexVariantSourceFunctionCall.slx
BLOCKTYPE: Constant;Demux;Inport;Outport;S-Function;Scope;Sin;Sum;TriggerPort;UnitDelay;VariantSource
BLOCKTYPE_FREQUENCY: 1;2;2;4;2;1;1;1;1;1;1
CHECKSUM: 0F496139028DA163442FCA7D2811A18B
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This illustrates how the Variant Source blocks allows joining of function-call signals. When a function call signals are connected to variant source you must enable [x] Output function call on the variant source block parameters dialog. To do it programmatically, use set_param(variantsrcblockpath, OutputFunctionCall, on). If the model is configured, the variant regions are computed by Simulink when you run &quot;Simulation -&gt; Update Diagram&quot;. Variant condition propagation determines active/inactive variant choices like normal variant source block. You should be able to simulate and generate code for the variant function-call signals. For example, Variant Source has conditions A==1 and A==2 for its input ports. A is a variant control variable and is defined in the PostLoadFcn of &quot;File -&gt; Model Properties -&gt; Callbacks&quot;. The Sine Wave is connected to two MATLAB Function caller blocks, slexVariantSourceFunctionCall/Filter Positive inputs and slexVariantSourceFunctionCall/Filter Negative inputs. slexVariantSourceFunctionCall/Filter Positive inputs is active when A==1 and the slexVariantSourceFunctionCall/Filter Negative inputs is active when A==2. Function-call subsystem slexVariantSourceFunctionCall/Counter is run when Sine Wave outputs are &gt;0 and A==1, where as it is triggered when Sine Wave outputs are &lt;=0 and A == 2. When A ~= 1 and A ~= 2, function-call subsystem slexVariantSourceFunctionCall/Counter is not run, since the sine wave is inactive. [x] Output function call Function call trigger for all positive values of sine wave Function call trigger for all 0 and negative values of sine wave Copyright 2020 The MathWorks, Inc.  help  Variant Source and Function call signal joining

BLOCK:
 Demux ; SFunction ;Add;Constant;Counter;Filter Negative inputs;Filter Positive inputs;Out;Scope;Sine Wave;SubSystem;Unit Delay;Variant Source;fcn;fcncall();help;u


MODELNAME: slexVariantStopCondProp
PATH: examples/simulink_variants/main/slexVariantStopCondProp.slx
BLOCKTYPE: Gain;Ground;Inport;Outport;Scope;Sin;Sum;Terminator;VariantSource
BLOCKTYPE_FREQUENCY: 6;2;8;7;1;3;1;4;3
CHECKSUM: 91C9AC00DC340F6D3B323F0F33C25776
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This illustrates how to control variant condition propagation capabilities of Simulink. Simulink will automatically compute the variant regions based on block connectivity. This is known as variant condition propagation. During variant condition propagation, Simulink automatically assigns conditions to blocks. You can view the conditions assigned to blocks by updating diagram and then looking at the &quot;Display -&gt; Blocks -&gt; Variant Condition Legend&quot;. The Variant Source1 has condition, A == 1, which is propagated backwards and forward to the connected blocks. After updating diagram and examining the &quot;Display -&gt; Blocks -&gt; Variant Condition Legend&quot; we see that the Sine Wave1 block is unconditional. This is because the Scope is unconditional and therefore its input, which is the output of the Sine Wave1, must be unconditional. If we were to remove (or comment-out) the Scope, and update diagram wed see the Sine Wave1 become conditional. Replacing the Scope it with any other block including a Terminator would result in Sine Wave1 being unconditional. We also see that the Sum block is unconditional. This is because the 2nd input to the Sum block is an unconditional signal and therefore the output of the Sum must be unconditional. If we were to place the Gain5, Sum, and Sine Wave2 blocks in a Subsystem (select and ^G) then the Subsystem will be conditional which means the blocks within the Subsystem are also conditional. The subsystem is conditional because it is a system (a well-defined algorithm) with only one input and that input is conditional. If you would like the Subsystem to be treated as an ungrouped collection of blocks and not a system, then you can unselect the &quot;Treat as grouped when propagating variant conditions&quot; parameter in the Subsystem block parameters dialog. This the same as expanding the subsystem in place. We can leverage the properties of variant condition propagation to create stop the propagation. For example, we are using the Terminator1 block to the right to force the Since Wave to always run. Forcing the Sine Wave to be unconditional in this model only means theres unnecessary computation happing. However, you could imagine replacing the Sine Wave with a Subsystem which has dynamics that must always run and the Terminator block can be used to ensure it is not assigned a condition. We can also create a stop propagation block that will stop the variant condition propagation on the output side (stop forward propagation) as shown by the Stop on output block. Note the Stop on output block has the &quot;Treat as grouped when propagating variant conditions&quot; Subsystem parameter turned off. The Stop on both sides stops both forward and backwards propagation by leveraging the properties of variant condition propagation. Again note that the block has the &quot;Treat as grouped when propagating variant conditions&quot; Subsystem parameter turned off.   Controlling and Stopping Variant Condition Propagation Copyright 2016-2020 The MathWorks, Inc.  help

BLOCK:
Gain;Ground;In;Out;Scope;Sine Wave;Stop on both sides;Stop on output;SubSystem;Subsystem;Sum;Terminator;Variant Source;help


MODELNAME: slexVariantSubsystemCtrlFromMaskandModelWks
PATH: examples/simulink_variants/main/slexVariantSubsystemCtrlFromMaskandModelWks.slx
BLOCK: Constant;Display;Gain;In;Info;Out;SS;Scope;Sine Wave;SubSystem;VSS;Vsrc;x
BLOCKTYPE: Constant;Display;Gain;Inport;Outport;Scope;Sin;VariantSource
BLOCKTYPE_FREQUENCY: 5;4;8;12;14;1;1;1
CHECKSUM: A1328E1A987484CE291155D4FBF2C657
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example shows how the active variant of a Variant Subsystem/ Inline Variant block can be controlled from the Mask workspace. This is a basic demo whose intent is to show what are the different ways the user can use the mask to control the active variant of a Variant Subsystem block. When Using the mask workspace or model workspace not that only normal MATLAB variables are supported as variant control variables from the mask or model workspaces. We cannot use Simulink.VariantExpression objects or Simulink.Parameters as the variant control variable from the mask/model workspace. Case 1: Active variant controlled by the mask parameter The block VSS1 shows how the active variant can be controlled from a mask parameter that is defined on the mask dialog of the block. The Variant Subsystem VSS1 contains a mask with the mask parameter B defined on it. B is an edit box. This mask parameter is used as the variant control variable for the Variant Subsystem. The user can change the active variant by changing the values on the mask dialog of VSS1. Case 2: Active variant controlled by variable defined in mask workspace The block VSS2 shows how variables that are defined in the mask initialization tab can be utilised as variant control variables. The Variant Subsystem VSS2 contains a mask on it. In the mask initialization tab, we have defined a variable A. This variable exists in the mask workspace and can be used as the variant control variable for the variant subsystem. Case 3: Active variant controlled by variable defined in the model workspace The block VSS3 shows how variables that are defined in the model workspace can be used as the variant control variable. The Variant Subsystem VSS3 has the variant control variable C. This variable is defined in the model workspace. The model workspace can be viewed and edited from the Model Explorer. Case 4: Controlling the active variant using mask initialization script(method used in earlier releases) VSS4 is an example of how earlier users had to write mask initialization scripts to control the active variant. This is not a recommended approach from R2020b. The Variant Subsystem VSS4 contains a mask parameter VChoice. The user can select the value of VChoice and then the script in the mask initialization tab reads this value and sets the active choice of the variants. This is how variants could be controled from the mask in the previous releases of Simulink. Case 5: Active variant of Variant Source (inline variant blocks) controlled by variable defined in mask workspace This subsystem is an example of how to use the mask workspace to define the variant control variables for Inline Variant blocks. The Subsystem SS1 contains a mask that defines a pop-up menu that gives the option to choose between the choices of the variant source. When using the Inline Variant blocks with controls from mask workspace you must ensure that conditions do not propagate outside the scope of the mask workspace.  Variant Control variables from Mask/Model workspace Copyright 2020 The MathWorks, Inc. The Variant Subsystem, VSS4, contains a mask parameter, VChoice. You can select the value of VChoice from the mask dialog. During simulation, the script in the mask Initialization tab reads this value and sets the active choice of the Variants. This is how you could control the Variant choices from the mask in earlier releases of Simulink. This is no longer a recommended approach. The Variant Subsystem, VSS1, contains a mask with the mask parameter, B, defined on it. B is an edit box. This mask parameter is used as a Variant control variable for the Variant Subsystem. You can control the active Variant by changing the values on the mask dialog of VSS1. The Variant Subsystem, VSS2, contains a mask on it. In the mask Initialization tab, a variable, A, is defined. You can use this variable as a Variant control variable for the Variant Subsystem. The Variant Subsystem, VSS3, has a Variant control variable, C. This variable is defined in the model workspace. You can view and edit this model workspace variable from the Model Explorer. The Subsystem SS1, has a mask defined on it. This mask has a mask parameter VC that is used as a variant control variable for the Variant Source block Vsrc.


MODELNAME: slexVariantSubsystemEnableChoice
PATH: examples/simulink_variants/main/slexVariantSubsystemEnableChoice.slx
DESCRIPTION: Code Variants Using Subsystems
BLOCK: Controller;Discrete Filter;Enable;In;Linear;Lookup Table;Nonlinear;Out;Sine Wave;SubSystem;help
BLOCKTYPE: DiscreteFilter;EnablePort;Inport;Lookup_n-D;Outport;Sin
BLOCKTYPE_FREQUENCY: 2;3;4;1;4;1
CHECKSUM: B992663735DD9B12951CD7852E16A142
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example illustrates the Variant Subsystem with Enable Subsystem as choice. In this example, we have Variant Subsystem Controller with two variant choices, named Linear and Nonlinear governed by conditions VSSMODE==0 and VSSMODE==1. This model can simulate and generate code based on VSSMODE value. Variant Subsystem supports conditionally executed systems like Enable, Trigger and Reset systems as its choices. For more information, see Variant Subsystems   help  Variant Subsystem with Conditionally Executed Systems Copyright 2017-2022 The MathWorks, Inc.


MODELNAME: slexVariantSubsystemExportFunction
PATH: examples/simulink_variants/main/slexVariantSubsystemExportFunction.slx
DESCRIPTION: Code Variants Using Subsystems
BLOCK: Discrete Filter;In;Linear;Lookup Table;Nonlinear;Out;SubSystem;VariantFcnCall;fcn;help
BLOCKTYPE: DiscreteFilter;Inport;Lookup_n-D;Outport;TriggerPort
BLOCKTYPE_FREQUENCY: 2;5;1;4;3
CHECKSUM: D728F1FD6A6D6CD6950E3D25A216590D
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This example illustrates export function modeling of Variant Subsystem with Function-Call blocks as choice. It also demonstrates preprocessor guarding of content inside export function definition. In this example, Variant Subsystem &quot;VariantFcnCall&quot; has two variant choices, named Linear and Nonlinear governed by conditions VSSMODE==0 and VSSMODE==1. Root inport(fcn) is a function-call inport connecting variant subsystem making this model as export function model. Snippet of generated code demonstrating preprocessor guarding inside export function: fcn() { #if VSSMODE==0 // code for Linear choice ....... #elif VSSMODE==1 // code for Nonlinear choice ....... #endif } For more information, see Variant Subsystems   help  Export function model with Variant Subsystem Copyright 2017-2022 The MathWorks, Inc.


MODELNAME: slexVariantSubsystemFunctionCall
PATH: examples/simulink_variants/main/slexVariantSubsystemFunctionCall.slx
BLOCKTYPE: Demux;DiscretePulseGenerator;Inport;Outport;S-Function;Scope;Sin;TriggerPort;UnitDelay
BLOCKTYPE_FREQUENCY: 2;1;4;9;2;1;1;1;1
CHECKSUM: 3E11246F6F0AD659B2A97E7B588A2CD2
PRODUCT: Embedded Coder;MATLAB;Simulink;Stateflow
PRODUCT_BASECODE: SL
ANNOTATION:
[x] Ouput function call Since activate() outport block is receiving a function-call it should have OutputFunctionCall parameter on.  This illustrates how the Variant Subsystem blocks allows joining of function-call signals on its outports. When a function call signals are emitted by the choice systems you enable [x] Output function call on the outport block parameters dialog on which the function-call signal is passed on. To do it programatically, use set_param(variantsubsystem_outport_path, OutputFunctionCall, on). If the model is configured, the active variant choice is computed by Simulink when you run &quot;Simulation -&gt; Update Diagram&quot;. You should be able to simulate and generate code for the variant function-call signals on variant subsystem outputs. For example, Variant Subsystem has conditions A==1 and A==2 for two choices. A is a variant control variable and is defined in the PostLoadFcn of &quot;File -&gt; Model Properties -&gt; Callbacks&quot;. The Pulse Generator is connected to Variant Subsystem and all the choices of Variant Subsystems, Chart1 and Chart2 are configured with port names matching the corresponding portnames of the Variant Subsystem. In this case Variant Subsystem/activate() outport block is getting function-call signal from the choices Chart1 and Chart2. So [x]Output function call is selected for Variant Subsystem/activate() in its paramter dialog. You can also set this parameter programattically by using set_param(VariantSubsystem_Outport_Block_Path, OutputFunctionCall, on), by default this parameter is set to off. As you can see Variant Subsystem/out receives non function-call signal so you dont need to set this parameter to on. This model will simulate and generate code. Copyright 2020-2022 The MathWorks, Inc.  help  Variant Subsystem with function call signal on outports

BLOCK:
 Demux ; SFunction ;Chart;Function-Call Subsystem;In;Out;Pulse Generator;Scope;Sine Wave;SubSystem;Unit Delay;Variant Subsystem;activate();f;help;out;u


MODELNAME: slexVariantSubsystemMaskIconPromotion
PATH: examples/simulink_variants/main/slexVariantSubsystemMaskIconPromotion.slx
BLOCK: In;Out;SubSystem;Subsystem;VSS ;help
BLOCKTYPE: Inport;Outport
BLOCKTYPE_FREQUENCY: 16;16
CHECKSUM: AB5FFAB249896E0E6F4402476F220FCB
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
 This example shows how the mask icon of active choice is automatically promoted to the Variant Subsystem in these scenarios: * VSS 1 - When the active choice has some text as its mask icon. * VSS 2 - When the active choice has a plot as its mask icon. * VSS 3 - When the active choice has an inbuilt icon on it. * VSS 4 - When the active choice has an image as its mask icon. In all the above cases, the active Subsystem choice block has a mask while the Variant Subsystem block does not have a mask.  help  Variant Subsystem - Automatic mask icon promotion Copyright 2020-2022 The MathWorks, Inc.


MODELNAME: slexVariantSubsystemUsingMaskAndEnums
PATH: examples/simulink_variants/main/slexVariantSubsystemUsingMaskAndEnums.slx
BLOCK: Display;Engine;Info;Out;Reference;SubSystem;Throttle
BLOCKTYPE: Constant;Display;Outport
BLOCKTYPE_FREQUENCY: 1;1;1
CHECKSUM: 02054D4AE97D3E42EB8FD36E329A4A2E
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This demo model explains how to use masks to control variants by incorporating libraries and promoted parameters along with enumerations to make the variant control expressions more readable. EngineLibrary The EngineLibrary contains a Variant Subsystem. This Variant Subsystem contains two choices: 1. Turbo Engine 2. Non Turbo Engine The Engine block has a mask parameter to select the active choice. Based on the active choice selected the second parameter on the Engine block mask dialog gives options to choose the fidelity of the engine. This is achieved through the parameter callback script engineParamCallBack.m TurboEngineLIbrary The TurboEngineLibrary contains a Variant Subsystem that contains the choices: 1. Low 2. Medium 3. High These choices are activated based on the mask parameter EngineFidelity. This parameter is promoted on to the EngineLibary block. NonTurboEngineLIbrary The NonTurboEngineLibrary contains a Variant Subsystem that contains the choices: 1. Low 2. High These choices are activated based on the mask parameter EngineFidelity. This parameter is promoted on to the EngineLibary block. The Variant Subsystems use Enums for better readability of the variant control expressions used.  Copyright 2020 The MathWorks, Inc.


MODELNAME: slexVariantSubsystems
PATH: examples/simulink_variants/main/slexVariantSubsystems.slx
BLOCKTYPE: DiscreteTransferFcn;Inport;Lookup_n-D;Outport;Scope;Sin;Sum
BLOCKTYPE_FREQUENCY: 1;9;1;4;1;3;2
CHECKSUM: 7337D2C849701501B181AC2E5A1C45D4
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2009-2013 The MathWorks, Inc. This model illustrates Simulink variant subsystems. Variant subsystems let you provide multiple implementations for a subsystem where only one implementation is active during simulation. You can programmatically swap out the active implementation and replace it with one of the other implementations without modifying the model. Variant Subsystems Copyright 2010-2013 The MathWorks, Inc. Variant Subsystems

BLOCK:
1-D Lookup Table;Add;Controller;Discrete Transfer Fcn;Linear Controller;More Info;Nonlinear Controller;Out;Scope;SubSystem;sensor;sine


MODELNAME: slexVariantSubsystemsAdaptiveInterface
PATH: examples/simulink_variants/main/slexVariantSubsystemsAdaptiveInterface.slx
DESCRIPTION: Code Variants Using Subsystems
BLOCKTYPE: DiscreteTransferFcn;Gain;HitCross;Inport;Logic;Lookup_n-D;Outport;Saturate;Sum;Terminator
BLOCKTYPE_FREQUENCY: 3;2;2;12;1;1;6;1;2;1
CHECKSUM: 62F1FA896F6610687DD1E866B8479DE9
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 This model illustrates the adaptive interface capability of Variant Subsystems. The Controller block is a Variant Subsystem that contains a Linear choice and a Nonlinear choice. One of the choices is active during simulation and the other is not part of the simulation. The &quot;File -&gt; Model Properties Callback -&gt; PostLoadFcn&quot;, defines the variant control variable, V, as a Simulink.Parameter. The Linear choice is active when V == 1 and the Nonlinear choice of the Controller is active when V == 2. To change the value of the variant control variable, you can type in MATLAB &gt;&gt; V.Value = int32(1) or &gt;&gt; V.Value = int32(2) When you open (double click) the Controller block, you will notice that the Linear choice of the Controller is using the sensor1 and the sensor3 inputs of the Variant Subsystem and is not using the sensor2 input. Similarly, the Linear choice is not producing a saturate output. On the Controller (Variant Subsystem) parameter dialog, which you can open by right-clicking the variant badge in the lower corner of the Controller block, you will see the [x] Propagate conditions outside of variant subsystem parameter selected. By selecting this parameter, we have instructed Simulink to adapt the interface of the Variant Subsystem to the connected blocks. In this example, we see that when we update diagram and then bring up the &quot;Display -&gt; Blocks -&gt; Variant Condition Legend&quot; that condition V == 2 has been propagated to the In2, filter, and Log saturation blocks. This is because the Linear choice of the Controller blocks is not using the sensor2 input and is not writing to the saturate output of the Controller block. Generate Preprocessor Conditionals and the propagation of variant conditions outside of the Variant Subsystem block On the Controller block dialog, youll also see the parameter, [x] Variant activation time When this parameter is set to &quot;update diagram analyze all choices&quot; or &quot;code compile&quot;, Simulink uses all variant choices in deciding what conditions to propagate out of the Variant Subsystem. When this parameter is set to &quot;update diagram&quot;, Simulink uses only the active choice in deciding conditions to propagate out of the Variant Subsystem. If you set the Variant activation time parameter to &quot;update diagram&quot;, the decision on whether to propagate conditions outside of the Controller Variant Subsystem is dependent on the active variant Nonlinear block choice only. For example, if you set V.Value == 1 in the base workspace, update diagram, then you will see that the filter and saturation logger blocks will be assigned the condition V==2 which means that they will be removed from simulation. If you then set &gt;&gt; V.Value = int32(2) and update diagram, youll see the filter and saturation logger blocks are unconditional because the Nonlinear choice of the Controller block is active and it is using all the input and output signals.  Place holder subsystem to be replaced with logic that logs the saturated output  Adaptive Interfaces for Variant Subsystems Copyright 2016 The MathWorks, Inc.  help

BLOCK:
Controller;Discrete Transfer Fcn;Gain;Hit Crossing;In;Linear;Logical Operator;Lookup Table;Nonlinear;Saturation;SubSystem;Sum;Terminator;filter;help;saturate;saturation logger;sensor;u


MODELNAME: slexVariantSubsystemsWithParSim
PATH: examples/simulink_variants/main/slexVariantSubsystemsWithParSim.slx
BLOCKTYPE: DiscreteTransferFcn;Inport;Lookup_n-D;Outport;Scope;Sin;Sum
BLOCKTYPE_FREQUENCY: 1;9;1;4;1;3;2
CHECKSUM: 0B8DA6E4494ECE6F9C1A15CA4CE501E4
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Copyright 2009-2021 The MathWorks, Inc.  This example illustrates how Variant Subsystem with startup activation can be simulated using parsim. Open slexVariantSubsystemsWithParSim_script.m to run each steps. Step 1 % setup the active variant selection for each variant choice % and set the number of simulation run equal to the variant selections mdl = slexVariantSubsystemsWithParSim; numSims = 2; varControl = [1,2]; Step 2 % create the SimulationInput object for each simulation run % and set the Variant Control value for each run in(1:numSims) = Simulink.SimulationInput(mdl); for idx = 1:numSims in(idx) = in(idx).setModelParameter(SimulationMode, rapid, ... RapidAcceleratorUpToDateCheck, on, ... SaveTime, on, ... SaveOutput, on); in(idx) = in(idx).setVariable(VSS_MODE,varControl(idx)); end Step 3 % Using parsim Simulate the model in parallel for each variant control value out = parsim(in, ShowProgress, on); Step 4 % Now plot the output values each run for i = 1:numSims simOut = out(i); t = simOut.tout; y = simOut.yout; plot(t, y) hold all end  Copyright 2021 The MathWorks, Inc.  Variant Subsystems with parsim  help

BLOCK:
1-D Lookup Table;Add;Controller;Discrete Transfer Fcn;Linear Controller;Nonlinear Controller;Out;Scope;SubSystem;help;sensor;sine


MODELNAME: slexVariantSymbolicDims
PATH: examples/simulink_variants/main/slexVariantSymbolicDims.slx
BLOCK: ActivateVariant;Constant;Display;Out;SubSystem;Subsystem;Variant Subsystem;help
BLOCKTYPE: Constant;Display;Outport
BLOCKTYPE_FREQUENCY: 2;1;4
CHECKSUM: 4F9305A1B2A1F11276DF05F9F47BB574
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
1) Only subsystems can be added as variant choices at this level 2) Blocks cannot be connected at this level as connectivity is automatically determined at simulation, based on the active variant  This example model shows how to simulate and generate code from variant subsystems when it contains symbolic dimensions which vary based on variant controls. Symbolic dimension ‘A’ is specified for outport block ‘Out1’ , which has ‘ImportedDefine’ storage class with header file specified as ‘slexVariantSymbolicDims_variant_defines.h’. The variant control ‘Var’ used in Variant choice blocks also have ‘ImportedDefine’ storage class with Header file ‘slexVariantSymbolicDims_variant_defines.h’. In the header file ‘slexVariantSymbolicDims_variant_defines.h’, we have the below setting. ifndef Var define Var 1 endif if Var == 1 define A 5 elif Var == 2 define A 6 else error &quot;Variant control variable, Var, must be defined as 1 or 2&quot; endif endif With this setting we can vary the symbolic dimension in generated code based on the VariantControl value. Additionally we need two different Simulink.Parameters P1 and P2 in variant choices which allows variant subsystem to change the dimension during simulation and code generation. The storage class for these parameters should be ImportedExtern, and it’s dimension field should be consistent with the symbolic dimension used in variant subsystem. Values of P1 and P2 has to be defined in Code Generation -&gt; Custom Code -&gt;Source file pane like this: #if Var == 1 int32_T P1[] = { 5,5,5,5,5}; #elif Var == 2 int32_T P2[] = { 6,6,6,6,6,6}; #endif This ensures that depending on the VariantControl the output size of Variant Subsystem changes. With Var= 1 we will generate output with dimension 5 and with Var=2 we will get dimension 6.   help


MODELNAME: slexVariantVnVWorkflow
PATH: examples/simulink_variants/main/slexVariantVnVWorkflow.slx
BLOCKTYPE_FREQUENCY: 7;3;1;27;1;24;5;2;1;7;4
CHECKSUM: A358DA47397B27DE76ABA382DD69C081
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Test;Stateflow
PRODUCT_BASECODE: SL
ANNOTATION:
 This model illustrates how Verification and Validation activites are done on Variant models. Simulink Design Verifier and Simulink Test toolboxes are used to demonstrate these steps. In this example, ComputeTargetSpeed_Config1 and ComputeTargetSpeed_Config2 are two variant choices in the model. Perform the following steps to do Verification and Validation activities for these two choices: Using Simulink Design Verifier on the model containing Variants: To generate test cases SLDV analyzes a model to detect design errors, identify hidden errors such as integer overflow, dead logic or division by zero. It also generates test inputs to achieve model coverage. Currently, SLDV performs only the analysis of active variant choice. The other inactive choices are not considered. Perform the following steps to analyze all the variant choice(s) present in the model. This allows you to automate the following steps either by creating a MATLAB script or by creating a pushback button in the model. Following lines of code can be written in the &quot;OpenFcn&quot; Callback of Block Properties. Set SLDV Option(s) which are required for Test Generation, Design Error Detection or Property Proving modelName = model_name; %Model Name for which SLDV Analysis needs to be done opts = sldvoptions(modelName); %Create object to set sldvoptions opts.SaveReport = on; %Save SLDV generated report opts.MakeOutputFilesUnique = on; %To avoid overwrite of SLDV report for different variants opts.Mode = TestGeneration; %Set Analysis mode to Test generation b. Set the Variant choice for which tests need to be generated. Here the tests are generated for &quot;ComputeTargetSpeed_Config1&quot;, which is associated with variant choice parameter &quot;speedConfig&quot; and has a value of 1. assignin(base,speedConfig,1); %Set the variant choice in the base workspace opts.ReportFileName = ([modelName report_speedConfig1]); %Set SLDV report file name to the variant choice for which tests needs to be generated disp([newline Performing SLDV Run for Model modelName with variant choice : SpeedConfig 1]); %To track the execution progress from MATLAB command prompt set_param(modelName, SimulationCommand, Update); % Call model update command, to activate the selected choice, as the variant regions are computed by Simulink when you run &quot;Simulation -&gt; Update Diagram&quot; [status,fileNames] = sldvrun(modelName, opts, true); % Launch SLDV with UI enabled c. Set the Variant choice for which tests need to be generated. Here the tests are generated for &quot;ComputeTargetSpeed_Config2&quot;, which is associated with variant choice parameter &quot;speedConfig&quot; and has a value of 2. assignin(base,speedConfig,2); %Set the variant choice in the base workspace opts.ReportFileName = ([modelName report_speedConfig2]); %Set SLDV report file name to the variant choice for which tests needs to be generated disp([newline Performing SLDV Run for Model modelName with variant choice : SpeedConfig 2]); %To track the execution progress from MATLAB command prompt set_param(modelName, SimulationCommand, Update); % Call model update command, to activate the selected choice, as the variant regions are computed by Simulink when you run &quot;Simulation -&gt; Update Diagram&quot; [status1,fileNames1] = sldvrun(modelName, opts, true); % Launch SLDV with UI enabled d. assignin(base,speedConfig,1); %Revert back the model to initially selected variant set_param(modelName, SimulationCommand, Update); e. (Optional) If test generation is successful for all choices display the status. if status &amp; status1 disp(SLDV test generation completed !!); end 2. Using Simulink Test on the model containing variants: To execute user-defined tests Simulink Test™ provides a platform for authoring, managing, and executing systematic, simulation-based tests of models, generated code, and simulated or physical hardware. The Test Manager is used for managing and executing user-defined tests. Currently, it performs the analysis of active variant choice. Perform the following steps to analyze all the variant choice(s) present in the model using Simulink Test: a. Create harness with the required test case, select the harness model in Simulink Test Manager. b. Select the required variant parameter from the base workspace, include in “Parameter Override” section and toggle the values of this variable in other test cases to verify the variant subsystems. c. In the demo model, click the “Open Simulink Test Manager” button, this would bring up the SL Test UI, run the test cases. d. In the test suite “CruiseControl_SpeedConfig_1”, 1st variant is made as active and in the “CruiseControl_SpeedConfig_2”, 2nd variant is made as active.  Access V&V Workflows This button, will invoke SLDV and would generate test cases on different variant subsystems present in this model.  This button, will launch the Simulink Test Manager (STM) Window. The Test Manager consists of various functional test cases. The variant choices are selected in the Parameters section of the STM.(To run the tests, double click on Run Tests from STM button in the Harness model or directly run the test suites through Test Manager).  V&amp;V workflow on Variant Subsystems with code compile activation time  help This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
 Demux ; SFunction ; Terminator ; engaged; tspeed;AccelResSw;AccelResSw ;Brake;Brake ;CoastSetSw;CoastSetSw ;ComputeTargetSpeed;ComputeTargetSpeed_Config;CruiseControl;CruiseOnOff;CruiseOnOff ;Data_Conversion_;Demux;FromWs;Harness Inputs;In_;Input Conversion Subsystem;Out_;Output Conversion Subsystem;Rate_Transition_;SigSpec_;Speed;Speed ;SubSystem;Terminator;engaged;help;slTestMgrOpen;slTestRun;sldvRun;tspeed

BLOCKTYPE:
DataTypeConversion;Demux;FromWorkspace;Inport;ModelReference;Outport;RateTransition;S-Function;Sigbuilder block;SignalSpecification;Terminator


MODELNAME: slexVariantWiper
PATH: examples/simulink_variants/main/slexVariantWiper.slx
BLOCKTYPE_FREQUENCY: 1;1;2;1;1;8;10;3;1;4;1;1;1;1;6
CHECKSUM: 57F4EFF916FAE813522FFDCFA4053A47
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
Replace the SineWave1 with an A/D block from your target support package or you can use a custom s-function to read the sensor Place holder - replace with a true D/A In codegen (2nd input to Variant Source), replace Sine Wave1 with your A/D sensor block from a target support package or a custom S-function. In codegen (2nd input to Variant Source), replace Sine Wave1 with your A/D sensor block from a target support package or a custom S-function. In codegen (2nd input to Variant Source), replace Sine Wave1 with your A/D sensor block from a target support package or a custom S-function.  This illustrates usage of Variant Source and Variant Sink blocks in a car windshield skelton model. The model can be operated in one of two modes, &quot;simulation&quot;, or &quot;codegen&quot; which is changed by double-clicking the Mode block. In simulation mode, the wiper motor plant block is used to form a closed loop simulation. In codegen mode, when you generate code, you will see the wiper motor block is inactive and the A/D and D/A skeleton blocks are used. The Mode block is a masked empty subsystem with an OpenFcn, which updates the value of the VSimCodegenMode variant control variable when you double click the block icon. This model has variant control variable, R, is used to vary the model targeting a hypothetical car which has a manual wiper or other cars which have rain sensors to automatically control the windshield wipers. When R is 0 (or any value other than 1 or 2), the Manual Wiper Setting is used as the control set point. When R is 1, the Rain Sensor Model 1 block is used to sense the amount of rain on the wind shield. Similarly, when R is 2, Rain Sensor Model 2 block is used.  Car wiper motor skelton illustrating use of Variant Source and Sink blocks Copyright 2016 The MathWorks, Inc.  help

BLOCK:
A/D;Compute Desired speed;Control Logic;Controller;D/A;Demux;F;Filtered Sensor;FromWs;In;Mode;Out;Pulse Generator;Rain Sensor Variant Source;Scope;Signal ;Signal Builder;Sine Wave;SubSystem;Subsystem;Sum;Terminator;Transfer Fcn;Variant Sink controlled by mode;Variant Source controlled by mode;Vendor;desired speed;filtered rain sensor;help;manual desired speed;s;u;wiper motor;wiper speed;y

BLOCKTYPE:
Demux;DiscreteFilter;DiscretePulseGenerator;DiscreteTransferFcn;FromWorkspace;Inport;Outport;Scope;Sigbuilder block;Sin;Sum;Terminator;TransferFcn;VariantSink;VariantSource


MODELNAME: slexVariantsWithMaskParametersInStartup
PATH: examples/simulink_variants/main/slexVariantsWithMaskParametersInStartup.slx
BLOCKTYPE: Constant;From;Goto;Outport;Scope;SignalEditor;VariantSource
BLOCKTYPE_FREQUENCY: 1;6;2;3;2;1;1
CHECKSUM: 8E02CF22F48A7CEAE4B7986230A99C0F
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
 This example shows how to use mask paramers to control structural variations in a model. In this model we have two instances of a Variant Subsystem with a mask. The variant control variable of the Variant Subystem is defined as a mask parameter. In this example we have used the popup widget from the mask editor is used as the variant conrol parameter. The values of the popup widget are populated using the Enum InputType, which is available on path. Each instance of the Variant Subsystem can select the active choice from the popup dialog. The Variant subsystem block, Controller, contains two choices Sensors Connected and Driver Switch with conditions CTRL_MODE==InputType.Sensor and CTRL_MODE== InputType.Driver, respectively. When you choose Driver Switch as the active choice, the LightCommand output is a delayed DriverSwitch signal. This is the equivalent action of the driver manually switching on or off the fog light. When you choose Sensors Connected as the active choice, the LightCommand output is high until the SensorOutput is high, independent of the Driver Switch signal. This is equivalent to sensors overriding the manual switching based on the light available. This demo contains two instances of the fog light controller. One instance of the Fog Light Controller uses the InputType.Sensor variant and the other instance uses the InputType.Driver variant. Simulation of this fog light controller is illustrated in this example. You can set the instance parameter values of the model reference block by opening the block parameter dialog of either the Model or the Model1 blocks in this demo. In the block parameter dialog, go to the Instance parameters tab and change the value of the CTRL_MODE and simulate the model in fast restart; then generate code with Simulink Coder or Embedded Coder. The generated code will contain regular If conditions.   Mask Parameters as variant controls for Variant Subsystem with startup activation Copyright 2023 The MathWorks, Inc.

BLOCK:
Build ERT;Build GRT;Constant;Controller;From;Goto;Help;LightCommandInst;Out;ReadFromHardWare;Reference;Scope;Signal Editor;SubSystem;Variant Source


MODELNAME: slexVariantsWithModelArguments
PATH: examples/simulink_variants/main/slexVariantsWithModelArguments.slx
BLOCKTYPE: Constant;From;Goto;ModelReference;Outport;Scope;SignalEditor;VariantSource
BLOCKTYPE_FREQUENCY: 1;6;2;2;3;2;1;1
CHECKSUM: E3B681F9F45F57745463252EB42CBCE9
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
EXTERNALFILE_REFERENCE: FogLightController.slx___Model_Block___
ANNOTATION:
 This example shows how to use model arguments to control structural variations in a model. In this model we have two instances of a referenced model, which contains the Variant Subsystem. The Variant Subsystem has variant control variable defined in the model workspace of the referenced model. This model workspace variable is marked as a Model Argument. The model arguments are used as controls for the Variant Subsystem blocks with startup activation time. The Variant Subsystem block represents structural variation in the model. The Variant subsystem block, Controller, contains two choices Sensors Connected and Driver Switch with conditions CTRL_MODE==InputType.Sensor and CTRL_MODE== InputType.Driver, respectively. When you choose Driver Switch as the active choice, the LightCommand output is a delayed DriverSwitch signal. This is the equivalent action of the driver manually switching on or off the fog light. When you choose Sensors Connected as the active choice, the LightCommand output is high until the SensorOutput is high, independent of the Driver Switch signal. This is equivalent to sensors overriding the manual switching based on the light available. This demo contains two instances of the fog light controller. One instance of the Fog Light Controller uses the InputType.Sensor variant and the other instance uses the InputType.Driver variant. Simulation of this fog light controller is illustrated in this example. You can set the instance parameter values of the model reference block by opening the block parameter dialog of either the Model or the Model1 blocks in this demo. In the block parameter dialog, go to the Instance parameters tab and change the value of the CTRL_MODE and simulate the model in fast restart; then generate code with Simulink Coder or Embedded Coder. The generated code will contain regular If conditions.   Model arguments as variant controls for Variant Subsystem with Startup activation Copyright 2023 The MathWorks, Inc.

BLOCK:
Build ERT;Build GRT;Constant;From;Goto;Help;LightCommandInst;Model;Out;ReadFromHardWare;Reference;Scope;Signal Editor;SubSystem;Variant Source


MODELNAME: slexVariantsWithStartup
PATH: examples/simulink_variants/main/slexVariantsWithStartup.slx
BLOCKTYPE_FREQUENCY: 3;2;4;3;5;1;1;9;2;2;1;1;1;1
CHECKSUM: 212D0BF43950793C3D7FF6A860279E4E
PRODUCT: MATLAB;Simulink;Simulink Documentation
PRODUCT_BASECODE: SL
ANNOTATION:
 This example shows how to use Variant Subsystem blocks and Simulink.VariantVariable objects with startup activation time during simulation and code generation workflow in a model. The Variant Subsystem block represents structural variation and the Simulink.VariantVariable represents parameter variation in the model. The Variant subsystem block, Controller, contains two choices Sensors Connected and Driver Switch with conditions CTRL_MODE==1 and CTRL_MODE== 2, respectively. When you choose Driver Switch as the active choice, the LightCommand output is a delayed DriverSwitch signal. This is the equivalent action of the driver manually switching on or off the fog light. When you choose Sensors Connected as the active choice, the LightCommand output is high until the SensorOutput is high, independent of the Driver Switch signal. This is equivalent to sensors overriding the manual switching based on the light available. The Sensors Connected subsystem has a 1-D Lookup Table (LUT) block that maps the SensorOutput based on the input sensorVoltage. The LUT blocks Table data parameter lightVolt, is a Simulink.VariantVariable whose values vary based on the Simulink.VariantControl LIGHT_TYPE. When you choose Sensors Connected as the active choice, the LightCommand and SensorOutput high values vary based on whether LIGHT_TYPE is Type1 or Type2. The value of LIGHT_TYPE is set to an enumeration. Simulation of this fog light controller is illustrated in this example. You can set CTRL_MODE to 1 or 2 and LIGHT_TYPE to either Type1 or Type2 and simulate the model in fast restart; then generate code with Simulink Coder or Embedded Coder. The generated code will contain regular If conditions. You can externally change the value of CTRL_MODE and LIGHT_TYPE through custom code hook as illustrated in this example. The custom code section in configset uses ReadLightControllerValues.c, which has the below content. #include &quot;rtwtypes.h&quot;#include &quot;LightType.h&quot; extern int32_T CTRL_MODE; extern LightType LIGHT_TYPE; void ReadValueOfVariantControls(void) { // The values of CTRL_MODE, LIGHT_TYPE can be read from a sensor or hardware // for simplicity it is hardcoded. CTRL_MODE = 1; LIGHT_TYPE = Type2; } In Custom code -&gt; model initialize function, you can call this function to set the values of CTRL_MODE and LIGHT_TYPE.   Variant Subsystem and Variant Parameters with startup activation  help Copyright 2021-2022 The MathWorks, Inc.

BLOCK:
1-D Lookup Table;Build ERT;Build GRT;Constant;Controller;Delay;Driver Switch;DriverSwitch;From;Goto;LightCommand;Logical Operator;Out;OverVolt;ReadFromHardWare;Reference;Scope;SensorFault;SensorOutput;Sensors Connected;Signal Editor;SubSystem;Switch;System Initialize;UnderVolt;Variant Source;help;sensorVoltage

BLOCKTYPE:
Constant;Delay;From;Goto;Inport;Logic;Lookup_n-D;Outport;RelationalOperator;Scope;SignalEditor;Switch;System Initialize;VariantSource


MODELNAME: slex_netvariant
PATH: examples/simulink_variants/main/slex_netvariant.slx
BLOCK: Constant;Delay;Input;Scope;SubSystem;Subsystem;Variant Source
BLOCKTYPE: Constant;Delay;Inport;Scope;VariantSource
BLOCKTYPE_FREQUENCY: 1;1;1;1;2
CHECKSUM: F85C9C9DAE8F86EE4FCDF3E885F41A72
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SL
ANNOTATION:
 Variant Net Condition Copyright 2019 The MathWorks, Inc. As a result of condition propagation from two Variant blocks in this model, the net variant condition on the Subsystem block is V==1&&W===1.


MODELNAME: AsyncSubsysToRefModelConversion
PATH: examples/simulinkcoder/main/AsyncSubsysToRefModelConversion.slx
ANNOTATION: Copyright 2024 The MathWorks, Inc. ?
BLOCKTYPE_FREQUENCY: 1;1;1;1;2;1;1;1;1
CHECKSUM: 0AE667BB0D1AE4287B0F531F6CC46933
PRODUCT: MATLAB;Simulink;Simulink Coder;Simulink Coder Documentation
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Asynchronous Event Modeling via Model Inputs (VxWorks(R) OS) This model shows how to simulate and generate code for asynchronous events on a real-time multitasking system. 

BLOCK:
Async Interrupt;Constant;Count;Ground;ISR 20 Hz;Integral;Integrator;Out;Reference;SubSystem;Unprotected RT;Variant Source;f-call

BLOCKTYPE:
Constant;DiscreteIntegrator;DiscretePulseGenerator;Ground;Outport;RateTransition;TriggerPort;VariantSource;VxWorks Interrupt Block


MODELNAME: BuildInfoModel
PATH: examples/simulinkcoder/main/BuildInfoModel.slx
ANNOTATION: Copyright 1994-2023 The MathWorks, Inc. ?
BLOCK: Build ERT;Build GRT;In;Out;S-Function;Scope;Sine Wave;SubSystem;Sum
BLOCKTYPE: Inport;Outport;S-Function;Scope;Sin;Sum
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1
CHECKSUM: 377B5B6686082AC92E769CD04A3EBFC9
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Exporting Generated Files Using PackNGo and BuildInfoModel API This example shows how to use the Build Information API as well as the Post Code Generation Command parameter, PostCodeGenCommand


MODELNAME: BusStructInCode
PATH: examples/simulinkcoder/main/BusStructInCode.slx
ANNOTATION: Copyright 2023 The MathWorks, Inc. ?
BLOCKTYPE: Constant;DataStoreMemory;DataStoreWrite;Gain;Inport;Outport;PID 1dof;Product;Sum
BLOCKTYPE_FREQUENCY: 4;3;3;6;10;4;1;3;2
CHECKSUM: CE54CFFB669CF7269E333C39905733D0
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
BLOCK:
Add;Air Coeff - Bio;Air Coeff - Coal;Air Coeff - Gas;Air Flow cf/h;Biomass Calc;Biomass Flow cf/h ;Boiler Control;Coal Calc;Coal Flow cf/h;Data Store Memory;Data Store Write;Fuel Energy;Gas Calc;Gas Flow cf/h;In;Nominal Air Flow - Bio;Nominal Air Flow - Coal;Nominal Air Flow - Gas;Out;Product;Reference;SubSystem;To Actuator Positions;mmBTU/cf - Bio;mmBTU/cf - Coal;mmBTU/cf - Gas;mmBTU/hr Setpoint


MODELNAME: CAPIModel
PATH: examples/simulinkcoder/main/CAPIModel.slx
ANNOTATION: Copyright 1994-2023 The MathWorks, Inc. ?
BLOCKTYPE: Constant;Gain;Inport;LookupNDDirect;ModelReference;Outport;UnitDelay
BLOCKTYPE_FREQUENCY: 1;1;4;3;1;6;1
CHECKSUM: 0F2F9316A91FA688964BABD0F7358CC8
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
EXTERNALFILE_REFERENCE: CAPIModelRef.slx___Model_Block___
DESCRIPTION:
Target-Based Data Interface: C-API Data Definition File This model illustrates the target-based C API for interfacing signals, parameters and states in the generated code. 

BLOCK:
Build ERT;Build GRT;Constant;Delay;Gain;In;Model;Out;Reference;SubSystem;View Code Generation Interface;View Workspace;lu1d;lu2d;lu3d


MODELNAME: CStandardMathLib
PATH: examples/simulinkcoder/main/CStandardMathLib.slx
ANNOTATION: Copyright 1994-2023 The MathWorks, Inc. ?
BLOCKTYPE: Abs;Constant;Gain;Inport;Math;Outport;Rounding;Sqrt;Sum;Trigonometry
BLOCKTYPE_FREQUENCY: 2;2;2;3;2;4;2;1;3;4
CHECKSUM: D334FDE4F6A06A1E89A55EA5E412D836
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
ANSI(R) C, ISO(R) C, and ISO(R) C++ Math Library Support This model shows math library extensions provided by the Code Generation Interface option Standard math library.

BLOCK:
Abs;Build ERT;Build GRT;Constant;Gain;In;Out;Reference;SubSystem;Sum;View Code Generation Interface;cos;fix;get_hypot;magsqr;setup;sin;sincos


MODELNAME: ConditionalInput
PATH: examples/simulinkcoder/main/ConditionalInput.slx
ANNOTATION: Copyright 1994-2023 The MathWorks, Inc. ?
BLOCKTYPE: Constant;Gain;Inport;Outport;RelationalOperator;Sum;Switch
BLOCKTYPE_FREQUENCY: 4;1;1;1;2;2;2
CHECKSUM: A69F6DF2A068358288FB71C8C5FEB5A6
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Conditional Input Branch Execution This model shows conditional input branch execution performed by Simulink(R) and Simulink Coder(TM).

BLOCK:
 C; C_; G; Sum; Switch; Switch2:Path;C;C_;Relational Operator;SubSystem;Switch;Switch1:Path;input;output


MODELNAME: CounterSimCoderModel
PATH: examples/simulinkcoder/main/CounterSimCoderModel.slx
ANNOTATION: Copyright 2023 The MathWorks, Inc. ?
BLOCKTYPE: Constant;DiscreteIntegrator;Display;EventListener;Outport;StateWriter
BLOCKTYPE_FREQUENCY: 2;1;1;1;1;1
CHECKSUM: 9AEB54F468FC9DFFDC28906BF942F27E
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
BLOCK:
Constant;Counter Subsystem;Discrete-Time Integrator;Display;Event Listener;Reset Function;State Writer;SubSystem;counter_add;subsys_counter_out


MODELNAME: CustomCode
PATH: examples/simulinkcoder/main/CustomCode.slx
BLOCKTYPE_FREQUENCY: 3;1;2;1;2;1;1;1;1;1;1
CHECKSUM: 3FA9591C5883CC9FDD068C29E05ECEAC
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Integrating Legacy Code Using Custom Code Blocks This model shows the use of the Simulink(R) Coder(TM) custom code blocks and the Configuration Parameters Code Generation Custom Code page to incorporating custom code into the generated code.

ANNOTATION:
The System Outputs block declares code in the nearest parent atomic subsystem. In this case, the code will appear in the outputs of the triggered subsystem. Copyright 1994-2023 The MathWorks, Inc.  ?

BLOCK:
Amplifier;Build ERT;Build GRT;Gain;INC;In;Input;LIMIT;Model Source;Out;Output;RESET;Reference;RelOpt;SubSystem;Subsystem;Sum;Switch;System Outputs;Trigger;View Code Generation Custom Code;X

BLOCKTYPE:
Constant;Gain;Inport;Model Source;Outport;RelationalOperator;Sum;Switch;System Outputs;TriggerPort;UnitDelay


MODELNAME: DeadPathElimination
PATH: examples/simulinkcoder/main/DeadPathElimination.slx
ANNOTATION: ? Copyright 2019-2023 The MathWorks, Inc.
BLOCK: Assert;Constant;G;In;Out;Sum
BLOCKTYPE: Assertion;Constant;Gain;Inport;Outport;Sum
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1
CHECKSUM: 6410345397B31CCA9DF79CDA6AECFB09
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Dead Path Elimination This model shows how Simulink(R) and Simulink Coder(TM) remove dead paths from a model.


MODELNAME: ForEachReuse
PATH: examples/simulinkcoder/main/ForEachReuse.slx
ANNOTATION: Copyright 2009-2023 The MathWorks, Inc. ?
BLOCKTYPE: Abs;ForEach;Gain;Inport;Math;Outport;Product;Sin;Sum;UnitDelay
BLOCKTYPE_FREQUENCY: 3;5;3;5;7;10;3;5;5;5
CHECKSUM: 8A55F805AA76BEBC56510A83D1B106F7
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Reusing Functions with Different Input Sizes In this example we illustrate the code reuse that happens when different For Each Subsystems containing identically connected components are fed with signals of different size. 

BLOCK:
Abs;For Each;Gain;In;Math Function;Matrix SS;Out;Product;Sine Wave;SubSystem;Sum;Unit Delay;Vector SS


MODELNAME: ForLoopConstruct
PATH: examples/simulinkcoder/main/ForLoopConstruct.slx
ANNOTATION: Copyright 1994-2023 The MathWorks, Inc. ?
BLOCK: Demux ; SFunction ; Terminator ;Accum;Delay;G;In;Out;SubSystem;Sum;Switch;u;y
BLOCKTYPE: Demux;Gain;Inport;Outport;S-Function;Sum;Switch;Terminator;UnitDelay
BLOCKTYPE_FREQUENCY: 1;2;2;2;1;2;1;1;1
CHECKSUM: 05F5C912C317A50B9C3F5E5822F44541
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
For-Loop Fusion This model shows how Simulink(R) Coder(TM) optimizes for-loops by combining multiple blocks into the same for-loop, improving code efficiency and readability.


MODELNAME: InitialStructBusObject
PATH: examples/simulinkcoder/main/InitialStructBusObject.slx
ANNOTATION: Copyright 2015-2023 The MathWorks, Inc. ?
BLOCKTYPE: Bias;BusCreator;BusSelector;Inport;Logic;Lookup_n-D;Outport;RelationalOperator;Saturate;UnitDelay
BLOCKTYPE_FREQUENCY: 3;1;3;4;2;2;5;2;2;1
CHECKSUM: F828106B522A1B39466DF302DD1356B5
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
This example shows how to control the data types of a tunable initial condition structure by applying using a bus type as the data type for the entire structure.

BLOCK:
1-D Lookup Table;Bus Creator;Bus Selector;DataIn;In;Intlk Cmd;Intlk Logic;Intlk Logic Delayed;IntlkDly Cmd;Logical Operator;Out;Preproc;Relational Operator;Saturation;SubSystem;Unit Delay;flowOffset;tmpOffset


MODELNAME: InvariantSignalsInline
PATH: examples/simulinkcoder/main/InvariantSignalsInline.slx
DESCRIPTION: This example shows how inline invariant signals can be used to optimize the generated code.
ANNOTATION: Copyright 2014-2023 The MathWorks, Inc. ?
BLOCKTYPE: Abs;Constant;DataTypeConversion;Gain;Inport;MinMax;Outport;Product;Sin;Sum
BLOCKTYPE_FREQUENCY: 4;4;1;4;5;1;6;1;1;5
CHECKSUM: C4E1374C3CB78A11B61C1E6E4B2CE6B9
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
BLOCK:
Abs;Constant;Data Type Conversion;Gain;In;InlinedConstFcn;MinMax;Out;Product;Sine Wave;SubSystem;Subsystem;Sum


MODELNAME: LctExternalCodeImportGain
PATH: examples/simulinkcoder/main/LctExternalCodeImportGain.slx
DESCRIPTION: Return Arguments
ANNOTATION: Copyright 1990-2023 The MathWorks, Inc. ?
BLOCKTYPE_FREQUENCY: 2;1;1;1;1;2;3;2;1;1;1;1
CHECKSUM: 4C28ADB4C4623FAE48CDCF8A29C8A816
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
BLOCK:
Build ERT;Build GRT;Constant;Data Type Conversion;Gain;In;Out;Reference;Scope;SubSystem;Sum;Switch;TestGain;Unit Delay;counter limited;sfun_gain_scalar

BLOCKTYPE:
Constant;CounterLimited;DataTypeConversion;Gain;Inport;Legacy Function;Outport;S-Function;Scope;Sum;Switch;UnitDelay


MODELNAME: LctFixedParams
PATH: examples/simulinkcoder/main/LctFixedParams.slx
DESCRIPTION: Fixed Point Parameters
BLOCK: Build ERT;Constant;In;Mux;Out;Reference;Scope;SubSystem;TestFixpt;sfun_gain_fixpt
BLOCKTYPE: Constant;Inport;Legacy Function;Mux;Outport;S-Function;Scope
BLOCKTYPE_FREQUENCY: 1;1;4;1;2;4;1
CHECKSUM: 564152CEC3B3475E3BE59F5AFA387E78
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
ANNOTATION:
Inlined parameters (InlineParameters ON + Auto storage class) ==> numeric value inlined Tunable parameter with myFixpt data type specification ==> parameter is not cast Double-precision (context-sensitive) parameters ==> tunable parameter inherits data type from run-time parameter Tunable parameter with explicit data type specification (uint8) ==> parameter is cast to run-time parameter data type Copyright 1990-2023 The MathWorks, Inc.  ?


MODELNAME: LctInheritedDimensions
PATH: examples/simulinkcoder/main/LctInheritedDimensions.slx
DESCRIPTION: Inherited Signal Dimensions
BLOCKTYPE: Constant;DataTypeConversion;Demux;Inport;Legacy Function;Outport;Probe;S-Function
BLOCKTYPE_FREQUENCY: 3;1;1;3;2;4;1;2
CHECKSUM: 657FDEE6E03F37E05F71B421E0C62F3C
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
ANNOTATION:
Input/output matrix dimensions are related to parameter values. \downarrow \uparrow Input matrices dynamically sized. Output matrix dimensions are related to dimensions of input matrices. Copyright 1990-2023 The MathWorks, Inc.  ?

BLOCK:
Build ERT;Build GRT;Constant;Data Type Conversion;Demux;In;Out;Probe;Reference;SubSystem;TestMatOps;sfun_mat_add;sfun_mat_mult


MODELNAME: LctInstanceSpecificMemory
PATH: examples/simulinkcoder/main/LctInstanceSpecificMemory.slx
ANNOTATION: Copyright 1994-2023 The MathWorks, Inc. ?
BLOCKTYPE_FREQUENCY: 3;1;1;2;1;1;1;1;1;1;1
CHECKSUM: A488C0B75FD751D10E2930E58A45D46A
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
This model calls a legacy C function via an S-function generated by the Legacy Code Tool. The function call uses instance-specific persistent memory.

BLOCK:
Build ERT;Build GRT;Bus Selector;Bus to Vector;COUNTERBUSCreator;In;LIMITBUSCreator;Out;Pulse Generator;Reference;SIGNALBUSCreator;ScopeA;Signal Conversion;SubSystem;lower_ saturation_ limit;memory_bus;sfun_work;upper_saturation_limit

BLOCKTYPE:
BusCreator;BusSelector;BusToVector;Constant;DiscretePulseGenerator;Inport;Legacy Function;Outport;S-Function;Scope;SignalConversion


MODELNAME: LctMultiDimensionalSig
PATH: examples/simulinkcoder/main/LctMultiDimensionalSig.slx
ANNOTATION: Copyright 1994-2023 The MathWorks, Inc. ?
BLOCK: Build ERT;Build GRT;Constant;In;Out;Reference;SubSystem;ndarray_add;rtwdemo_sfun_ndarray_add
BLOCKTYPE: Constant;Inport;Legacy Function;Outport;S-Function
BLOCKTYPE_FREQUENCY: 2;2;1;2;1
CHECKSUM: 41B91B1011654A2180137BE73D505F8E
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
This model calls a legacy C function via an S-function generated by the Legacy Code Tool. The function call uses multi-dimensional signals.


MODELNAME: LctSampleTime
PATH: examples/simulinkcoder/main/LctSampleTime.slx
BLOCKTYPE: Constant;Inport;Legacy Function;Outport;Probe;S-Function
BLOCKTYPE_FREQUENCY: 3;3;3;6;3;3
CHECKSUM: ECF2C70557D1B0207C857004EF2C9E63
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
This model calls legacy C functions via S-functions generated by the Legacy Code Tool. One function call inherits the sample time from the input signal, one function call specifies a fixed sample time, and one function call uses a parametrized sample time.

ANNOTATION:
Block sample time inherited from input signal sample time. Block sample time specified as parameter. Can change in the mask dialog. Block sample time is fixed: [2 1].  Copyright 1994-2023 The MathWorks, Inc.  ?

BLOCK:
Build ERT;Build GRT;Constant;In;Out;Probe;Reference;SubSystem;sample_time;sfun_st_fixed;sfun_st_inherited;sfun_st_parameterized


MODELNAME: LctStartTermActions
PATH: examples/simulinkcoder/main/LctStartTermActions.slx
DESCRIPTION: Start and Terminate Actions
ANNOTATION: Copyright 1990-2023 The MathWorks, Inc. ?
BLOCKTYPE_FREQUENCY: 4;1;1;1;1;1;1;4;1;1;1;2;1;2
CHECKSUM: 7623D885C879E434E926948B9352CBA8
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
BLOCK:
Build ERT;Build GRT;Constant;Data Type Conversion;Digital Clock;Enable;In;Out;Reference;Relational Operator;Scope;SubSystem;Sum;Switch;TestFault;Triggered Subsystem;Unit Delay;counter limited;sfun_fault

BLOCKTYPE:
Constant;CounterLimited;DataTypeConversion;DigitalClock;EnablePort;Inport;Legacy Function;Outport;RelationalOperator;S-Function;Scope;Sum;Switch;UnitDelay


MODELNAME: LctStructureArguments
PATH: examples/simulinkcoder/main/LctStructureArguments.slx
DESCRIPTION: Structure Arguments Using Buses
BLOCKTYPE_FREQUENCY: 5;2;2;2;1;1;5;3;2;1;1;2;2;1;2;2;1;2;1
CHECKSUM: EA49A1E2C15BC505E3027BA243BF067B
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
ANNOTATION:
\leftarrow call the legacy function via the S-Function \leftarrow call the Simulink version Copyright 1994-2023 The MathWorks, Inc.  ?

BLOCK:
 input; input GE lower; limit;Add;And;Build ERT;Build GRT;Bus Creator;Bus Selector;Bus to Vector;COUNTERBUSCreator;Delay;From;Goto;In;LIMITBUSCreator;Limits;Out;Previous Output;Pulse Generator;Reference;SIGNALBUSCreator;ScopeA;Signal Conversion;SubSystem;Switch;TestCounter;lower_ saturation_ limit;sfun_counterbus;slCounter;upper GE input;upper_saturation_limit

BLOCKTYPE:
BusCreator;BusSelector;BusToVector;Constant;Delay;DiscretePulseGenerator;From;Goto;Inport;Legacy Function;Logic;Outport;RelationalOperator;S-Function;Scope;SignalConversion;Sum;Switch;UnitDelay


MODELNAME: LctTableLookups
PATH: examples/simulinkcoder/main/LctTableLookups.slx
DESCRIPTION: Lookup Tables
BLOCKTYPE: Constant;Demux;Display;Inport;Legacy Function;LookupNDDirect;Mux;Outport;S-Function
BLOCKTYPE_FREQUENCY: 2;2;2;2;2;2;2;4;2
CHECKSUM: 0C66C511A453301D22FBBCA3BDE28503
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
ANNOTATION:
3D table \downarrow 4D table \downarrow LookUp Table are defined as: >> LUT3D = single(reshape([1:4*5*6], [4 5 6])); >> LUT4D = single(reshape([1:4*5*6*2], [4 5 6 2])) Copyright 1994-2023 The MathWorks, Inc.  ?

BLOCK:
Build ERT;Build GRT;Constant;Demux;Direct Lookup Table (n-D);Display;In;Mux;Out;Reference;SubSystem;TestLut;sfun_dlut3D;sfun_dlut4D


MODELNAME: LctValueVersusAddress
PATH: examples/simulinkcoder/main/LctValueVersusAddress.slx
BLOCKTYPE_FREQUENCY: 1;2;1;4;2;4;2;1;2;2
CHECKSUM: 24E80923477362EFFFF71903B6D536A0
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
This model calls legacy C functions via S-functions generated by the Legacy Code Tool. One function call accesses the first input by value, and the other function call accesses the first input by address.

ANNOTATION:
First input accessed by value (expression is conserved in the generated code) \downarrow First input accessed by address (expression is not conserved in the generated code) \downarrow Copyright 1990-2023 The MathWorks, Inc.  ?

BLOCK:
Band-Limited White Noise;Build ERT;Build GRT;Data Type Conversion;Out;Pulse Generator;Reference;Scope;SubSystem;Sum;TestFilter;Unit Delay;noise;sfun_filterV;sigIn;sigOut

BLOCKTYPE:
Band-Limited White Noise.;DataTypeConversion;DiscretePulseGenerator;Inport;Legacy Function;Outport;S-Function;Scope;Sum;UnitDelay


MODELNAME: ParallelBuildA1
PATH: examples/simulinkcoder/main/ParallelBuildA1.slx
ANNOTATION: Copyright 2018-2023 The MathWorks, Inc. ?
BLOCK: C;CounterA;CounterB;In;Out;Vector Concatenate
BLOCKTYPE: Concatenate;Constant;Inport;ModelReference;Outport
BLOCKTYPE_FREQUENCY: 1;2;1;3;1
CHECKSUM: 82752E7E38135281521578BC419873D1
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
File Packaging for Models (Code and Data) This model shows how to use Model Reference to provide system interface encapsulation and incremental code generation.

EXTERNALFILE_REFERENCE:
ParallelBuildB1.slx___Model_Block___ParallelBuildB2.slx___Model_Block___ParallelBuildB3.slx___Model_Block___


MODELNAME: RowLUT2D
PATH: examples/simulinkcoder/main/RowLUT2D.slx
ANNOTATION: Lookup table with interpolation on a 3x2 table Copyright 2018-2023 The MathWorks, Inc. ?
BLOCK: 2-D Lookup Table;Constant;Out
BLOCKTYPE: Constant;Lookup_n-D;Outport
BLOCKTYPE_FREQUENCY: 2;1;1
CHECKSUM: 6A71C459CC60CB1008B41846DD618E4A
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
This example shows 2-D interpolated table lookup algorithms that is optimized for row-major array layout.


MODELNAME: RowLUTColToRow
PATH: examples/simulinkcoder/main/RowLUTColToRow.slx
BLOCK: 2-D Lookup Table;Cf;Ci;Constant;Direct LUT;Interp;Out;Prelookup
BLOCKTYPE: Constant;Interpolation_n-D;LookupNDDirect;Lookup_n-D;Outport;PreLookup
BLOCKTYPE_FREQUENCY: 13;3;1;1;5;3
CHECKSUM: 5A55573D326D31D9C7AA07BFA6FFEF15
PRODUCT: MATLAB;Simulink;Simulink Coder Documentation
PRODUCT_BASECODE: EC;RT
ANNOTATION:
Interpolation on a 10x6 table Select a 10x6 plane from a 10x6x2x3 table Index search in 5 variably spaced points Index search in 10 evenly spaced points Index search in 6 evenly spaced points Interpolationon one 10x6 plane of a 10x6x5 table Interpolation on a 3x2x4 table Equivalent Lookup Table for Interpolation on a 10x6 table Copyright 2018-2023 The MathWorks, Inc.  ?


MODELNAME: SecondOrderSystem
PATH: examples/simulinkcoder/main/SecondOrderSystem.slx
ANNOTATION: ? Copyright 1994-2023 The MathWorks, Inc.
BLOCKTYPE: DashboardScope;Demux;Gain;Inport;Integrator;KnobBlock;Outport;S-Function;SignalGenerator;Terminator
BLOCKTYPE_FREQUENCY: 1;1;3;3;2;1;1;1;1;1
CHECKSUM: C3E113759D9EA5BF599989ACC3CD8C57
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
BLOCK:
 Demux ; SFunction ; Terminator ;Damping;Dashboard Scope;Force: f(t);Integrator;Knob;MATLAB Function;Mass;Stiffness;SubSystem;X


MODELNAME: SignalObjectInitialValue
PATH: examples/simulinkcoder/main/SignalObjectInitialValue.slx
ANNOTATION: IV=-2.5 IV=-4.5 IV=-3.5 IV=-3.0 IV=-2.0 Copyright 1994-2023 The MathWorks, Inc. ?
BLOCKTYPE_FREQUENCY: 1;1;1;1;1;1;2;1;1;1;1
CHECKSUM: 11899887C0F6BBEBC2D1B3DF373C8992
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Controlling the Initial Value of Signals and States Using Signal Objects This model shows how to control the initialization and reset characteristics of signals and states using the initial value property of signal objects. 

BLOCK:
Build ERT;Build GRT;Comparing Storage Classes;Data Store Memory;Data Store Read;Data Store Write;Enable;Enabled Subsystem (state X1 inside);In;Out;Pulse Generator;Reference;Scope;Signal Conversion;SubSystem;Unit Delay;Vector Concatenate;View Workspace

BLOCKTYPE:
Concatenate;DataStoreMemory;DataStoreRead;DataStoreWrite;DiscretePulseGenerator;EnablePort;Inport;Outport;Scope;SignalConversion;UnitDelay


MODELNAME: SingleRateBareBoard
PATH: examples/simulinkcoder/main/SingleRateBareBoard.slx
ANNOTATION: Copyright 1994-2023 The MathWorks, Inc. ?
BLOCK: Gain;In;In1_1s;In2_1s;Integrator;Out;SS;SubSystem;Sum
BLOCKTYPE: DiscreteIntegrator;Gain;Inport;Outport;Sum
BLOCKTYPE_FREQUENCY: 1;3;6;4;3
CHECKSUM: 237250E993D5C344E87D4140FE51AB22
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Single-Rate Modeling (Bare Board, No OS) This model shows the code generated for a single-rate discrete-time model configured for a bare-board target (one with no operating system).


MODELNAME: StartupResetShutdown
PATH: examples/simulinkcoder/main/StartupResetShutdown.slx
ANNOTATION: Copyright 2016-2023 The MathWorks, Inc. ?
BLOCKTYPE: Constant;DiscreteIntegrator;EventListener;Outport;Scope;StateReader;StateWriter;Terminator
BLOCKTYPE_FREQUENCY: 3;1;3;1;1;1;2;1
CHECKSUM: A18991D54242DB5F17431454E5768940
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Generate Code for Reset Events This model shows how to use a Reset Function block to generate code that resets the input value for a discrete integrator.

BLOCK:
Constant;Discrete Integrator;Event Listener;Initialize Function;Out;Reset Function;Scope;State Reader;State Writer;SubSystem;Terminate Function;Terminator


MODELNAME: StartupResetShutdownShared
PATH: examples/simulinkcoder/main/StartupResetShutdownShared.slx
ANNOTATION: Copyright 2016-2023 The MathWorks, Inc. ?
BLOCKTYPE: Constant;DiscreteIntegrator;EventListener;Inport;Outport;Scope;StateReader;StateWriter;Terminator
BLOCKTYPE_FREQUENCY: 5;4;6;1;3;3;2;4;2
CHECKSUM: 342166A7B6FE365FEE944E8ADAB8FA13
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Event Names and Code Aggregation This model shows how use the Initialize Function and Terminate Function blocks to define multiple initialize, reset, and terminate functions for a component hierarchy.

BLOCK:
Constant;Event Listener;In;Initialize Function;Integrator;Out;Reset Function;Scope;State Reader;State Writer;Sub Initialize Function;Sub Reset Function;SubIntegrator;SubSystem;SubTerminate Function;Subsystem;Terminate Function;Terminator


MODELNAME: SubtableInterpolationCol
PATH: examples/simulinkcoder/main/SubtableInterpolationCol.slx
BLOCK: Cs;Cu;Interp;Out;Prelookup
BLOCKTYPE: Constant;Interpolation_n-D;Outport;PreLookup
BLOCKTYPE_FREQUENCY: 3;1;1;2
CHECKSUM: 16198A52554E4607D9BEE03FC32D7371
PRODUCT: MATLAB;Simulink;Simulink Coder Documentation
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
This model shows selecting a 2-D sub-table or a plane from a 3-D table. The sub-table is then interpolated normally.

ANNOTATION:
Interpolation with sub-table selection on a 3x2x4 table Copyright 2018-2023 The MathWorks, Inc. Index search in 3 breakpoints Index search in 2 breakpoints  ?


MODELNAME: TargetSettings
PATH: examples/simulinkcoder/main/TargetSettings.slx
BLOCKTYPE: Display;Fixed-Point Target Specific;S-Function
BLOCKTYPE_FREQUENCY: 5;1;1
CHECKSUM: 10057D390BDF3B825B481E649E74D0B3
PRODUCT: MATLAB;Simulink;Simulink Coder Documentation
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Specifying Target Environment Settings This example shows how Simulink(R) allows you to specify the implementation-specific characteristics of your target system.

ANNOTATION:
If your system is not listed and you are not certain of its values, use the code generated by this model to compute the necessary C compiler and target hardware settings. If you use a cross-development system that includes a source level debugger, first configure the model for your intended target. Then generate code and build an executable using your target development system (for more details about retrieving file and path information, see the documentation on the Simulink Coder Build Information API). Download the executable to the target and set breakpoints at the model output code for each of the outports of the model. Run a debugging session and observe the behavior of the code as it executes on the target. As you step through the code the values for the various characteristics are computed. If your target development system does not support source level debugging, you may have to generate code and add printf statements or other code that enables you to obtain the results. Once youve obtained your target settings, enter them into the Hardware Implementation page via a Custom Processor device type. Copyright 1994-2023 The MathWorks, Inc.  ?

BLOCK:
0 => Little Endian 1 => Big Endian ;0 => Long Long Disabled 1 => Long Long Enabled ;0 => Shift Right on int is NOT arithmetic 1 => Shift Right on int is arithmetic ;1 => Rounds to floor 2 => Rounds to zero 3 => Rounding undefined;Bits per char, short, int, long, long long;Build ERT;Build GRT;Compute Target Specific Values;Reference;SubSystem;Subsystem;View Hardware


MODELNAME: ThrottleControl
PATH: examples/simulinkcoder/main/ThrottleControl.slx
ANNOTATION: Copyright 2007-2023 The MathWorks, Inc. ?
BLOCKTYPE: BusCreator;Constant;Demux;Inport;Outport;S-Function;Terminator
BLOCKTYPE_FREQUENCY: 1;3;1;6;5;1;1
CHECKSUM: 2BD8F3A1461144328027E1C72B065004
PRODUCT: MATLAB;Simulink;Simulink Coder Documentation;Stateflow
PRODUCT_BASECODE: EC;RT
BLOCK:
 Demux ; SFunction ; Terminator ;Bus Creator;Constant;Define_Throt_Param;PI_ctrl_;Pos_Command_Arbitration;Reference;SubSystem;ThrotComm;Throt_Param;fbk_;pos_cmd_one;pos_cmd_two;pos_rqst


MODELNAME: ThrottleControlExtFuncCall
PATH: examples/simulinkcoder/main/ThrottleControlExtFuncCall.slx
BLOCKTYPE_FREQUENCY: 1;3;1;2;4;10;4;7;4;5;2;4;1
CHECKSUM: F5493BFBA9C45E8AFA550702485A81BA
PRODUCT: MATLAB;Simulink;Simulink Coder Documentation;Stateflow
PRODUCT_BASECODE: EC;RT
ANNOTATION:
Gain Scheduled PI Controller Gain Scheduled PI Controller Copyright 2007-2023 The MathWorks, Inc.  ?

BLOCK:
 Demux ; SFunction ; Terminator ;Bus Creator;Constant;Define_Throt_Param;Discrete_Time_Integrator;Int Gain;PI_ctrl_;Pos_Command_Arbitration;Product;Prop Gain;Saturation;SimpTableWrap;SubSystem;Sum;ThrotComm;Throt_Param;fbk;fbk_;pos_cmd;pos_cmd_one;pos_cmd_two;pos_rqst;rqst

BLOCKTYPE:
BusCreator;Constant;Demux;DiscreteIntegrator;Gain;Inport;Legacy Function;Outport;Product;S-Function;Saturate;Sum;Terminator


MODELNAME: ThrottleControlTestHarness
PATH: examples/simulinkcoder/main/ThrottleControlTestHarness.slx
BLOCKTYPE_FREQUENCY: 1;3;1;1;3;7;3;7;1;8;1;7;1;2;5
CHECKSUM: 56579B9001532CAB1A126FD9E0583DA4
PRODUCT: MATLAB;Simulink;Simulink Coder Documentation
PRODUCT_BASECODE: EC;RT
EXTERNALFILE_REFERENCE: ThrottleControl___Model_Block___
ANNOTATION:
Input Signal Scaling This subsystem 1.) Selects the required signals from the test vector 2.) Creates 2 unique feedback signals based on white noise added to the feedback Both feedback siganals have white noise added The noise has a maximum of 5% of the full signal value Output Signal Scaling This subsystem selects the required signals to route to the plant model.  B0.z^2 + B1. z + B2 --------------------------- z^2 + A1.z + A2  Plant Copyright 2007-2022 The MathWorks, Inc.  ?

BLOCK:
Add;Bus Creator;Bus Selector;Data Type Conversion;From;Gain;Goto;Input_Scaling;Input_Signal_Scaling;Output_Scaling;Output_Signal_Scaling;Plant;PlantSignals;PosRequest;Reference;Signal Editor;SubSystem;Sum;Terminator;TestVectorSignals;Test_Vectors;ThrottleCMD_Act_Test;Uniform Random Number;Unit Delay;UnitUnderTestSignals;Unit_Under_Test;V_cmd;Verification;cmd;fbk_1_out;fbk_2_out;pos_cmd_act;pos_cmd_one;pos_cmd_two;pos_fbk;pos_rad;pos_rqst;sys_in

BLOCKTYPE:
BusCreator;BusSelector;Checks_SRange;DataTypeConversion;From;Gain;Goto;Inport;ModelReference;Outport;SignalEditor;Sum;Terminator;UniformRandomNumber;UnitDelay


MODELNAME: TunableInitStruct
PATH: examples/simulinkcoder/main/TunableInitStruct.slx
DESCRIPTION: This example shows how to create a tunable initial condition structure in the generated code.
ANNOTATION: Copyright 2015-2023 The MathWorks, Inc. ?
BLOCKTYPE: Bias;BusCreator;BusSelector;Inport;Logic;Lookup_n-D;Outport;RelationalOperator;Saturate;UnitDelay
BLOCKTYPE_FREQUENCY: 3;1;2;8;2;2;7;2;2;1
CHECKSUM: 11E6730196B436382CBAD21D17CFCEF8
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
BLOCK:
1-D Lookup Table;Bus Creator;Bus Selector;In;Intlk Cmd;Intlk Logic;Intlk Logic Delayed;IntlkDly Cmd;Logical Operator;Out;Preproc;Relational Operator;Saturation;SubSystem;Unit Delay;flowIn;flowOffset;posIn;thermIn;tmpOffset


MODELNAME: UnderspecifiedDataType
PATH: examples/simulinkcoder/main/UnderspecifiedDataType.slx
ANNOTATION: Copyright 2014-2023 The MathWorks, Inc. Sum ?
BLOCK: In;Multiport Switch;Out;Product;Relational Operator;Sum
BLOCKTYPE: Inport;MultiPortSwitch;Outport;Product;RelationalOperator;Sum
BLOCKTYPE_FREQUENCY: 4;1;1;1;1;1
CHECKSUM: 4FAB0AE9FD11C367DCEFE8D4F10D3A4A
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Specifying Default for underspecified data type This example shows how the Default for underspecified data type optimization option affects datatypes of variables in the generated code.


MODELNAME: laneAndVehicleDetection
PATH: examples/simulinkcoder/main/laneAndVehicleDetection.slx
ANNOTATION: Copyright 2021 The MathWorks, Inc.
BLOCKTYPE_FREQUENCY: 1;1;2;1;8;5;1;1;1;2;2;1
CHECKSUM: E9D284F36039C1E47E9072F3194B1582
PRODUCT: Computer Vision Toolbox;Deep Learning Toolbox;MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
BLOCK:
 Demux ; SFunction ; Terminator ;Annotation using Vehicle Bounding Boxes and Lane Trajectory ;Constant;In;In ;Lane Detection;Lane Trajectory from Network Output ;Lane and Vehicle Detection Output;Out;Preprocessing for Lane Detection;Product;Reference;Resize;SubSystem;Traffic Video;Vehicle Detector;bboxes;laneFound;laneNetOut;ltPts;rtPts;scores

BLOCKTYPE:
Constant;Deep Learning Object Detector;Demux;From Multimedia File;Inport;Outport;Predict;Product;Resize;S-Function;Terminator;VideoViewer


MODELNAME: rtwdemo_VectorOptimization
PATH: examples/simulinkcoder/main/rtwdemo_VectorOptimization.slx
ANNOTATION: Copyright 2014-2023 The MathWorks, Inc. ?
BLOCK: G;In;Out;Sum;X
BLOCKTYPE: Gain;Inport;Outport;Sum;UnitDelay
BLOCKTYPE_FREQUENCY: 3;1;1;3;3
CHECKSUM: CF2B18149CF296F419D3E3DBAF502EAB
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: EC;RT
DESCRIPTION:
Optimized Vector Operations This model shows how Simulink(R) Coder(TM) replaces temporary/local arrays with scalars to reduce stack memory.


MODELNAME: Aircraft_Dynamics_Model
PATH: examples/simulinkcompiler/main/Aircraft_Dynamics_Model.slx
BLOCKTYPE: Gain;Inport;Outport;Sum;TransferFcn
BLOCKTYPE_FREQUENCY: 4;3;2;2;2
CHECKSUM: 0B690E514911EE2C80793FD185850140
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SK
ANNOTATION:
Copyright 2021 The MathWorks, Inc. Simulink model Aircraft_Dynamics_Model is exported to a Standalone FMU in the example. Model variables(e.g. Uo, Mw, etc.) defined in the model workspace are exposed to FMU as tunable parameters. Generated FMU is referenced in Simulink model f14_fmu to demonstrate nested FMU export workflow.

BLOCK:
Elevator Deflection d (deg);Gain;Pitch Rate q (rad/sec);Rotary Gust qGust (rad/sec);Sum;Transfer Fcn.;Vertical Gust wGust (ft/sec);Vertical Velocity w (ft/sec)


MODELNAME: Controller
PATH: examples/simulinkcompiler/main/Controller.slx
BLOCKTYPE: Gain;Inport;Outport;Sum;TransferFcn
BLOCKTYPE_FREQUENCY: 3;3;1;3;4
CHECKSUM: FCD27E7FB3030B1F04AAB110263E2947
PRODUCT: MATLAB;Simulink;Simulink Compiler
PRODUCT_BASECODE: SK
ANNOTATION:
Copyright 2021 The MathWorks, Inc. Simulink model Controller is exported as a protected model in the example, Generated protected model is referenced in Simulink model f14_fmu to demonstrate workflow exporting a protected model to Standalone FMU. 

BLOCK:
Alpha-sensor Low-pass Filter;Elevator Command (deg);Gain;Pitch Rate Lead Filter;Proportional plus integral compensator;Stick Input (in);Stick Prefilter;Sum;alpha (rad);q (rad/sec)


MODELNAME: FMUExportWithExternalCPP
PATH: examples/simulinkcompiler/main/FMUExportWithExternalCPP.slx
BLOCK: Input;Output;S-Function Builder
BLOCKTYPE: Inport;Outport;S-Function;S-Function Builder
BLOCKTYPE_FREQUENCY: 1;1;1;1
CHECKSUM: 91AF826447991F1A32BA768BD7F511D3
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SK
ANNOTATION:
 Use S-Function builder block to import external C++ code and export the model to standalone FMU. Copyright 2021 The MathWorks, Inc.


MODELNAME: double_spring_damper
PATH: examples/simulinkcompiler/main/double_spring_damper.slx
DESCRIPTION: Double Mass-Spring-Damper in Simulink(R) and Simscape(TM)
ANNOTATION: Simulink Model Double Mass-Spring-Damper Copyright 2022 The MathWorks, Inc.
BLOCKTYPE: From;Gain;Goto;Inport;Integrator;Outport;Sum
BLOCKTYPE_FREQUENCY: 2;6;2;3;4;2;4
CHECKSUM: 439FAF2CD99836E2B48AB084779066A7
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SK
BLOCK:
1/Mass;Damping;Displacement;Goto;In;Integrator;Mass1_Velocity;Mass2_Velocity;Sensing Simulink;Simulink;Simulink ;Stiffness;SubSystem;Sum


MODELNAME: double_spring_damper_sim
PATH: examples/simulinkcompiler/main/double_spring_damper_sim.slx
BLOCKTYPE: FMU;Inport;Outport;SignalSpecification
BLOCKTYPE_FREQUENCY: 1;4;5;3
CHECKSUM: 0E30D3E2BCB7058030A24BC8FCD901A3
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SK
ANNOTATION:
This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. Copyright 2022 The MathWorks, Inc.

BLOCK:
Double Spring Damper FMU;Inport_;Input;Input Conversion Subsystem;Mass1_Velocity;Mass2_Velocity;Outport_;Output Conversion Subsystem;SigSpec_;SubSystem


MODELNAME: example_modify_parameters
PATH: examples/simulinkcompiler/main/example_modify_parameters.slx
BLOCK: Add;Constant;Digital Clock;Gain;In;Model;Out;Step;SubSystem;Subsystem;Trigger;Triggered Subsystem
BLOCKTYPE: Constant;DigitalClock;Gain;Inport;ModelReference;Outport;Step;Sum;TriggerPort
BLOCKTYPE_FREQUENCY: 1;2;3;2;1;6;1;1;1
CHECKSUM: 8A7326ACF29693DCAE4C079868FA36DA
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SK
EXTERNALFILE_REFERENCE: exRefUsingGlobalWksVars___Model_Block___
ANNOTATION:
 Types of parameter modifications we can do:1. Modify base workspace variable used in block parameters2. Modify model workspace variables used in block parameters3. Modify variables used in maks dialog parameters4. Modify variables used by parameters of different sample time blocks (constant, triggered, event-driven, etc.)


MODELNAME: f14_flight_control
PATH: examples/simulinkcompiler/main/f14_flight_control.slx
BLOCKTYPE_FREQUENCY: 1;1;2;1;6;3;1;5;1;3;1;3;3
CHECKSUM: 281BE31838EC7E48067BEE4F19B6409D
PRODUCT: MATLAB;Simulink;Simulink Compiler
PRODUCT_BASECODE: SK
EXTERNALFILE_REFERENCE: Controller.slxp___Model_Block___
ANNOTATION:
Nz pilot calculation Nz = (dq/dt*22.8 + q*Uo - dw/dt)/g Copyright 2021 The MathWorks, Inc. F-14 Flight Control Model for Nested FMU Export. Model contians a ModelRef block references to protected model Controller and a FMU Import block references to a FMU. This model can be exported as a Standalone FMU.

BLOCK:
Actuator Model;Aircraft Dynamics Model;Angle of Attack;Band-Limited White Noise;Constant;Controller;Derivative;Dryden Wind Gust Models;Gain;Input;Nz Pilot (g);Nz pilot calculation;Pilot;Pilot G force Scope;Pilot g force (g);Product;Q-gust model;Qg;Reference;Stick Input;SubSystem;Sum;W-gust model;Wg;alpha (rad);q;w

BLOCKTYPE:
Band-Limited White Noise.;Constant;Derivative;FMU;Gain;Inport;ModelReference;Outport;Product;Scope;SignalGenerator;Sum;TransferFcn


MODELNAME: fmudemo_export_fuelsys_controller
PATH: examples/simulinkcompiler/main/fmudemo_export_fuelsys_controller.slx
BLOCKTYPE_FREQUENCY: 3;2;1;8;2;2;3;1;1;1;1;24;1;5;1;1;15;1;4;2;1;1;5;1;1;1;3;1
CHECKSUM: 5A5A5D80AE6ED3EAC71260EAE67AFF8E
PRODUCT: MATLAB;Simulink;Simulink Compiler Documentation;Stateflow
PRODUCT_BASECODE: SK
ANNOTATION:
Intake Airflow Estimation and Closed-Loop Correction Feedback Control Feedforward Control MAP Estimation Speed Estimation Throttle Estimation Feedforward Fuel Rate Disabled Mode Fuel Mode Low Mode Fuel Mode Rich Mode Fuel Mode Loop Compensation and Filtering Fuel Rate Calculation The contents of this subsystem are excluded from the code Simulink Coder generates. To work correctly this system must continue to * Contain no output ports * Enable its Treat as Atomic Unit parameter * Specify its Mask type parameter as VerificationSubsystem Verify sample time: aspects of the design assume a 0.01 second sample time. Fuel Rate Control Subsystem Copyright 1990-2020 The MathWorks, Inc.


MODELNAME: fmudemo_export_fuelsys_plant
PATH: examples/simulinkcompiler/main/fmudemo_export_fuelsys_plant.slx
BLOCKTYPE_FREQUENCY: 3;4;1;17;1;2;14;4;4;1;1;2;1;4;1
CHECKSUM: 321319755C1D0958B164312219BCC924
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SK
ANNOTATION:
Intake Manifold Vacuum Throttle Flow vs. Valve Angle and Pressure Air-Fuel Intake Dynamics Engine Gas Dynamics Copyright 1990-2020 The MathWorks, Inc.


MODELNAME: fmudemo_export_fuelsys_top
PATH: examples/simulinkcompiler/main/fmudemo_export_fuelsys_top.slx
BLOCKTYPE_FREQUENCY: 1;1;9;2;5;1;2;5;4;2;1;1;1;1;1;4;4;1;1
CHECKSUM: 1FE96C92ADA3F4FFB3BA3F28FED52ED2
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SK
ANNOTATION:
Inputs Fault Injection Air/Fuel Ratio Fuel (g/s)  Throttle Angle  Engine Speed  EGO  Fault-Tolerant Fuel Control System Dashboard  MAP  Engine Speed (rpm)  Normal Range  Full Range  Update Diagram (Ctrl+D) to bind switches to model workspace variables. This system: - Packs individual sensors into a EngSensors bus signal - Permits bus elements data types to change - Converts signals from continuous to discrete time This system: - Permits upstream signal data type to change - Converts signals from discrete to continuous time Fault-Tolerant Fuel Control System Copyright 1990-2020 The MathWorks, Inc.  Open the Dashboard subsystem to simulate any combination of sensor failures.

BLOCK:
Bus Creator;Constant;DTC;Dashboard;Dashboard Scope;EGO Fault Switch;Engine Gas Dynamics;Engine Speed;Engine Speed Fault Switch;Engine_Speed_Selector;Gauge;Half Gauge;In;Lamp;MAP Fault Switch;MAP_Selector;O2_Voltage_Selector;Out;Quarter Gauge;Rate Transition;Reference;Scope;Sensor Info;Slider Switch;SubSystem;Throttle Angle Fault Switch;Throttle Command;Throttle_Angle_Selector;To Controller;To Plant;Toggle Switch;Unit Delay;ego;fuel_rate_control;map;sensors;speed;throttle

BLOCKTYPE:
BusCreator;CircularGaugeBlock;Constant;DashboardScope;DataTypeConversion;DocBlock;FMU;Inport;LampBlock;Outport;QuarterGaugeBlock;RateTransition;Repeating table;Scope;SemiCircularGaugeBlock;SliderSwitchBlock;Switch;ToggleSwitchBlock;UnitDelay


MODELNAME: fmuexport_aircraft_flight_control_plant
PATH: examples/simulinkcompiler/main/fmuexport_aircraft_flight_control_plant.slx
BLOCKTYPE: Band-Limited White Noise.;Gain;Inport;InportShadow;Integrator;Outport;Sum;Terminator;TransferFcn
BLOCKTYPE_FREQUENCY: 1;13;10;1;2;12;9;2;7
CHECKSUM: 933A7216C74B52A91BD3A6C9F330C3BC
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SK
DESCRIPTION:
Aircraft Longitudinal Flight Control Plant This example shows how to model flight control for the longitudinal motion of an aircraft. First order linear approximations of the aircraft and actuator behavior are connected to an analog flight control design that uses the pilots stick pitch command as the set point for the aircrafts pitch attitude and uses aircraft pitch angle and pitch rate to determine commands. A simplified Dryden wind gust model is incorporated to perturb the system.

ANNOTATION:
Aircraft Longitudinal Flight Control This example models a flight control algorithm for the longitudinal motion of an aircraft. Copyright 2021 The MathWorks, Inc.

BLOCK:
Actuator Model;Aircraft Dynamics Model;Alpha, deg;Alpha-sensor Low-pass Filter;Band-Limited White Noise;Controller;Dryden Wind Gust Models;Elevator Command (deg);Elevator Deflection d (deg);Gain;Input;Integrate;Integrate qdot;Pitch Accel qdot (rad/sec2);Pitch Channel;Pitch Rate Lead Filter;Pitch Rate q (rad/sec);Proportional plus integral compensator;Q-gust model;Qg;Reference;Rotary Gust qGust (rad/sec);Stick;Stick Input (in);Stick Prefilter;SubSystem;Sum;Vertical Channel;Vertical Gust wGust (ft/sec);W-gust model;Wg;alpha;alpha (rad);q;q (rad/sec);qdot;u;w;wdot;wdot (ft/sec^2)


MODELNAME: fmuexport_aircraft_flight_control_top
PATH: examples/simulinkcompiler/main/fmuexport_aircraft_flight_control_top.slx
BLOCK: Aircraft Longitudinal Flight Control Plant;Pilot;Scope;u
BLOCKTYPE: FMU;Inport;Scope;SignalGenerator
BLOCKTYPE_FREQUENCY: 1;1;1;1
CHECKSUM: 30BAB60AF3D760519CF360E5F1448418
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SK
DESCRIPTION:
Aircraft Longitudinal Flight Control Top This example shows how to integrate FMU in Simulink. The FMU models flight control for the longitudinal motion of an aircraft. First order linear approximations of the aircraft and actuator behavior are connected to an analog flight control design that uses the pilots stick pitch command as the set point for the aircrafts pitch attitude and uses aircraft pitch angle and pitch rate to determine commands. A simplified Dryden wind gust model is incorporated to perturb the system.

ANNOTATION:
Aircraft Longitudinal Flight Control System This example models a flight control algorithm for the longitudinal motion of an aircraft. Copyright 2021 The MathWorks, Inc.


MODELNAME: fmuexport_fuelsys_controller
PATH: examples/simulinkcompiler/main/fmuexport_fuelsys_controller.slx
BLOCKTYPE_FREQUENCY: 3;2;1;8;2;2;3;1;1;1;1;24;1;5;1;1;15;1;4;2;1;1;5;1;1;1;3;1
CHECKSUM: 7CA8834CFBD37CCFACA4BEC0D18E0D13
PRODUCT: MATLAB;Simulink;Simulink Compiler Documentation;Stateflow
PRODUCT_BASECODE: SK
ANNOTATION:
Intake Airflow Estimation and Closed-Loop Correction Feedback Control Feedforward Control MAP Estimation Speed Estimation Throttle Estimation Feedforward Fuel Rate Disabled Mode Fuel Mode Low Mode Fuel Mode Rich Mode Fuel Mode Loop Compensation and Filtering Fuel Rate Calculation The contents of this subsystem are excluded from the code Simulink Coder generates. To work correctly this system must continue to * Contain no output ports * Enable its Treat as Atomic Unit parameter * Specify its Mask type parameter as VerificationSubsystem Verify sample time: aspects of the design assume a 0.01 second sample time. Fuel Rate Control Subsystem Copyright 2021 The MathWorks, Inc.


MODELNAME: fmuexport_fuelsys_plant
PATH: examples/simulinkcompiler/main/fmuexport_fuelsys_plant.slx
BLOCKTYPE_FREQUENCY: 3;4;1;17;1;2;14;4;4;1;1;2;1;4;1
CHECKSUM: E56E14D1FE71D86D75DE5B7C0B3C4647
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SK
ANNOTATION:
Intake Manifold Vacuum Throttle Flow vs. Valve Angle and Pressure Air-Fuel Intake Dynamics Engine Gas Dynamics Copyright 2021 The MathWorks, Inc.


MODELNAME: fmuexport_fuelsys_top
PATH: examples/simulinkcompiler/main/fmuexport_fuelsys_top.slx
BLOCKTYPE_FREQUENCY: 1;1;9;2;5;1;1;5;4;1;2;1;1;1;1;1;4;4;1;1
CHECKSUM: EAFFB8E015B4AABD15D5AD7846FD3344
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SK
EXTERNALFILE_REFERENCE: fmuexport_fuelsys_plant.slx___Model_Block___
ANNOTATION:
Inputs Fault Injection Air/Fuel Ratio Fuel (g/s)  Throttle Angle  Engine Speed  EGO  Fault-Tolerant Fuel Control System Dashboard  MAP  Engine Speed (rpm)  Normal Range  Full Range  Update Diagram (Ctrl+D) to bind switches to model workspace variables. This system: - Packs individual sensors into a EngSensors bus signal - Permits bus elements data types to change - Converts signals from continuous to discrete time This system: - Permits upstream signal data type to change - Converts signals from discrete to continuous time Fault-Tolerant Fuel Control System Copyright 2021 The MathWorks, Inc.  Open the Dashboard subsystem to simulate any combination of sensor failures.

BLOCK:
Bus Creator;Constant;DTC;Dashboard;Dashboard Scope;EGO Fault Switch;Engine Gas Dynamics;Engine Speed;Engine Speed Fault Switch;Engine_Speed_Selector;Fuel Rate Control;Gauge;Half Gauge;In;Lamp;MAP Fault Switch;MAP_Selector;O2_Voltage_Selector;Out;Quarter Gauge;Rate Transition;Reference;Scope;Sensor Info;Slider Switch;SubSystem;Throttle Angle Fault Switch;Throttle Command;Throttle_Angle_Selector;To Controller;To Plant;Toggle Switch;Unit Delay;ego;map;sensors;speed;throttle

BLOCKTYPE:
BusCreator;CircularGaugeBlock;Constant;DashboardScope;DataTypeConversion;DocBlock;FMU;Inport;LampBlock;ModelReference;Outport;QuarterGaugeBlock;RateTransition;Repeating table;Scope;SemiCircularGaugeBlock;SliderSwitchBlock;Switch;ToggleSwitchBlock;UnitDelay


MODELNAME: fmuexport_fuelsys_top_harness_model
PATH: examples/simulinkcompiler/main/fmuexport_fuelsys_top_harness_model.slx
BLOCKTYPE_FREQUENCY: 1;1;9;2;5;1;5;4;2;2;1;1;1;1;1;4;4;1;1
CHECKSUM: 4D473A4A418FDEF7903219974E5BE9DA
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SK
ANNOTATION:
Inputs Fault Injection Air/Fuel Ratio Fuel (g/s)  Throttle Angle  Engine Speed  EGO  Fault-Tolerant Fuel Control System Dashboard  MAP  Engine Speed (rpm)  Normal Range  Full Range  Update Diagram (Ctrl+D) to bind switches to model workspace variables. This system: - Packs individual sensors into a EngSensors bus signal - Permits bus elements data types to change - Converts signals from continuous to discrete time This system: - Permits upstream signal data type to change - Converts signals from discrete to continuous time Fault-Tolerant Fuel Control System Copyright 2021 The MathWorks, Inc.

BLOCK:
Bus Creator;Constant;DTC;Dashboard;Dashboard Scope;EGO Fault Switch;Engine Gas Dynamics;Engine Speed;Engine Speed Fault Switch;Engine_Speed_Selector;Gauge;Half Gauge;In;Lamp;MAP Fault Switch;MAP_Selector;Model;O2_Voltage_Selector;Out;Quarter Gauge;Rate Transition;Reference;Scope;Sensor Info;Slider Switch;SubSystem;Throttle Angle Fault Switch;Throttle Command;Throttle_Angle_Selector;To Controller;To Plant;Toggle Switch;Unit Delay;ego;map;sensors;speed;throttle

BLOCKTYPE:
BusCreator;CircularGaugeBlock;Constant;DashboardScope;DataTypeConversion;DocBlock;Inport;LampBlock;ModelReference;Outport;QuarterGaugeBlock;RateTransition;Repeating table;Scope;SemiCircularGaugeBlock;SliderSwitchBlock;Switch;ToggleSwitchBlock;UnitDelay

EXTERNALFILE_REFERENCE:
fmuexport_fuelsys_controller_harness.slx___Model_Block___fmuexport_fuelsys_plant.slx___Model_Block___


MODELNAME: ifThen
PATH: examples/simulinkcompiler/main/ifThen.slx
ANNOTATION: Copyright 1990-2023 The MathWorks, Inc. If-Then Subsystem
BLOCKTYPE: ActionPort;Constant;If;Inport;Merge;Outport
BLOCKTYPE_FREQUENCY: 2;1;1;4;1;3
CHECKSUM: 13CD65635DC19F3690E090CEF63B2C63
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SK
BLOCK:
Action Port;Baseline Value;Control Signal;If;If Action Subsystem;Inport;Merge;Out;Outport;Source Signal;SubSystem;Transmitted Signal


MODELNAME: AttitudeControllerAutopilotMdlRef
PATH: examples/simulinktest/main/AttitudeControllerAutopilotMdlRef.slx
BLOCKTYPE: CMBlock;Gain;Inport;Logic;Outport;SLCI_Level_Reset_Integrator;Saturate;Sum
BLOCKTYPE_FREQUENCY: 1;3;4;1;1;1;3;3
CHECKSUM: 138976B2AA635911785302B57D63AB4A
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SZ
ANNOTATION:
Copyright 2015 The MathWorks Inc. AttitudeControllerAutopilotMdlRef.slx  This model is referenced by PitchAutopilotMdlRef.slx and RollAutopilotMdlRef. Autopilot Example Model

BLOCK:
Cmd Limit;Disp Gain;Disp Limit;Disp_Cmd;Disp_FB ;Engaged;Int Gain;Model Info;Not engaged;Rate Gain;Rate Limit;Rate_FB;Reference;ResetIntegratorInternal;Sum;Surf_Cmd


MODELNAME: CruiseControlAddCov
PATH: examples/simulinktest/main/CruiseControlAddCov.slx
BLOCKTYPE_FREQUENCY: 2;1;1;1;2;33;3;17;8;4;3;2
CHECKSUM: FEB335E81A66873F287273E79DCE42A5
PRODUCT: MATLAB;Simulink;Simulink Test
PRODUCT_BASECODE: SZ
DESCRIPTION:
Cruise Control Test Generation This example shows how to generate test cases that achieve complete model coverage.

ANNOTATION:
Determine if the control is active Compute the target speed Cruise Control Coverage Copyright 2021 The MathWorks, Inc. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
Constant;Controller;Discrete-Time Integrator;Enable;Inport_;Input Conversion Subsystem;Kp;Logical Operator;Outport_;Output Conversion Subsystem;PI Controller;Reference;SigSpec_;SubSystem;Sum;Switch;Unit Delay;brake;constraint;dec;enable;error;harness_in_;harness_out_;inc;set;speed;target;throt

BLOCKTYPE:
Constant;Design Verifier Test Condition;DiscreteIntegrator;EnablePort;Gain;Inport;Logic;Outport;SignalSpecification;Sum;Switch;UnitDelay


MODELNAME: HeadingModeAutopilotMdlRef
PATH: examples/simulinktest/main/HeadingModeAutopilotMdlRef.slx
BLOCK: Angle_Diff;Disp Gain;Model Info;Phi Cmd;Product;Psi;Psi Ref;Reference;SubSystem;TAS
BLOCKTYPE: CMBlock;Gain;Inport;Outport;Product
BLOCKTYPE_FREQUENCY: 1;1;3;1;1
CHECKSUM: 1EF867BA52942D316C6E0A26642E55C0
PRODUCT: Embedded Coder;MATLAB;Requirements Toolbox;Simulink
PRODUCT_BASECODE: SZ
ANNOTATION:
Copyright 2015 The MathWorks Inc. HeadingModeAutopilotMdlRef.slx  This model is referenced by RollAutopilotMdlRef.slx. Autopilot Example Model


MODELNAME: HeatPumpScenario
PATH: examples/simulinktest/main/HeatPumpScenario.slx
BLOCKTYPE_FREQUENCY: 1;2;2;3;1;17;1;10;2;2;4;2;1;2;1;1
CHECKSUM: 18530A7D07771694BD3D0FF178993B0D
PRODUCT: MATLAB;Simulink;Simulink Test;Simulink Test Documentation
PRODUCT_BASECODE: SZ
ANNOTATION:
Copyright 1990-2014 The MathWorks, Inc. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
 Demux ; Ground ; SFunction ; Terminator ;1/mcp;Aw/Rth;Bus Selector;Controller;H/C Switch;In;In_;Input Conversion Subsystem;Integrator;Nom cool rate [BTU/hr];Nom htg rate [BTU/hr];Out_;Output Conversion Subsystem;Plant;Reference;Scope;SigSpec_;SubSystem;Sum;Test Assessment;Test Sequence;Toutside;Troom;Troom_in;Tset;Unit Delay;Zero-Order Hold;[J/s];control_in;control_out;harness_in_;harness_out_;harness_stub

BLOCKTYPE:
BusSelector;Constant;Demux;Gain;Ground;Inport;Integrator;Outport;S-Function;Scope;SignalSpecification;Sum;Switch;Terminator;UnitDelay;ZeroOrderHold


MODELNAME: Overflow_Observer_1
PATH: examples/simulinktest/main/Overflow_Observer_1.slx
BLOCKTYPE: BusSelector;Demux;Inport;ObserverPort;Outport;S-Function;Terminator
BLOCKTYPE_FREQUENCY: 2;2;4;2;4;2;6
CHECKSUM: 44284A96BB8226E62FF37C4004FDAD95
PRODUCT: MATLAB;Simulink;Stateflow
PRODUCT_BASECODE: SZ
BLOCK:
 Demux ; SFunction ; Terminator ;Bus Selector;Chart;Metadata;OrigPayload;Receive;Send;SubSystem;Terminator;data;eventType;meta


MODELNAME: PitchAutopilotMdlRef
PATH: examples/simulinktest/main/PitchAutopilotMdlRef.slx
BLOCKTYPE_FREQUENCY: 1;1;1;17;1;2;3;2;2;2;2;1
CHECKSUM: 60B9B2A07F22C04E271F367E159E63EC
PRODUCT: Aerospace Blockset;Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SZ
EXTERNALFILE_REFERENCE: AltitudeModeAutopilotMdlRef___Model_Block___AttitudeControllerAutopilotMdlRef___Model_Block___
ANNOTATION:
Pitch Rate Computation Pitch Reference Copyright 2015 The MathWorks Inc. PitchAutopilotMdlRef.slx  This model is referenced by TestAndVerificationAutopilotExample.slx. Autopilot Example Model

BLOCK:
ALT Mode;AP Eng;Alt;Alt Rate;Alt Ref;Altitude Mode;Angle Conversion;Basic Pitch Mode;Constant;Elv Cmd;Eng switch;Latch Theta;Mode switch;Model Info;Not engaged;Phi;Pitch Rate;Pitch Rate Feedback;Pitch Reference;Pitch Wheel;Pitch Wheel ;Product;Q;R;Reference;SubSystem;Sum;TAS;Theta;Theta Ref;cos;sin

BLOCKTYPE:
Angle Conversion;CMBlock;Constant;Inport;Logic;ModelReference;Outport;Product;Sum;Switch;Trigonometry;Unit Delay Enabled


MODELNAME: RollAutopilotMdlRef
PATH: examples/simulinktest/main/RollAutopilotMdlRef.slx
BLOCKTYPE_FREQUENCY: 1;1;5;1;1;9;5;19;2;2;10;4;3;1;4;4;1;1;1
CHECKSUM: CF84D2A328A885A51E71565FB3F343D5
PRODUCT: Embedded Coder;MATLAB;Requirements Toolbox;Simulink;Simulink Test;Simulink Test Documentation
PRODUCT_BASECODE: SZ
EXTERNALFILE_REFERENCE: AttitudeControllerAutopilotMdlRef___Model_Block___HeadingModeAutopilotMdlRef___Model_Block___
ANNOTATION:
Roll Reference Copyright 2017 The MathWorks Inc. RollAutopilotMdlRef.slx  This model is used to show how to perform requirements-based testing using test harnesses, Test Sequence blocks, and the test manager. To view the demo, enter sltestRequirementsTestingAutopilotDemo in MATLAB(R). Requirements-based Testing for Controller Development This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
 Demux ; SFunction ; Terminator ;AP Eng;AP eng;APEng;Abs;Ail Cmd;Basic Roll Mode;DD_PhiRef;Discrete Derivative;Eng switch;From_;Goto_;HDG Mode;HDG Ref;Heading Mode;In_From_;In_Goto_;Inport_;Input Conversion Subsystem;Latch Phi;Mode switch;Model Info;Not engaged;Out_From_;Out_Goto_;Outport_;Output Conversion Subsystem;Phi;Phi Ref;Psi;RateTs_;Rate_Transition_;Ref Threshold;Reference;Roll Reference;SigSpec_;SubSystem;TAS;TK Threshold;TK switch;Test Assessment;Test Sequence;Turn Knob;TurnKnob;delay_;harness_in_;harness_out_;minus six;or;p;ref switch;six;three;zero

BLOCKTYPE:
Abs;CMBlock;Constant;Demux;Discrete Derivative;From;Goto;Inport;Logic;ModelReference;Outport;RateTransition;RelationalOperator;S-Function;SignalSpecification;Switch;Terminator;Unit Delay Enabled;UnitDelay


MODELNAME: RollAutopilotRevised
PATH: examples/simulinktest/main/RollAutopilotRevised.slx
BLOCKTYPE_FREQUENCY: 1;1;8;1;1;1;1;29;3;2;16;3;5;1;8;5;1;1;1
CHECKSUM: B010B7CC61ED68CCE56B1752FCDA225F
PRODUCT: Embedded Coder;MATLAB;Requirements Toolbox;Simulink;Simulink Test;Simulink Test Documentation
PRODUCT_BASECODE: SZ
ANNOTATION:
Roll Reference Copyright 2015 The MathWorks Inc. RollAutopilotRevised.slx  This example shows you how to increase the model coverage of tests for a test suite set up initially for timeseries testing. To view the demo, enter sltestCoverageIncreaseAPDemo in MATLAB(R). Increasing Test Coverage for a Model This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
 Demux ; SFunction ; Terminator ;AP Eng;AP eng;APEng;AP_eng;Abs;Ail Cmd;Basic Roll Mode;DD_PhiRef;Discrete Derivative;Eng switch;From_;Goto_;HDG Mode;HDG Ref;Heading Mode;In_;Input Conversion Subsystem;Latch Phi;Mode switch;Model Info;Not engaged;Out_;Output Conversion Subsystem;Phi;Phi Ref;Psi;Rate_Transition_;Ref Threshold;Reference;Roll Reference;SigSpec_;SubSystem;TAS;TK Threshold;TK switch;Test Assessment;Test Sequence;Turn Knob;TurnKnob;delay_;harness_in_;harness_out_;minus six;minus thirty;or;p;ref switch;six;thirty;thirty ref;three;zero

BLOCKTYPE:
Abs;CMBlock;Constant;Demux;Discrete Derivative;From;Goto;Inport;Logic;ModelReference;Outport;RateTransition;RelationalOperator;S-Function;SignalSpecification;Switch;Terminator;Unit Delay Enabled;UnitDelay

EXTERNALFILE_REFERENCE:
AttitudeControllerAutopilotMdlRef.slx___Model_Block___HeadingModeAutopilotMdlRef.slx___Model_Block___


MODELNAME: TestAndVerificationAutopilotExample
PATH: examples/simulinktest/main/TestAndVerificationAutopilotExample.slx
BLOCKTYPE: BusSelector;CMBlock;Inport;ModelReference;Outport
BLOCKTYPE_FREQUENCY: 2;1;9;3;3
CHECKSUM: 3D8F4951962ADE93B92E7ED4D2A10C32
PRODUCT: Aerospace Blockset Documentation;Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SZ
ANNOTATION:
Copyright 2015 The MathWorks Inc. TestAndVerificationAutopilotExample.slx  This model is the parent model of RollAutopilotMdlRef.slx, which is used to demonstrate requirements-based testing. Autopilot Example Model

BLOCK:
ALT Mode;ALT Ref;AP Eng;Aileron Cmd;Air Data;Bus Selector;Elevator Cmd;HDG Mode;HDG Ref;Inertial;Model Info;Pitch Wheel;Pitch_Autopilot;Reference;Roll_Autopilot;Rudder Cmd;Turn Knob;Yaw_Damper

EXTERNALFILE_REFERENCE:
PitchAutopilotMdlRef___Model_Block___RollAutopilotMdlRef___Model_Block___YawDamperAutopilotMdlRef___Model_Block___


MODELNAME: TestSeqOutputFunctions
PATH: examples/simulinktest/main/TestSeqOutputFunctions.slx
ANNOTATION: Copyright 2015-2020 The MathWorks, Inc.
BLOCKTYPE: Demux;Ground;Outport;S-Function;Scope;Terminator
BLOCKTYPE_FREQUENCY: 3;3;5;3;3;4
CHECKSUM: 9C0C13A5291FA5FE73C7B182CF8783BB
PRODUCT: MATLAB;Simulink;Simulink Test
PRODUCT_BASECODE: SZ
BLOCK:
 Demux ; Ground ; SFunction ; Terminator ;Calling ext functions;Output functions;Scope;Sine and rand;SubSystem;Terminator;Ti;asg;sg;throttle


MODELNAME: TransmissionDownshiftTestSequence
PATH: examples/simulinktest/main/TransmissionDownshiftTestSequence.slx
BLOCKTYPE_FREQUENCY: 11;2;26;6;15;59;2;5;41;6;3;11;2;12;1;3;10;1;4;1;1
CHECKSUM: 3CB710C1207B353B02480FDCD12638EC
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Test;Simulink Test Documentation;Stateflow
PRODUCT_BASECODE: SZ
DESCRIPTION:
TransmissionDownshiftTestSequence model The model is used to show how to test a transmission shift logic controller using test sequences and assessments. 

ANNOTATION:
Vehicle TORQUE CONVERTER  Copyright 2014-2024 The MathWorks, Inc.  Testing Downshift Points of a Transmission Controller This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. Copyright 2014-2017 The MathWorks, Inc.   This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
 Demux ; SFunction ; Terminator ; gear;Engine;FloatingScope;From;From_;Goto;Goto_;In_;In_From_;In_Goto_;Inport_;Input Conversion Subsystem;Integrator;K factor;Look-Up;Look-Up Table;Ne;Nin;Nout;Out;Out_;Out_From_;Out_Goto_;Outport_;Output Conversion Subsystem;Product;Rate_Transition_;Scope;SigSpec_;Sign;SubSystem;Sum;Test Assessment;Test Assessment Block;Test Sequence;Ti;Tin;Torque Converter;Torque ratio;Tout;Tt;Vehicle;brake;brake torque;delay_;down_th;engine + impeller inertia;engine torque;f;final drive ratio;gear;harness_in_;harness_out_;impeller;interp_down;interp_up;linear speed;mph;out;quotient;road load;selection_state.calc_th;shift_controller;signed load;speed;speed ratio;throttle;transmission;transmission output speed;transmission output torque;transmission ratio;turbine;up_th;vehicle;vehicle inertia;vehicle speed;wheel speed

BLOCKTYPE:
Demux;Fcn;From;Gain;Goto;Inport;Integrator;Lookup_n-D;Outport;Product;RateTransition;S-Function;Scope;SignalSpecification;Signum;Sum;Terminator;TriggerPort;UnitDelay;torque converter;vehicle model


MODELNAME: TxDownShift
PATH: examples/simulinktest/main/TxDownShift.slx
BLOCKTYPE_FREQUENCY: 7;2;11;6;7;40;2;5;29;6;1;7;1;6;1;3;6;1;2;1;1
CHECKSUM: 485B85D9EFF5FFF9E756C904C3BE1AA7
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Test;Simulink Test Documentation;Stateflow
PRODUCT_BASECODE: SZ
DESCRIPTION:
TransmissionDownshiftTestSeqVerify model The model is used to show how to obtain the verify statement dataset from a test case result. 

ANNOTATION:
Vehicle TORQUE CONVERTER Copyright 2014-2024 The MathWorks, Inc.  Testing Downshift Points of a Transmission Controller This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. Copyright 2014-2017 The MathWorks, Inc.   This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
 Demux ; SFunction ; Terminator ; gear;Engine;FloatingScope;From;From_;Goto;Goto_;In_;In_From_;In_Goto_;Inport_;Input Conversion Subsystem;Integrator;K factor;Look-Up;Look-Up Table;Ne;Nin;Nout;Out;Out_;Out_From_;Out_Goto_;Outport_;Output Conversion Subsystem;Product;Rate_Transition_;SigSpec_;Sign;SubSystem;Sum;Test Assessment;Test Assessment Block;Test Sequence;Ti;Tin;Torque Converter;Torque ratio;Tout;Tt;Vehicle;brake;brake torque;delay_;down_th;engine + impeller inertia;engine torque;f;final drive ratio;gear;harness_in_;harness_out_;impeller;interp_down;interp_up;linear speed;mph;out;quotient;road load;selection_state.calc_th;shift_controller;signed load;speed;speed ratio;throttle;transmission;transmission output speed;transmission output torque;transmission ratio;turbine;up_th;vehicle;vehicle inertia;vehicle speed;wheel speed

BLOCKTYPE:
Demux;Fcn;From;Gain;Goto;Inport;Integrator;Lookup_n-D;Outport;Product;RateTransition;S-Function;Scope;SignalSpecification;Signum;Sum;Terminator;TriggerPort;UnitDelay;torque converter;vehicle model


MODELNAME: YawDamperAutopilotMdlRef
PATH: examples/simulinktest/main/YawDamperAutopilotMdlRef.slx
BLOCKTYPE: CMBlock;Constant;Gain;Inport;MinMax;Outport;Product;Saturate;Sum;Switch;Trigonometry
BLOCKTYPE_FREQUENCY: 2;2;2;7;1;2;1;1;1;1;1
CHECKSUM: CF66C57FEB2627E6392001DFA3BDB8F3
PRODUCT: Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SZ
ANNOTATION:
Basic Yaw Damper Copyright 1990-2012 The MathWorks Inc. ARP-4754/DO-178 Demonstration Copyright 2015 The MathWorks Inc. YawDamperAutopilotMdlRef.slx  This model is referenced by TestAndVerificationAutopilotExample.slx. Autopilot Example Model

BLOCK:
AP Eng;Basic Yaw Damper;Constant;Eng switch;MinMax;Model Info;Phi;Phi ;Product;R;Rate Gain;Reference;Rud Cmd;Rud Limit;SubSystem;Sum;TAS;gravity;sin


MODELNAME: cruiseControlRBTCovExample
PATH: examples/simulinktest/main/cruiseControlRBTCovExample.slx
BLOCKTYPE_FREQUENCY: 2;2;1;1;2;27;3;1;17;8;4;3;2
CHECKSUM: AF3CF98E74D0C21F1CE92960F909C14D
PRODUCT: MATLAB;Requirements Toolbox;Simulink;Simulink Test;Simulink Test Documentation
PRODUCT_BASECODE: SZ
ANNOTATION:
Copyright 2006-2024 The MathWorks, Inc. Determine if the control is active Compute the target speed Cruise Control Requirements-Based Testing This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
Constant;Controller;Discrete Derivative;Discrete-Time Integrator;Enable;Inport_;Input Conversion Subsystem;Ki;Kp;Logical Operator;Outport_;Output Conversion Subsystem;PI Controller;Reference;SigSpec_;SubSystem;Sum;Switch;Unit Delay;brake;dec;enable;error;inc;set;sldvdemo_cruise_control_rbt;speed;target;target_deriv;throt;throt_deriv

BLOCKTYPE:
Constant;Discrete Derivative;DiscreteIntegrator;EnablePort;Gain;Inport;Logic;ModelReference;Outport;SignalSpecification;Sum;Switch;UnitDelay


MODELNAME: mMdlRef
PATH: examples/simulinktest/main/mMdlRef.slx
BLOCK: In;In_;Input Conversion Subsystem;Model;Out_;SigSpec_;SubSystem
BLOCKTYPE: Inport;ModelReference;Outport;SignalSpecification
BLOCKTYPE_FREQUENCY: 10;3;4;4
CHECKSUM: 1070783C62FE19FD97B0D8C236BCE478
PRODUCT: MATLAB;Simulink;Simulink Test
PRODUCT_BASECODE: SZ
EXTERNALFILE_REFERENCE: mDecisionRootInport___Model_Block___
ANNOTATION:
This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure.


MODELNAME: mShiftControl
PATH: examples/simulinktest/main/mShiftControl.slx
BLOCKTYPE: Demux;Inport;Outport;S-Function;Terminator;TriggerPort
BLOCKTYPE_FREQUENCY: 1;10;2;1;1;1
CHECKSUM: 59AA6F8E3127588B25DEA4F5EB3FCD7E
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Test Documentation;Stateflow
PRODUCT_BASECODE: SZ
BLOCK:
 Demux ; SFunction ; Terminator ;FcnCall;GearCmd;GearMove;SubSystem;gear;shift_control;speed;throttle;v;v_down;v_up


MODELNAME: mSldvdemoCruiseControl
PATH: examples/simulinktest/main/mSldvdemoCruiseControl.slx
BLOCKTYPE_FREQUENCY: 2;12;2;1;1;1;2;2;91;3;3;83;12;2;2;48;4;3;2
CHECKSUM: D342A626B05577B087EA03592CF70D31
PRODUCT: MATLAB;Simulink;Simulink Test;Simulink Test Documentation
PRODUCT_BASECODE: SZ
DESCRIPTION:
Cruise Control Test Generation This example shows how to generate test cases that achieve complete model coverage.

ANNOTATION:
Determine if the control is active Compute the target speed Simulink Design Verifier Cruise Control Test Generation Copyright 2006-2012 The MathWorks, Inc.  This example shows how to generate test cases that achieve complete model coverage. By default, Simulink Design Verifier generates test cases that satisfy objectives in the fewest steps. One of the test objectives forces the discrete integrator in the PI controller to exceed its upper limit. When you run Simulink Design Verifier without constraints, the limit is exceeded in a single step by forcing speed to be 500. The constraint on speed limits the values in test cases between 0 and 100. This forces the test cases to take several samples to exceed the integrator limit.  This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
Constant;Controller;Data_Conversion_;Demux;Discrete-Time Integrator;Enable;FromWs;Harness Inputs;Inport_;Input Conversion Subsystem;Kp;Logical Operator;Outport_;Output Conversion Subsystem;PI Controller;RateTs_;Reference;SigSpec_;SubSystem;Sum;Switch;Unit Delay;brake;constraint;dec;enable;error;harness_in_;harness_out_;inc;mSldvdemoCruiseControl;set;speed;target;throt

BLOCKTYPE:
Constant;DataTypeConversion;Demux;Design Verifier Test Condition;DiscreteIntegrator;EnablePort;FromWorkspace;Gain;Inport;Logic;ModelReference;Outport;RateTransition;Sigbuilder block;SignalEditor;SignalSpecification;Sum;Switch;UnitDelay


MODELNAME: mTCUDesign
PATH: examples/simulinktest/main/mTCUDesign.slx
BLOCKTYPE: Demux;Ground;Inport;ModelReference;Outport;S-Function;Scope
BLOCKTYPE_FREQUENCY: 1;1;2;3;4;1;1
CHECKSUM: 90C4EB7DBA2D6E3D170C3F1980C3D169
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Test Documentation;Stateflow
PRODUCT_BASECODE: SZ
EXTERNALFILE_REFERENCE: mGearControl___Model_Block___mShiftControl.slx___Model_Block___mShiftThreshold.slx___Model_Block___
BLOCK:
 Demux ; Ground ; SFunction ;F1();F2();F3();Gear;GearControlModule;Scheduler;Scope;SubSystem;shift_controlModule;shift_threshold;speed;throttle


MODELNAME: massSpringDamperPID
PATH: examples/simulinktest/main/massSpringDamperPID.slx
ANNOTATION: Copyright 2023 The MathWorks, Inc. Mass-Spring-Damper PID Controller
BLOCKTYPE: BusCreator;BusSelector;Constant;Inport;Outport;PID 1dof;Sum;TransferFcn
BLOCKTYPE_FREQUENCY: 1;1;2;2;2;1;1;1
CHECKSUM: 0DE35A28155DF33874AD2F2D8A7BC90D
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SZ
BLOCK:
Bus Creator;Bus Selector;Constant;Controller;In;Inport;Out;Outport;PID Controller;Reference;SubSystem;Sum;Transfer Fcn


MODELNAME: massSpringDamperPIDwithRef
PATH: examples/simulinktest/main/massSpringDamperPIDwithRef.slx
ANNOTATION: Copyright 2023 The MathWorks, Inc. Mass-Spring-Damper PID Controller
BLOCKTYPE: BusCreator;BusSelector;Constant;Inport;Outport;PID 1dof;Scope;Step;Sum;TransferFcn
BLOCKTYPE_FREQUENCY: 1;1;2;1;2;1;1;1;1;1
CHECKSUM: 4C8078AE3B20E68512D588E8C43B5C59
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SZ
BLOCK:
Actual tracking error;Bus Creator;Bus Selector;Constant;Controller;In;Out;Outport;PID Controller;Reference;Step;SubSystem;Sum;Transfer Fcn


MODELNAME: prohibitSimultaneousPress
PATH: examples/simulinktest/main/prohibitSimultaneousPress.slx
BLOCKTYPE_FREQUENCY: 1;2;3;18;10;27;1;21;6;3;1;8;2;3;2
CHECKSUM: 6B0EC2CE25B21446C8AE5F6474F777A6
PRODUCT: MATLAB;Simulink;Simulink Test;Simulink Test Documentation
PRODUCT_BASECODE: SZ
ANNOTATION:
 This model includes test harnesses for the RejectPressingBothButtons subsystem. To open the test harnesses, click the icon on the subsystem and select a harness.  Simulink® Test™ model prohibitSimultaneousPress.slx Copyright 2018, The MathWorks, Inc. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.  This test harness shows how to connect a Test Sequence block to a Test Assessment block with active test step data. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.  This test harness shows Signal Builder block inputs with a Test Assessment block containing verify statements.

BLOCK:
 Demux ; SFunction ; Terminator ;Constant;Data_Conversion_;From_;Goto_;GreenButtonIN;GreenButtonOUT;Harness Inputs;In;In_From_;In_Goto_;Inport_;Input Conversion Subsystem;Logical Operator;Out;Out_From_;Out_Goto_;Outport_;Output Conversion Subsystem;RateTs_;Rate_Transition_;RedButtonIN;RedButtonOUT;Reference;RejectPressingBothButtons;SigSpec_;SubSystem;Switch;TSActiveStepIN;TSActiveStepOUT;Test Assessment Block;Test Sequence;delay_;harness_in_;harness_out_

BLOCKTYPE:
Constant;DataTypeConversion;Demux;From;Goto;Inport;Logic;Outport;RateTransition;S-Function;SignalEditor;SignalSpecification;Switch;Terminator;UnitDelay


MODELNAME: simpleSwitchWithSubsystemIn
PATH: examples/simulinktest/main/simpleSwitchWithSubsystemIn.slx
BLOCKTYPE_FREQUENCY: 2;22;2;2;2;24;32;12;10;6;8
CHECKSUM: 8E18EFDAFB01C991E64AACBAB5CA370E
PRODUCT: MATLAB;Simulink;Simulink Test
PRODUCT_BASECODE: SZ
ANNOTATION:
Copyright 2020 The MathWorks, Inc. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
Compare To Constant;Constant;Display;Enable;Enabled Subsystem;Gain;In;Inport_;Input Conversion Subsystem;Out;Outport_;Output Conversion Subsystem;Reference;Scope;SigSpec_;Sine Wave;SubSystem;Subsystem;Switch;harness_in_;harness_out_;switchOutput

BLOCKTYPE:
Compare To Constant;Constant;Display;EnablePort;Gain;Inport;Outport;Scope;SignalSpecification;Sin;Switch


MODELNAME: sldemo_fuelsys_ex
PATH: examples/simulinktest/main/sldemo_fuelsys_ex.slx
BLOCKTYPE_FREQUENCY: 3;1;2;1;1;20;2;7;6;3;1;1;1;1;1;1;46;1;4;1;5;1;2;1;31;1;8;1;2;2;1;5;2;1;1;1;4;7;6;1;5;1;1;3;1
CHECKSUM: BCC8DBD87815C95AAE21D19718E11E52
PRODUCT: Embedded Coder;MATLAB;Simulink;Stateflow
PRODUCT_BASECODE: SZ
ANNOTATION:
Inputs Fault Injection Air/Fuel Ratio Fuel (g/s)  Throttle Angle  Engine Speed  EGO  Fault-Tolerant Fuel Control System Dashboard  MAP  Engine Speed (rpm)  Normal Range  Full Range  Update Diagram (Ctrl+D) to bind switches to model workspace variables. Intake Manifold Vacuum Throttle Flow vs. Valve Angle and Pressure Air-Fuel Intake Dynamics This system: - Packs individual sensors into a EngSensors bus signal - Permits bus elements data types to change - Converts signals from continuous to discrete time This system: - Permits upstream signal data type to change - Converts signals from discrete to continuous time Intake Airflow Estimation and Closed-Loop Correction Feedback Control Feedforward Control MAP Estimation Speed Estimation Throttle Estimation Feedforward Fuel Rate Disabled Mode Fuel Mode Low Mode Fuel Mode Rich Mode Fuel Mode Loop Compensation and Filtering Fuel Rate Calculation The contents of this subsystem are excluded from the code Simulink Coder generates. To work correctly this system must continue to * Contain no output ports * Enable its Treat as Atomic Unit parameter * Specify its Mask type parameter as VerificationSubsystem Verify sample time: aspects of the design assume a 0.01 second sample time. Fuel Rate Control Subsystem Fault-Tolerant Fuel Control System Copyright 1990-2023 The MathWorks, Inc.  Open the Dashboard subsystem to simulate any combination of sensor failures.

BLOCK:
 Demux ; O2_normal; SFunction ; Terminator ;Action Port;Actual Sample Time;Atmospheric Pressure, Pa (bar);Atmospheric Pressure, Pa (bar) ;Bus Creator;Bus Selector;CheckRange;Constant;DTC;Dashboard;Dashboard Scope;Data Type Conversion;Demux;Discrete Filter;Discrete Integrator;EGO Fault Switch;EGO Sensor;Engine Gas Dynamics;Engine Speed;Engine Speed Fault Switch;Engine Speed, N;Engine_Speed_Selector;Enumerated Constant;Expected Sample Time;From;Gauge;Goto;Half Gauge;In;Intake Manifold;Lamp;Limit to Positive;Logic;MAP;MAP (bar);MAP Fault Switch;MAP_Selector;MATLAB Function;Manifold Pressure, Pm (bar);Mass Airflow Rate;Merge;MinMax;Mixing & Combustion;Multiport Switch;N (rad/sec);O2_Voltage_Selector;O2_normal;Out;Oxygen Sensor Switching Threshold;Pressure Estimation;Pressure.map_estimate;Product;Pumping Constant;Quarter Gauge;RT/Vm;Ramp Rate Ki;Rate Transition;Reference;Relational Operator;Saturation;Scope;Sensor Info;Slider Switch;Sonic Flow ;Speed Estimation;Speed.speed_estimate;SubSystem;Sum;Switch Case;System Lag;Terminator;Throttle;Throttle & Manifold;Throttle Ang.;Throttle Angle Fault Switch;Throttle Angle, theta (deg);Throttle Command;Throttle Estimation;Throttle Flow, mdot (g/s);Throttle Transient;Throttle.throttle_estimate;Throttle_Angle_Selector;To Controller;To Plant;Toggle Switch;air flow;air/fuel ratio;airflow_calc;control_logic;direction;disabled_mode;ego;engine speed;es_i;es_o;est_airflow;f;f(theta);fb_correction;feedforward_fuel_rate;ff_fuel_rate;fuel;fuel rate;fuel_calc;fuel_mode;fuel_rate;fuel_rate_control;g(pratio);hold integrator;low_mode;map;mdot Input (g/s);mdot to Cylinder (g/s);normal;o2_out;p0 = 0.589 bar;rich;rich_mode;sensors;shutdown;shutoff;speed;switchable_compensation;threshold = 0.;throttle;throttle angle;u;validate_sample_time;y

BLOCKTYPE:
ActionPort;BusCreator;BusSelector;Checks_SRange;CircularGaugeBlock;Constant;DashboardScope;DataTypeConversion;Demux;DiscreteFilter;DiscreteIntegrator;DocBlock;Enumerated Constant;From;Gain;Goto;Inport;Integrator;LampBlock;Logic;Lookup_n-D;Merge;MinMax;MultiPortSwitch;Outport;Probe;Product;QuarterGaugeBlock;RateTransition;RelationalOperator;Repeating table;S-Function;Saturate;Scope;SemiCircularGaugeBlock;Signum;SliderSwitchBlock;Sum;Switch;SwitchCase;Terminator;ToggleSwitchBlock;Transfer Function with Initial Outputs;TriggerPort;VerificationSubsystem


MODELNAME: sltestABSBrakeMdlRef
PATH: examples/simulinktest/main/sltestABSBrakeMdlRef.slx
BLOCKTYPE: Constant;DataTypeConversion;Gain;Inport;Integrator;Outport;RelationalOperator;Sign;Sum;TransferFcn
BLOCKTYPE_FREQUENCY: 1;2;2;3;2;2;2;1;2;1
CHECKSUM: C5AA8AB4D5097FC97285B49D549D7FF5
PRODUCT: MATLAB;Simulink;Simulink Coder
PRODUCT_BASECODE: SZ
ANNOTATION:
Calculate the Wheel Speed for the Anti-Lock Braking System (ABS) Simulation  Copyright 2015 The MathWorks, Inc.

BLOCK:
1/I;Bang-bang controller;Brake pressure;Constant;Data Type Conversion;Force & torque;Hydraulic Lag ;Input;Relational Operator;SubSystem;Sum;Tire Torque;Wheel Speed;WheelSpeed;in_;out_


MODELNAME: sltestAccelerationPedalPositionSensorMdlRef
PATH: examples/simulinktest/main/sltestAccelerationPedalPositionSensorMdlRef.slx
ANNOTATION: Copyright 2017-2023 The MathWorks, Inc.
BLOCKTYPE: DataTypeConversion;Inport;Lookup_n-D;Outport
BLOCKTYPE_FREQUENCY: 1;2;1;2
CHECKSUM: 46BA32830623CBDFCA0903C6354A33E7
PRODUCT: AUTOSAR Blockset;Embedded Coder;MATLAB;Simulink
PRODUCT_BASECODE: SZ
BLOCK:
APP_HwIO_Value;APP_HwIO_Value_read;APP_Percent_Value;APP_Percent_Value_write;Build ERT;Data Type Conversion;Runnable_Step_sys;Setpoint Lookup;SubSystem;View Code Generation Interface


MODELNAME: sltestBaselineBasicExample
PATH: examples/simulinktest/main/sltestBaselineBasicExample.slx
BLOCK: Gain;Out;Sine Wave;Sum
BLOCKTYPE: Gain;Outport;Sin;Sum
BLOCKTYPE_FREQUENCY: 2;2;2;2
CHECKSUM: B98726366D81F63CC150284B1668FBCB
PRODUCT: MATLAB;Simulink
PRODUCT_BASECODE: SZ
DESCRIPTION:
sltestBaselineBasicExample model. This model has two outputs which can be used for baseline comparison. A variable is loaded in the model callbacks which can be modified from the workspace to try different baseline scenarios.

ANNOTATION:
 This model is used to show how baseline tests can be created and executed in the Test Manager. To see the demo, execute showdemo sltestTestManagerBaselineDemo in MATLAB(R).  Creating Baseline Tests  Copyright 2015 The MathWorks, Inc.


MODELNAME: sltestBasicCruiseControl
PATH: examples/simulinktest/main/sltestBasicCruiseControl.slx
BLOCKTYPE_FREQUENCY: 1;3;3;7;6;1;1;2;2;4;19;7;12;6;1;1;8;8;6;1
CHECKSUM: 4A30B71BE5E07D6ED842999D8C53F00C
PRODUCT: MATLAB;Simulink;Simulink Test;Simulink Test Documentation
PRODUCT_BASECODE: SZ
ANNOTATION:
Determine if the control is active Compute the target speed Simulink Test: Basic Cruise Control Copyright 2006-2022 The MathWorks, Inc. Compute the target speed Determine if the control is active Property: When the brake is applied for three consecutive steps, the throttle goes to zero. Locate Defective Behavior Simulink Test Basic Cruise Control Verification Copyright 2006-2023 The MathWorks, Inc.  This model demonstrates the output of Model Verification blocks to Simulation Data Inspector and the Test Manager. The cruise controller outputs the trottle value based on the difference between the actual and the target speeds.

BLOCK:
BrakeAssertion;Bus;Bus Selector;Cast;Constant;Controller;Discrete-Time Integrator;Enable;Implies;In;InBus;InputData(1);InputData(1).Actual_speed;InputData(1).Switches(1);InputData(1).Switches(1).brake;InputData(1).Switches(1).enable;InputData(1).Switches(1).set;InputData(1).Switches(1).setIncDec(1);InputData(1).Switches(1).setIncDec(1).dec;InputData(1).Switches(1).setIncDec(1).inc;Inputs;Kp;Logical Operator;Out;PI Controller;Reference;Relational Operator;Safety Properties;Size-Type;SubSystem;Sum;Switch;Sync;Throttle_Out;Unit Delay;constraint;error;in;target;throt

BLOCKTYPE:
Assertion;BusCreator;BusSelector;Constant;DataTypeConversion;Design Verifier Assumption;Design Verifier Implies;DiscreteIntegrator;EnablePort;Gain;Inport;Logic;Outport;RateTransition;RelationalOperator;SignalEditor;Sum;Switch;UnitDelay;VerificationSubsystem


MODELNAME: sltestBasicCruiseControlBaseline
PATH: examples/simulinktest/main/sltestBasicCruiseControlBaseline.slx
BLOCKTYPE_FREQUENCY: 3;1;3;6;1;1;2;14;3;7;6;1;4;4;2
CHECKSUM: 45870F76A1B446D4D57C06273DADC235
PRODUCT: MATLAB;Simulink;Simulink Test Documentation
PRODUCT_BASECODE: SZ
ANNOTATION:
Determine if the control is active Compute the target speed Simulink Test Basic Cruise Control for Baseline Test Copyright 2006-2022 The MathWorks, Inc.

BLOCK:
Bus;Bus Selector;Cast;Constant;Controller;Discrete-Time Integrator;Enable;In;InBus;InputData(1);InputData(1).Actual_speed;InputData(1).Switches(1);InputData(1).Switches(1).brake;InputData(1).Switches(1).enable;InputData(1).Switches(1).set;InputData(1).Switches(1).setIncDec(1);InputData(1).Switches(1).setIncDec(1).dec;InputData(1).Switches(1).setIncDec(1).inc;Inputs;Kp;Logical Operator;Out;PI Controller;Reference;Size-Type;SubSystem;Sum;Switch;Sync;Unit Delay;error;target;throt

BLOCKTYPE:
BusCreator;BusSelector;Constant;DataTypeConversion;DiscreteIntegrator;EnablePort;Gain;Inport;Logic;Outport;RateTransition;SignalEditor;Sum;Switch;UnitDelay


MODELNAME: sltestBasicCruiseControlHarnessModel
PATH: examples/simulinktest/main/sltestBasicCruiseControlHarnessModel.slx
BLOCKTYPE_FREQUENCY: 1;3;2;4;6;1;1;1;1;2;16;4;7;6;1;1;4;4;4;1
CHECKSUM: F764104B746F251F5B3ED41E79DAC783
PRODUCT: MATLAB;Simulink;Simulink Test Documentation
PRODUCT_BASECODE: SZ
ANNOTATION:
Determine if the control is active Compute the target speed Property: When the brake is applied for three consecutive steps, the throttle goes to zero. Locate Defective Behavior Simulink Test Basic Cruise Control Verification Copyright 2006-2022 The MathWorks, Inc.

BLOCK:
BrakeAssertion;Bus;Bus Selector;Cast;Constant;Controller;Discrete-Time Integrator;Enable;Implies;In;InBus;InputData(1);InputData(1).Actual_speed;InputData(1).Switches(1);InputData(1).Switches(1).brake;InputData(1).Switches(1).enable;InputData(1).Switches(1).set;InputData(1).Switches(1).setIncDec(1);InputData(1).Switches(1).setIncDec(1).dec;InputData(1).Switches(1).setIncDec(1).inc;Inputs;Kp;Logical Operator;Out;PI Controller;Reference;Relational Operator;Safety Properties;Size-Type;SubSystem;Sum;Switch;Sync;Throttle_Out;Unit Delay;constraint;error;in;target;throt

BLOCKTYPE:
Assertion;BusCreator;BusSelector;Constant;DataTypeConversion;Design Verifier Assumption;Design Verifier Implies;DiscreteIntegrator;EnablePort;Gain;Inport;Logic;Outport;RateTransition;RelationalOperator;SignalEditor;Sum;Switch;UnitDelay;VerificationSubsystem


MODELNAME: sltestCarRootInport
PATH: examples/simulinktest/main/sltestCarRootInport.slx
BLOCKTYPE_FREQUENCY: 5;2;3;6;3;33;2;7;23;6;2;5;3;1;3;3;2;1;1
CHECKSUM: BBF6F798EB0D2CC82391FCC12AF39517
PRODUCT: MATLAB;Simulink;Simulink Real-Time;Simulink Test;Simulink Test Documentation;Stateflow
PRODUCT_BASECODE: SZ
ANNOTATION:
Vehicle TORQUE CONVERTER  Simulink® Test™ model sltestCarRootInport Copyright 1997-2024 The MathWorks, Inc. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
 Demux ; SFunction ; Terminator ; gear;Engine;From;Goto;Inport_;Input Conversion Subsystem;Integrator;K factor;Look-Up;Look-Up Table;Ne;Nin;Nout;Out;Outport_;Output Conversion Subsystem;Product;Rate Transition;SigSpec_;Sign;SubSystem;Sum;Ti;Tin;Torque Converter;Torque ratio;Tout;Tt;Vehicle;brake;brake torque;down_th;engine + impeller inertia;engine torque;f;final drive ratio;gear;impeller;interp_down;interp_up;linear speed;mph;out;quotient;road load;selection_state.calc_th;shift_logic;signed load;speed;speed ratio;throttle;transmission;transmission output speed;transmission output torque;transmission ratio;turbine;up_th;vehicle inertia;vehicle speed;wheel speed

BLOCKTYPE:
Demux;Fcn;From;Gain;Goto;Inport;Integrator;Lookup_n-D;Outport;Product;RateTransition;S-Function;SignalSpecification;Signum;Sum;Terminator;TriggerPort;torque converter;vehicle model


MODELNAME: sltestCruiseControl
PATH: examples/simulinktest/main/sltestCruiseControl.slx
DESCRIPTION: Cruise Control Model
BLOCKTYPE_FREQUENCY: 5;1;1;10;7;5;1;3;140;3;2;2;112;9;2;50;6;6;2
CHECKSUM: 0B1743709F30141C712D028DDFC383B1
PRODUCT: Embedded Coder;MATLAB;Simulink;Simulink Test;Simulink Test Documentation
PRODUCT_BASECODE: SZ
EXTERNALFILE_REFERENCE: sltestCruiseControlMode.slx___Model_Block___sltestDriverSwRequest.slx___Model_Block___
ANNOTATION:
Copyright 2021 The MathWorks, Inc. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the source blocks to the interface required by the harnessed component. Modifying the contents of this subsystem may result in compilation and simulation failure. This subsystem has been inserted by Simulink to adapt the output of the harnessed component to the interface required by the sink blocks. Modifying the contents of this subsystem may result in compilation and simulation failure.

BLOCK:
Activate;Add;Constant;CruiseControlMode;DTI ;Delay;DriverSwRequest;Enable;EnumConst;From;Goto;Inport_;Input Conversion Subsystem;Kp;LogicOp;Logical Operator;Merge;Outport_;Output Conversion Subsystem;PI controller;Reference;Relational Operator;Saturation;SigSpec_;SubSystem;Sum;Switch;TargetSpeedThrottle;UnitDelay;UsePI;activated;brakeP;cncl;dec;disabled;enabled;enbl;gear;getNewTargetSpeed;harness_enable_port;harness_in_;harness_out_;inc;isActivated;isDisabled;isEnabled;isResumed;key;mode;operation_mode;relop;reqDrv;resume;set;status;storeSpeed;stored_targetSp;targetSp;targetSpIn;targetSp_in;targetSp_pre;targetSp_prev;targetSpeed;throt;throtCC;throtDrv;throtPI;throttleCC;toBoolean;vehSp;yesno

BLOCKTYPE:
Constant;Delay;DiscreteIntegrator;EnablePort;Enumerated Constant;From;Gain;Goto;Inport;Logic;Merge;ModelReference;Outport;RelationalOperator;Saturate;SignalSpecification;Sum;Switch;UnitDelay


