Simulink® HDL Coder™

Language Support

Fixed-Point Runtime Library Support

The coder supports most of the fixed-point runtime library functions supported by the Embedded MATLAB Function block. For a complete list of these functions, see Supported Functions and Limitations of the Fixed-Point Embedded MATLAB Subset in the Fixed-Point Toolbox documentation.

Some functions are not supported, or are subject to some restrictions. These functions are summarized in the following table.

Back to Top

Variables and Constants

This section summarizes supported data types and typing rules for variable and constants, and the use of persistent variables in modeling registers.

Data Type Usage

When generating code for the Embedded MATLAB Function block, the coder supports a subset of MATLAB data types. The following table summarizes supported and unsupported data types.

Typing Ports, Variables and Constants

Strong typing rules are applied to Embedded MATLAB Function blocks, as follows:

• All input and output port data types must be resolved at model compilation time.

  • If the data type of an input port is unspecified when the model is compiled, the port is assigned the data type of the signal driving the port.

  • If the data type of an output port is unspecified when the model is compiled, the output port type is type is determined by the first assignment to the output variable.

• Similarly, all constant literals are strongly typed. If you do not specify the data type of a constant explicitly, its type is determined by internal rules. To specify the data type of a constant, use cast functions (e.g., uint8, uint16, etc.) or fi functions using fimath specifications.

• After you have defined a variable, do not change its data type. Variable types cannot be changed dynamically by assigning a different value. Dynamic typing will lead to a compile time error.

• After you have defined a variable, do not change its size. Variables cannot be grown or resized dynamically.

• Do not use output variables to model registered output; Embedded MATLAB Function block outputs are never persistent. Use persistent variables for this purpose, as described in Persistent Variables.

Persistent Variables

Persistent variables let you model registers. If you need to preserve state between invocations of an Embedded MATLAB Function block, use persistent variables.

Each persistent variable must be initialized with a statement specifying its size and type before it is referenced. You can initialize a persistent variable with either a constant value or a variable, as in the following code listings:

% Initialize with a constant
persistent p;
if isempty(p)
    p = fi(0,0,8,0); 
end

% Initialize with a variable
initval = fi(0,0,8,0);

persistent p;
if isempty(p)
    p = initval; 
end

When testing whether a persistent variable has been initialized, it is good practice to use simple logical expressions, as in the preceding examples. Using simple expressions ensures that the HDL code for the test is generated in the reset process, and therefore is executed only once.

You can initialize multiple variables based on a single simple logical expression, as in the following example:

% Initialize with  variables
initval1 = fi(0,0,8,0);
initval2 = fi(0,0,7,0);

persistent p;
if isempty(p)
    x = initval1; 
    y = initval2; 
end

See also The Incrementer Function Code for an example of the initialization and use of a persistent variable.

Note   If persistent variables are not initialized properly, unnecessary sentinel variables can appear in the generated code.

Limitation on Use of Persistent Variables.   As described in Using Persistent Variables to Model State, you can use persistent variables in Embedded MATLAB code to simulate various kinds of delay blocks.

However, note that the ports on the Embedded MATLAB Function block act as direct feedthrough ports during simulation. The delay constructs internal to the Embedded MATLAB Function block are not recognized during simulation. Therefore a feedback loop in the model causes an algebraic loop condition.

To work around this limitation:

• Keep the combinatorial logic inside the Embedded MATLAB Function block for one of the blocks in the loop which has a persistent variable for the output or input. Remove the persistent variable.

• Place a Unit Delay block external to the Embedded MATLAB Function block.

Back to Top

Use of Nontunable Parameter Arguments

An Embedded MATLAB function argument can be declared to be a parameter argument by setting its Scope to Parameter in the Ports and Data Manager GUI. Such a parameter argument does not appear as a signal port on the block. Parameter arguments for Embedded MATLAB Function blocks do not take their values from signals in the Simulink model. Instead, their values come from parameters defined in a parent Simulink masked subsystem or variables defined in the MATLAB base workspace.

Only nontunable parameters are supported for HDL code generation. If you declare parameter arguments in Embedded MATLAB function code that is intended for HDL code generation, be sure to clear the Tunable option for each such parameter argument.

See also Parameter Arguments in Embedded MATLAB Functions in the Simulink documentation.

Back to Top

Arithmetic Operators

When generating code for the Embedded MATLAB Function block, the coder supports the arithmetic operators (and their M-function equivalents) listed in the following table.

Back to Top

Relational Operators

When generating code for the Embedded MATLAB Function block, the coder supports the relational operators (and their M-function equivalents) listed in the following table.

Back to Top

Logical Operators

When generating code for the Embedded MATLAB Function block, the coder supports the logical operators (and their M function equivalents) listed in the following table.

Back to Top

Control Flow Statements

When generating code for the Embedded MATLAB Function block, the coder imposes some restrictions on the use of control flow statements and constructs. The following table summarizes supported and unsupported control flow statements.

Unstructured flow graph or loop containing 
[statement type] not supported for HDL

Unstructured flow graph or loop containing 
[statement type] not supported for HDL

Unstructured flow graph or loop containing 
[statement type] not supported for HDL

for i=eml.unroll(1:2:8) 
    ... 
   end 

Back to Top

Recommended Practices

Other Limitations