Chapter 14  Preparing Models for Use with Reactis

To use Reactis on a Simulink / Stateflow model, a user 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 not, please let us know what features or blocks are lacking. Reactive Systems uses such feedback to prioritize enhancements to Reactis.

14.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.

14.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 included in .m files that are attached to a model using Simulink’s pre-load callback. 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 Simulink window, select the File -> 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 pre-load 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.

14.1.2  Unsupported MATLAB Features

While Reactis supports most of MATLAB , the following exceptions may not be used in Simulink / Stateflow models, e.g. in callbacks or mask initializations.

14.2  Simulink

Reactis currently supports Simulink versions 4.0 through 7.5 (MathWorks releases R12 through R2010a). Most features of Simulink are supported. Some notable exceptions are:

• Simulink signals with more than 2 dimensions are not supported.
• Reactis does not support the use of complex values (i.e. values with real and imaginary parts) in Simulink signals
• Models must not contain 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 14.2.3 and below. 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.

14.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 Simulink user’s guide)
• 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.

14.2.2  Lookup Tables

This section describes the settings for each of the standard Simulink Lookup Table blocks that are supported by Reactis. Some settings might not be relevant depending on the version of MATLAB used. For example, many data type settings for the “Lookup Table (n-D)” block were only introduced in MATLAB R2009b and therefore are not relevant when using Reactis with MATLAB R2009a or earlier.

Lookup Table

All block settings and the following data type combinations are supported. “fixpoint” includes all fixed-point data types as well as built-in integer data types int8, uint8, int16, uint16, int32, and uint32.

Lookup Table (2-D)

All block settings and the following data type combinations are supported. “fixpoint” includes all fixed-point data types as well as built-in integer data types int8, uint8, int16, uint16, int32 and uint32.

Look-Up Table (n-D)

The following restrictions for data types apply for these tables in Reactis:

• Input, output, intermediate and fraction data types must be floating-point (double or single).
• Breakpoint data type must match input data type.
• Table data type must match output data type.
• Intermediate results data type must match output data type.
• If the number of dimensions is 2 or higher then data types of all inputs and outputs must be the same.

Reactis natively supports 1-d and 2-d configurations not using "cubic spline" interpolation. For those configurations Reactis will also track coverage.

All other valid configurations are supported via 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 even with R2007b and later.

Direct Lookup Table (n-D)

Only floating-point (double and single) data types are supported.

This table is supported in Reactis via the sfun_nddirectlook.mexw32 S-Function that comes with MATLAB R2009a and earlier. Starting with MATLAB R2009b, this S-Function is no longer included in the MATLAB distribution. However, if a sfun_lookupnd.mexw32 from R2009a or earlier is placed in Reactis’ search path, Reactis can use that S-Function even with R2009b and later.

Look-Up Table Dynamic

All parameters and the data type configurations listed for the “Lookup Table” block above are supported.

Prelookup

All parameters are supported. The following data type restrictions apply:

• Only floating-point (double and single) input data types are supported.
• Only “int32” and “uint32” are supported as the data type of the “index” output.
• Only “single” and “double” are supported as the data type of the “fraction” output.

Interpolation using Prelookup

All parameters are supported. The following data type restrictions apply:

• Only floating-point (double and single) data types are supported for “fraction” inputs.
• Data types of all “fraction” inputs must be the same as the output data type.
• Only “int32” and “uint32” are supported as the data type of the “index” input.
• Table data type must match output data type
• Intermediate results data type must match output data type.

14.2.3  MathWorks R12

14.2.4  MathWorks R13

14.2.5  MathWorks R14, R2006a, R2006b

14.2.6  R2007a

14.2.7  R2007b

14.2.8  R2008a, R2008b, R2009a, R2009b, R2010a

14.2.9  Simulink Extras

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

14.2.10  TargetLink Library Blocks

The following table lists the supported blocks from the dSPACE TargetLink library, if installed:

14.3  Stateflow

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

• Implicit “enter”, “exit” and “change” events
• Range limits for variables.
• “ml.” namespace operator and “ml()” function call.
• Embedded MATLAB code.
• When using expressions in the ’size’ field of a Stateflow variable declaration, all references to constants within the expression must refer to constants that are defined in the MATLAB workspace.
• 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).
• Using “bind” actions.
• The operators hasChanged, hasChangedTo, hasChangedFrom.
• Graphical functions with multiple outputs.
• Absolute time in temporal logic operators (i.e. using the sec keyword).
• The temporalCount operator.
• Simulink function-call subsystems.
• Enumerated datatypes.
• Keywords true and false.