Target Language Compiler

Generating Code for Models with States

Objective: Look at Real-Time Workshop code generation for the models that have states. This does not involve many new Real-Time Workshop concepts, but it is instructive to see the changes in the generated C code as opposed to the sfun_x2.mdl on page 8-3, for example.

This is not an assignment per se, but rather a demonstration of the process involved, from designing a model to generating and using the code. This choice of model involves some subtleties, which you will see in the discussion ahead:

1. Open the springsfun.mdl model located in the tlctutorial/states subdirectory. This is the model of a linear system with transfer function

that represents a simple SISO system. The picture of the model is given below.

2. Before executing the model, run the m-file initialize.m that is in the same subdirectory. This generates initial parameters for the system. These parameters are in the form of a random, stable, eighth order linear system. Once this is done, the model is ready to execute.
3. Examine the properties of the SiSoSF S-function block and the state space block. Both of these blocks are intended to do exactly the same thing, so that they can be checked against each other. The S-function, sisosf, is the state space equivalent of above, in the controllable canonical form. Therefore, the system is described by being the state in question

where u(t) is the control signal. The output y(t) is given by y(t) = a₀x₀.

This same information is incorporated in the state space block, via matrices a, b, c, and d. The order of the states, however, may be different from that given above, with the differences being those of nomenclature, and not of fact.

4. The S-function is driven by the program sisosf.c, which is also found in this directory. If the precompiled version of sisosf.c (sisosf.dll) is not in your directory, you will need to compile it with the command

mex sisosf.c.

Also, study the sisosf.c program. This program was created by editing a copy of the sfuntmpl.c program template, which is what you are advised to do. Note the various macros (ssNumSetSFcnParams, ssSetSFcnParamNotTunable, ssGetContStates, etc.) that are used to access the SimStruct structure to get/set the various model parameters. These macros are defined in simstruc.h and described in the Simulink book Writing S-Functions. Some things to be noted are:

• The parameter vector that is passed to SiSoSF are the ai values, which form the last line of the A matrix. The length of this vector determines the number of states (MdlInitializeSizes).
• The initial conditions have been chosen as x0 = 1.0, xi = 0.0 if i0. This is an arbitrary choice, and a real program (as opposed to an example) would have this as a parameter. However, this choice has been made to keep things simple (MdlInitializeConditions, which is optional).
• The MdlDerivatives function is the heart of the program and should be studied carefully. The xdot vector stores the derivatives, and xdot[7] (in this case) and more generally xdot[NCStates-1] is calculated incrementally. Additionally, the fact that x and xdot have disparate indices in the line

    xdot[i] = x[i+1];

should be noted, since this causes some complications in the TLC file.

5. The next step is to write a .tlc file to enable the inlining S-function. This has already been done for you, and the file is called sisosf.tlc. A listing of the file follows.

%% FileName: sisosf.tlc
%%
%% Purpose: To implement a SISO system in controllable canonical form.
%implements "sisosf" "C"

%% Function: Outputs ==========================================================
%%
%function Outputs(block,system) Output
  %assign y  = LibBlockOutputSignal(0,"","",0)
  %assign x  = LibContinuousState("","",0)
  %assign dc = LibBlockParameter(P1,"","",0)
  %% Dc gain is the negative of the first element of the

  %% The first state (zeroth derivative) is the output
  /* Block %<Name>: %<Type>  Output */
  %<y> = -%<dc> * %<x>;
%endfunction    %% Outputs

%% Function: Derivatives ======================================================
%%
%function Derivatives(block,system) Output
  %assign ncStates = ContStates[0]
  %assign offset   = ContStates[1]
  %assign input    = LibBlockInputSignal(0,"","",0)
  /* Derivatives function starts here */
  {
    real_T *dx = ssGetdX(%<tSimStruct>);

    dx[%<ncStates - 1 + offset>] = %<input> + \
                                   %<LibBlockParameter(P1,"","",0)> * \
                                   %<LibContinuousState("","",0)>;
  %assign rollVars = ["Xc", "<param>/P1"]
  %roll xIdx = [0:%<ncStates-2>],xlcv = RollThreshold, block, "Roller", rollVars
    %assign idx = (xlcv != "") ? "%<xIdx+offset> + %<xlcv>" : "%<xIdx+offset>"
    %assign lcv = (xlcv != "") ? "1 + %<xlcv>" : ""
    %assign x = LibContinuousState("",lcv,xIdx+1)
    %assign a = LibBlockParameter(P1,"",lcv,xIdx+1)
    /* Block %<Name>: %<Type> derivatives */
    dx[%<idx>] = %<x>;
    dx[%<ncStates - 1 + offset>] += %<a> * %<x>;
  %endroll
  }
%endfunction    %% Derivatives

%% Function: InitializeConditions =============================================
%%
%function InitializeConditions(block,system) Output
  %assign ncStates = ContStates[0]

  %% Initialize State zero (position) to 1.0, rest are 0.0
  %assign x = LibContinuousState("","",0)
  /* %<Type>: %<Name> Position Initialization */
  %<x> = 1.0;

  %foreach sigIdx = ncStates - 1
    %assign x = LibContinuousState("","",sigIdx+1)
    /* %<Type>: %<Name> Other States Initialization */
    %<x> = 0.0;

  %endforeach
%endfunction    %% InitializeConditions

%% [EOF] sisosf.tlc

Generating Auxiliary Files for Batch FTP

Derivatives Function