Writing S-Functions

Example of a Discrete State S-Function

The matlabroot/simulink/src/dsfunc.c example shows how to model a discrete system in a C MEX S-function. Discrete systems can be modeled by the following set of equations.

dsfunc.c implements a discrete state-space equation. The output portion is placed in mdlOutputs and the update portion in mdlUpdate. To visualize how the simulation works, refer to the flowchart in How Simulink Interacts with C S-Functions. The output equation above corresponds to the mdlOutputs in the major time step. The preceding update equation corresponds to the mdlUpdate in the major time step. If your model does not contain continuous elements, the integration phase is skipped and time is moved forward to the next discrete sample hit.

matlabroot/simulink/src/dsfunc.c

• /*  File    : dsfunc.c
   *  Abstract:
   *
   *      Example C-file S-function for defining a discrete system.  
   *
   *      x(n+1) = Ax(n) + Bu(n)
   *      y(n)   = Cx(n) + Du(n)
   *
   *      For more details about S-functions, see simulink/src/sfuntmpl_doc.c.
   * 
   *  Copyright 1990-2000 The MathWorks, Inc.
   */
  
  #define S_FUNCTION_NAME dsfunc
  #define S_FUNCTION_LEVEL 2
  
  #include "simstruc.h"
  
  #define U(element) (*uPtrs[element])  /* Pointer to Input Port0 */
  
  static real_T A[2][2]={ { -1.3839, -0.5097 } ,
                          {  1     ,  0      }
                        };
   
  static real_T B[2][2]={ { -2.5559,  0      } ,
                          {  0     ,  4.2382 }
                        };
   
  static real_T C[2][2]={ {  0     ,  2.0761 } ,
                          {  0     ,  7.7891 }
                        };
   
  static real_T D[2][2]={ { -0.8141, -2.9334 } ,
                          {  1.2426,  0      }
                        };
   
  
  /*====================*
   * S-function methods *
   *====================*/
  
  /* Function: mdlInitializeSizes ===============================================
   * Abstract:
   *    The sizes information is used by Simulink to determine the S-function
   *    block's characteristics (number of inputs, outputs, states, etc.).
   */
  static void mdlInitializeSizes(SimStruct *S)
  {
      ssSetNumSFcnParams(S, 0);  /* Number of expected parameters */
      if (ssGetNumSFcnParams(S) != ssGetSFcnParamsCount(S)) {
          return; /* Parameter mismatch will be reported by Simulink */
      }
  
      ssSetNumContStates(S, 0);
      ssSetNumDiscStates(S, 2);
  
      if (!ssSetNumInputPorts(S, 1)) return;
      ssSetInputPortWidth(S, 0, 2);
      ssSetInputPortDirectFeedThrough(S, 0, 1);
  
      if (!ssSetNumOutputPorts(S, 1)) return;
      ssSetOutputPortWidth(S, 0, 2);
  
      ssSetNumSampleTimes(S, 1);
      ssSetNumRWork(S, 0);
      ssSetNumIWork(S, 0);
      ssSetNumPWork(S, 0);
      ssSetNumModes(S, 0);
      ssSetNumNonsampledZCs(S, 0);
  
      /* Take care when specifying exception free code - see sfuntmpl_doc.c */
      ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE);
  }
  
  
  
  /* Function: mdlInitializeSampleTimes =========================================
   * Abstract:
   *    Specifiy that we inherit our sample time from the driving block.
   */
  static void mdlInitializeSampleTimes(SimStruct *S)
  {
      ssSetSampleTime(S, 0, 1.0);
      ssSetOffsetTime(S, 0, 0.0);
  }
  
  
  
  #define MDL_INITIALIZE_CONDITIONS
  /* Function: mdlInitializeConditions ========================================
   * Abstract:
   *    Initialize both discrete states to one.
   */
  static void mdlInitializeConditions(SimStruct *S)
  {
      real_T *x0 = ssGetRealDiscStates(S);
      int_T  lp;
  
      for (lp=0;lp<2;lp++) { 
          *x0++=1.0; 
      }
  }
  
  
  
  /* Function: mdlOutputs =======================================================
   * Abstract:
   *      y = Cx + Du 
   */
  static void mdlOutputs(SimStruct *S, int_T tid)
  {
      real_T            *y    = ssGetOutputPortRealSignal(S,0);
      real_T            *x    = ssGetRealDiscStates(S);
      InputRealPtrsType uPtrs = ssGetInputPortRealSignalPtrs(S,0);
   
      UNUSED_ARG(tid); /* not used in single tasking mode */
  
      /* y=Cx+Du */
      y[0]=C[0][0]*x[0]+C[0][1]*x[1]+D[0][0]*U(0)+D[0][1]*U(1);
      y[1]=C[1][0]*x[0]+C[1][1]*x[1]+D[1][0]*U(0)+D[1][1]*U(1);
  }
  
  
  
  #define MDL_UPDATE
  /* Function: mdlUpdate ======================================================
   * Abstract:
   *      xdot = Ax + Bu
   */
  static void mdlUpdate(SimStruct *S, int_T tid)
  {
      real_T            tempX[2] = {0.0, 0.0};
      real_T            *x       = ssGetRealDiscStates(S);
      InputRealPtrsType uPtrs    = ssGetInputPortRealSignalPtrs(S,0);
  
      UNUSED_ARG(tid); /* not used in single tasking mode */
  
      /* xdot=Ax+Bu */
      tempX[0]=A[0][0]*x[0]+A[0][1]*x[1]+B[0][0]*U(0)+B[0][1]*U(1);
      tempX[1]=A[1][0]*x[0]+A[1][1]*x[1]+B[1][0]*U(0)+B[1][1]*U(1);
   
      x[0]=tempX[0];
      x[1]=tempX[1];
  }
  
  
  
  /* Function: mdlTerminate =====================================================
   * Abstract:
   *    No termination needed, but we are required to have this routine.
   */
  static void mdlTerminate(SimStruct *S)
  {
      UNUSED_ARG(S); /* unused input argument */
  }
  
  #ifdef  MATLAB_MEX_FILE    /* Is this file being compiled as a MEX-file? */
  #include "simulink.c"      /* MEX-file interface mechanism */
  #else
  #include "cg_sfun.h"       /* Code generation registration function */
  #endif
  

Example of a Continuous State S-Function

Example of a Hybrid System S-Function