Chapter 15  Preparing Models for Use with Reactis

To use Reactis on a Simulink / Stateflow model, you must ensure that the model satisfies certain constraints. This chapter describes what these constraints are. Please note that, while every effort is made to maintain the accuracy of the following list of supported and unsupported features, due to the complexity and continual evolution of the Simulink / Stateflow notation, this description may not be complete. For example, some blocks listed as supported do not support all parameters for the block. A block or feature not listed as either supported or unsupported should be assumed to be unsupported.

We encourage all potential customers to take advantage of a free evaluation license for Reactis to determine if the subset of Simulink / Stateflow supported by Reactis is adequate for your models. If it’s not, please let us know what features or blocks you would like to see Reactis support. Reactive Systems uses such feedback to prioritize enhancements to Reactis.

15.1  MATLAB

Reactis can process Simulink / Stateflow models that contain MATLAB code in callbacks or mask initializations, provided that certain conventions are observed. On the one hand, files that define workspace data items referred to in a model must be “connected” to the model appropriately, and certain MATLAB functions should be avoided. The remainder of this section elaborates on these points.

15.1.1  Workspace Data Items

Reactis invokes MATLAB to evaluate many MATLAB expressions, but it does not directly interact with an executing MATLAB session in the same way that Simulink does. For this reason, any workspace data items that a model uses must be initialized within one of the following locations :

• Any Simulink model callback or block callback that is executed when loading or running the model (PreLoadFcn, PostLoadFcn, InitFcn, StartFcn).
• A “startup.m” file located in the folder where the model file is located. When using this method, make sure that the “Execute startup.m and pathdef.m scripts in model folder” is checked in the “General” tab of the Reactis Info File Editor.
• The “Callbacks” tab of the Reactis Info File Editor. If in your environment the MATLAB workspace for your model is set up via some external script or graphical user interface prior to loading the model, you can add the initialization code here so Reactis knows how to set up the workspace. Reactis will automatically execute the “Pre-Load Function” code prior to loading the model and the “Post-Load Function” code after loading the model. This method allows you to use Reactis in such an environment without having to modify your model.
• The Simulink Data Dictionary.

For the cruise control example, the file cruise_constants.m defines two workspace variables that are used in cruise.mdl. One attaches cruise_constants.m to cruise.mdl as follows:

1. Load cruise.mdl into Simulink.
2. From the Modeling tab toolbar, select the Model Settings > Model Properties menu item.
3. In the resulting dialog, select the Callbacks tab.
4. In the Model pre-load function entry box enter cruise_constants;.
5. Save the model.

In general, using the PreLoadFcn callback in this manner is good modeling practice, since once the .m files are attached to a model file, loading the model file into Simulink (and not just Reactis) will automatically load the .m files as well.

15.1.2  Unsupported MATLAB Features

If any of the following MATLAB functions are used in the callbacks or mask initializations of a model, then the Reactis “Propagate set_param" setting must be enabled. To enable the feature for a model, load the model, select menu item Edit > General, and then check the box “Propagate set_param changes by saving the model to a temporary file”. To enable this feature for all models, select File > Model Defaults... and then check the box “Propagate set_param changes by saving the model to a temporary file” in the General tab. If this setting is enabled, Reactis will cause Simulink to apply all the changes to the model, then automatically save them to a temporary file. Reactis then imports the temporary model to see the applied changes.

15.2  Simulink

Reactis currently supports Simulink releases R2013a through R2023a. Most features of Simulink are supported; but the following are not supported by Reactis:

• Continuous-time blocks.
• The use of complex values (i.e. values with real and imaginary parts).
• Models containing corresponding DataStoreWrite/DataStoreRead blocks whose execution order is not explicitly defined by either the model logic or priorities.

For the subset of Simulink blocks supported by Reactis please refer to Section 15.2.3. For blocks that can be either continuous- or discrete-time, only the discrete-time version is supported. For some blocks identified as supported, not all settings are supported.

Reactis supports the fixed-step and variable-step discrete solvers for models that do not contain any continuous-time blocks. For variable-step solvers, the “Max step size” setting is supported.

15.2.1  S-Functions

Reactis supports both C-Coded and M-File S-functions, with some restrictions. For C-Coded S-functions, the following are not supported by Reactis:

• Port-based sample times.
• Multiple sample times.
• Complex number signals.
• Zero-crossing detection.
• Output of function-calls.
• Level 1 S-functions (For a guide on how to convert Level 1 S-functions to Level 2 S-functions — which are supported by Reactis - please consult the MathWorks documentation)
• Calling any function from MATLAB’s “mex” library (including mexCallMATLAB, mexEvalString and mexGetVariable) from an S-Function.

For M-File S-functions, the following are not supported by Reactis:

• Multiple sample times.
• Complex number signals.
• Level 2 S-functions.

In addition to the above restrictions, care must be taken about any internal data that is stored by S-functions. In order to work properly, Reactis must be able to retrieve and reset the values of all internal states of any S-function occurring within a model. The best way to make internal states visible to Reactis (and Simulink) is to declare the appropriate number of discrete states in the mdlInitializeSizes() function and then use the state vector that Reactis and Simulink will provide. Reactis will also save and restore memory that an S-function allocates as a result of calling the ssGetNumRWork() and ssGetNumIWork() during mdlInitializeSizes.

Reactis has no way of knowing about any other persistent data that an S-function maintains by other means, such as:

• global or static variables in C-code;
• memory allocated by malloc() or mxMalloc() functions in C-code;
• Use of workspace variables in M-File S-functions.

Reactis will also not save and restore memory requested by ssGetNumPWork(), since otherwise pointers stored in this vector by your S-function might get lost or mangled, resulting in memory leaks or crashes.

If an S-function stores internal states in any of the unsupported ways described above, Reactis will seem to work properly, but the test suites generated by Tester may include wrong outputs. One sign of this can be if you run a test suite in Simulator and get an error message saying “Model fails test”. Another problem of such invalid use of internal states may be invalid outputs after using the “back” buttons in Simulator.

In general, Reactis passes S-Function parameters as fixed values at the time the S-Function is first initialized (i.e. when Tester or Simulator is started). Therefore, if a configuration variable is used as a parameter to an S-Function, the S-Function will not see any changes to the configuration variable unless the S-Function is designed to process such updates. To have an S-Function be updated on changes to its parameters, define a mdlProcessParameters function (see Simulink documentation) within the S-Function code. If this function is present, then Reactis will propagate the parameter changes into the S-Function by calling the S-Function’s mdlProcessParameters function at each step with the new parameter values. In the mdlProcessParameters function, the S-Function can then take appropriate actions if any parameters have changed.

15.2.2  Lookup Tables

This section describes the settings for each of the standard Simulink lookup table blocks that are supported by Reactis. Note that MathWorks has changed the names of these blocks and their settings over different releases. We use the R2023a terminology here. If you are using an older version of MATLAB, your block names and settings may be slightly different.

15.2.2.1  1-D Lookup Table

Note that this block was previously named Lookup Table. A 1-D lookup table is equivalent to an n-D Lookup Table with one dimension. See Section 15.2.2.3 for details on which parameter and type combinations are supported in Reactis.

15.2.2.2  2-D Lookup Table

Note that this block was previously named Lookup Table (2-D). A 2-D lookup table is equivalent to an n-D Lookup Table with two dimensions. See Section 15.2.2.3 for details on which parameter and type combinations are supported in Reactis.

15.2.2.3  n-D Lookup Table

Note that this block was previously named Lookup Table (n-D). Reactis supports a wide variety of n-D lookup tables, subject to restrictions which depend on the number of table dimensions. There are two levels of support, native and via S-function.

Native support means Reactis will natively execute the n-D Lookup Table block and track coverage for it. An n-D Lookup Table is natively supported if it satisfies the following requirements:

1. The number of dimensions is at most four.
2. The interpolation method is linear or flat.
3. The extrapolation method is linear or clip.
4. None of the inputs or outputs have enumerated types.
5. If the intermediate type is set to Inherit via Internal Rule, then all input, output, breakpoint, and table data types are either (1) a floating-point data type, or (2) a fixed-point type with a binary-point scaling and a bias of zero.
6. The Internal rule priority is set to Precision. It may also be set to Speed if Reactis has been configured to allow it. The behavior of Reactis is controlled by the setting If lookup table uses internal rule priority ’Speed’ in the General pane of the Reactis Info File Editor (see Section 5.8).

15.2.2.4  Lookup table support via S-function

Support via S-function requires MATLAB R2017b or earlier: it is not available with R2018a and later. Support via S-function means Reactis can execute the n-D lookup block but not track coverage. In order to execute the block, Reactis requires the sfun_lookupnd.mexw32 S-Function that comes with MATLAB R2007a or earlier. Starting with MATLAB R2007b, this S-Function is no longer included in the MATLAB distribution. However, if a sfun_lookupnd.mexw32 from R2007a or earlier is placed in Reactis’ search path, Reactis can use that S-Function with MATLAB R2007b to R2017b, but not with R2018a and later.

n-D lookup tables which meet the following requirements are supported via S-function in Reactis:

1. The input and output types are the same floating-point type.
2. The fraction data type is set to Inherit via internal rule.
3. The table data type is set to Inherit: same as output.
4. The breakpoint data type is set to Inherit: same as corresponding input.
5. All inputs are scalars.
6. If the table has more than one dimension, then the intermediate data type is set to Inherit: same as output.

15.2.2.5  Lookup Table Dynamic

All parameters and data type configurations listed for the 1-D Lookup Table in Section 15.2.2.1 are supported.

15.2.2.6  Prelookup

There are two levels of support for the Prelookup block in Reactis, native and via S-function.

Native support means Reactis will natively execute the Prelookup block and track coverage for it. Reactis natively supports Prelookup blocks which meet the following requirements:

1. The breakpoint data specification is Explicit Values or Breakpoint Object.
2. The breakpoint data source is Dialog or Input port.
3. The extrapolation method is linear or clip.

Support via S-function means Reactis can execute the Prelookup block but not track coverage. In order to execute the block, Reactis requires the sfun_idxsearch.mexw32 S-Function that comes with all versions of MATLAB.

The following data types are supported:

1. The breakpoint type is double or single.
2. The index type is int32 or uint32.
3. The fraction type is double or single.

15.2.2.7  Interpolation Using Prelookup

There are two levels of support for the Interpolation Using Prelookup block in Reactis, native and via S-function.

Native support means Reactis will natively execute the Interpolation block and track coverage for it. Only Interpolation Using Prelookup blocks which satisfy the following requirements are natively supported in Reactis:

1. The number of dimensions is at most four.
2. The number of sub-table selection dimensions is less than or equal to the number of dimensions.
3. The interpolation method is linear or flat.
4. The extrapolation method is linear or clip.
5. None of the inputs or outputs have enumerated types.
6. If the intermediate type is set to Inherit via Internal Rule, then all input, output, breakpoint, and table data types are either (1) a floating-point data type, or (2) a fixed-point type with a binary-point scaling and a bias of zero.
7. The Internal rule priority is set to Precision. It may also be set to Speed if Reactis has been configured to allow it. The behavior of Reactis is controlled by the setting If lookup table uses internal rule priority ’Speed’ in the General pane of the Reactis Info File Editor (see Section 5.8).

Support via S-function means Reactis can execute the Interpolation block but not track coverage. In order to execute the block, Reactis requires the sfun_kflookupnd.mexw32 S-Function that comes with all versions of MATLAB.

All parameters are supported. Blocks which satisfy the following requirements are supported:

1. Only floating-point (double and single) data types are supported for “fraction” inputs.
2. All fraction types must be the same as the output data type.
3. All index types must be int32 or uint32.
4. Table data type must match output data type.
5. Intermediate results data type must match output data type.

15.2.3  Table of Supported Blocks

15.2.4  Simulink Extras

The following table lists the supported blocks from the “Simulink extras” library which is available in all MATLAB versions:

15.2.5  HDL Coder Blockset

The following table lists the supported blocks from the HDL Coder blockset:

15.2.6  TargetLink 2.2.1 Library Blocks

The following table lists the supported blocks from the dSPACE TargetLink library (version 2.2.1), if installed:

15.2.7  TargetLink 2.3.1 Library Blocks

The following table lists the supported blocks from the dSPACE TargetLink library (version 2.3.1), if installed:

15.2.8  TargetLink 3.0 to 3.4 Library Blocks

The following table lists the supported blocks from the dSPACE TargetLink library (versions 3.0 to 3.4), if installed:

15.2.9  TargetLink 3.5 to 22.1 (2022-B) Library Blocks

The table below lists the supported blocks from the dSPACE TargetLink library versions 3.5 to 22.1 (2022-B). Note that TargetLink 2022-B is not certified to work with MATLAB R2023a.

15.3  Stateflow

Reactis supports most of Stateflow. Some exceptions are the following unsupported features:

• Charts with the action language set to MATLAB are currently supported if they use the language subset described in Section 15.4. Charts with “C” action language are supported.
• Implicit “enter”, “exit” and “change” events
• Range limits for variables.
• “ml.” name-space operator and “ml()” function call.
• Embedded MATLAB code. Reactis supports the language subset described in Section 15.4.
• Using Stateflow keywords as variable names. The Stateflow keywords are: at, after, before, change, du, during, enter, en, entry, every, ex, exit, in, on, ml, send, abs, acos, asin, atan, atan2, ceil, cos, cosh, exp, fabs, floor, fmod, labs, ldexp, log, log10, min, max, pow, rand, rem, sin, sinh, sqrt, tan, tanh, int8, int16, int32, uint8, uint16, uint32, double, boolean.
• The explicit type cast function (“cast”).
• The address operator (&) is supported only in calls to external C functions.
• The pointer operator (*) is supported only inside a literal C code section.
• Charts without trigger or sample time are supported only if the model has a fixed sample time.
• In some cases, the detection of inner transitions fails for odd-shaped transitions (for example, single transition segments which leave and reenter a state).
• The temporalCount operator.
• Atomic Subcharts (introduced in R2010b).

15.4  Embedded MATLAB

Reactis V2012 introduced black-box support for Embedded MATLAB. This includes:
 Simulink
   •  MATLAB Function block
   •  Truth Table block
 Stateflow
   •  MATLAB functions
   •  Truth Table functions with MATLAB language option
   •  MATLAB action language in Stateflow
Note that a subset of the full Embedded MATLAB language is supported. To use models containing Embedded MATLAB in Reactis, your model must only use the language subset supported by Reactis. Note that the same language restrictions apply no matter which of the five model constructs listed above are used to incorporate Embedded MATLAB into your model. To avoid confusion, we use the following abbreviations in the following discussion:

Embedded MATLAB (EML)

the subset of MATLAB supported by MathWorks for code generation.

Reactis Embedded MATLAB (REML)

the subset of EML supported by Reactis.

REML is under active development towards the ultimate goal of supporting a very large subset of EML. Please send requests to Reactive Systems (help@reactive-systems.com) if there are unsupported EML features you would like to use.

The V2015 release of Reactis included a new product: the Reactis for EML Plugin. It integrates with Reactis to offer white-box testing of the EML portions of a model. See Chapter 18 for a description of the Reactis for EML Plugin. If not using the new product, you can still test models containing EML; however, exercising coverage targets within the EML will not be an objective of test generation and tracking this coverage will not be available. Whether in white-box or black-box mode for EML, Reactis supports the same subset of EML. This subset is defined in Section 18.4.