trigwksp.c
上传用户:loeagle
上传日期:2013-03-02
资源大小:1236k
文件大小:6k
源码类别:

通讯编程文档

开发平台:

Matlab

  1. /* $Revision: 1.21 $ */
  2. /*
  3.  * TRIGWKSP   A Simulink triggered read from workspace
  4.  *
  5.  *           Syntax:  [sys, x0] = TRIGWKSP(t,x,u,flag,var, thd, cycl_flag, ini)
  6.  *      This function is for the Simulink Triggered read-from-workspace block.
  7.  *      The block outputs a row of VAR at the rising edge of of the input
  8.  *      impulse. The output impulse equals the colomn number of VAR. The 
  9.  *      rising edge of the trigger signal is detected when it is greater than 
  10.  *      or equal to the threshold. When the output index is greater than
  11.  *      the row number of VAR, the block outputs zero if cycl_flag == 0.
  12.  *      The block returns to the very begining of the VAR and cyclically
  13.  *      outputs the same variable again when cycl_flag ~= 0.
  14.  *
  15.  * Wes Wang  August 25, 1994
  16.  * Copyright 1996-2001 The MathWorks, Inc.
  17.  */
  18. #define S_FUNCTION_NAME trigwksp
  19. #ifdef MATLAB_MEX_FILE
  20. #include "mex.h"      /* needed for declaration of mexErrMsgTxt */
  21. #endif
  22. /*
  23.  * need to include simstruc.h for the definition of the SimStruct and
  24.  * its associated macro definitions.
  25.  */
  26. #include "simstruc.h"
  27. #include "tmwtypes.h"
  28. /* For RTW */
  29. #if defined(RT) || defined(NRT)  
  30. #undef  mexPrintf
  31. #define mexPrintf printf
  32. #endif
  33. /*
  34.  * Defines for easy access of the input parameters
  35.  */
  36. #define NUM_ARGS       4
  37. #define VARIABLE       ssGetArg(S,0)
  38. #define THRESHOLD      ssGetArg(S,1)
  39. #define CYCL_FLAG      ssGetArg(S,2)
  40. #define INIOUTPUT      ssGetArg(S,3)
  41. /*
  42.  * mdlInitializeSizes - called to initialize the sizes array stored in
  43.  *                      the SimStruct.  The sizes array defines the
  44.  *                      characteristics (number of inputs, outputs,
  45.  *                      states, etc.) of the S-Function.
  46.  */
  47. static void mdlInitializeSizes(SimStruct *S)
  48. {
  49.     /*
  50.      * Set-up size information.
  51.      */ 
  52.     
  53.     if (ssGetNumArgs(S) == NUM_ARGS) {
  54. int_T numOutput, maxBuffer;
  55. numOutput = mxGetN(VARIABLE);
  56. maxBuffer = mxGetM(VARIABLE);
  57. if (numOutput < 1) {
  58. #ifdef MATLAB_MEX_FILE
  59.     char_T err_msg[256];
  60.     sprintf(err_msg, "Input variable is empty.");
  61.     mexErrMsgTxt(err_msg);
  62. #endif    
  63.         }
  64. if ((mxGetM(THRESHOLD) != 1) || (mxGetN(THRESHOLD) != 1) ) {
  65. #ifdef MATLAB_MEX_FILE
  66.     char_T err_msg[256];
  67.     sprintf(err_msg, "Threshold must be a scalar.");
  68.     mexErrMsgTxt(err_msg);
  69. #endif    
  70.         }
  71. if ((mxGetM(CYCL_FLAG) != 1) || (mxGetN(CYCL_FLAG) != 1) ) {
  72. #ifdef MATLAB_MEX_FILE
  73.     char_T err_msg[256];
  74.     sprintf(err_msg, "Cyclic flag must be a scalar.");
  75.     mexErrMsgTxt(err_msg);
  76. #endif    
  77.         }               
  78.         
  79.         ssSetNumContStates(    S, 0);
  80. ssSetNumDiscStates(    S, 0);
  81. ssSetNumInputs(        S, 1);
  82. ssSetNumOutputs(       S, numOutput);
  83. ssSetDirectFeedThrough(S, 1);
  84. ssSetNumInputArgs(     S, NUM_ARGS);
  85. ssSetNumSampleTimes(   S, 1);
  86. ssSetNumRWork(         S, 0);
  87. ssSetNumIWork(         S, 2);  /*Index and lastTrig*/
  88. ssSetNumPWork(         S, 0);
  89.     } else {
  90. #ifdef MATLAB_MEX_FILE
  91. char_T err_msg[256];
  92. sprintf(err_msg, "Wrong number of input arguments passed to S-function MEX-file.n"
  93. "%d input arguments were passed in when expecting %d input arguments.n", ssGetNumArgs(S) + 4, NUM_ARGS + 4);
  94. mexErrMsgTxt(err_msg);
  95. #endif
  96.     }
  97. }
  98. /*
  99.  * mdlInitializeSampleTimes - initializes the array of sample times stored in
  100.  *                            the SimStruct associated with this S-Function.
  101.  */
  102. static void mdlInitializeSampleTimes(SimStruct *S)
  103. {
  104.     /*
  105.      * Note, blocks that are continuous in nature should have a single
  106.      * sample time of 0.0.
  107.      */
  108.     ssSetSampleTimeEvent(S, 0, INHERITED_SAMPLE_TIME);
  109.     ssSetOffsetTimeEvent(S, 0, 0.0);
  110. }
  111. /*
  112.  * mdlInitializeConditions - initializes the states for the S-Function
  113.  */
  114. static void mdlInitializeConditions(real_T *x0, SimStruct *S)
  115. {
  116.     int_T    *Index          = ssGetIWork(S);
  117.     int_T    *lastTrig       = ssGetIWork(S) + 1;    
  118.     *Index          = 0;
  119.     *lastTrig       = 0;
  120. }
  121. /*
  122.  * mdlOutputs - computes the outputs of the S-Function
  123.  */
  124. static void mdlOutputs(real_T *y, const real_T *x, const real_T *u, SimStruct *S, int_T tid)
  125. {
  126.   if (ssIsMajorTimeStep(S)) {
  127.     int_T    *Index          = ssGetIWork(S);
  128.     int_T    *lastTrig       = ssGetIWork(S) + 1;    
  129.     int_T     numOutput      = mxGetN(VARIABLE);
  130.     int_T     maxBuffer      = mxGetM(VARIABLE);
  131.     int_T     cyclFlag       = (int_T)mxGetPr(CYCL_FLAG)[0];
  132.     real_T  thd            = mxGetPr(THRESHOLD)[0];
  133.     
  134.     int_T     i, outIndex;
  135.     
  136.     ssSetSolverNeedsReset(S);
  137.     if ((u[0] >= thd) & (*lastTrig == 0)) {
  138.         outIndex = *Index;
  139.         *Index += 1;
  140.         if (cyclFlag != 0)
  141.             outIndex %= maxBuffer;
  142.         if (outIndex < maxBuffer) {
  143.             for (i = 0; i < numOutput; i++)
  144.                 y[i] = mxGetPr(VARIABLE)[outIndex + i * maxBuffer];
  145.         } else {
  146.             for (i = 0; i < numOutput; i++)
  147.                 y[i] = 0.0;            
  148.         }
  149.         *lastTrig = 1;
  150.     } else {
  151. if (ssGetT(S) <= 0.0) {
  152.       if ((mxGetN(INIOUTPUT) * mxGetM(INIOUTPUT)) == numOutput) {
  153. for (i = 0; i < numOutput; i++)
  154.     y[i] = mxGetPr(INIOUTPUT)[i];
  155.     } else if ((mxGetN(INIOUTPUT) * mxGetM(INIOUTPUT)) <= 0) {
  156. for (i = 0; i < numOutput; i++)
  157.     y[i] = 0.0;
  158.   } else {
  159. for (i = 0; i < numOutput; i++)
  160.     y[i] = mxGetPr(INIOUTPUT)[0];
  161.     }
  162. }
  163. if (*lastTrig == 1) {
  164.     if (u[0] < thd)
  165. *lastTrig = 0;
  166. }
  167.       }
  168.   }
  169. }
  170. /*
  171.  * mdlUpdate - computes the discrete states of the S-Function
  172.  */
  173. static void mdlUpdate(real_T *x, const real_T *u, SimStruct *S, int_T tid)
  174. {
  175. }
  176. /*
  177.  * mdlDerivatives - computes the derivatives of the S-Function
  178.  */
  179. static void mdlDerivatives(real_T *dx, const real_T *x, const real_T *u, SimStruct *S, int_T tid)
  180. {
  181. }
  182. /*
  183.  * mdlTerminate - called at termination of model execution.
  184.  */
  185. static void mdlTerminate(SimStruct *S)
  186. {
  187. }
  188. #ifdef  MATLAB_MEX_FILE    /* Is this file being compiled as a MEX-file? */
  189. #include "simulink.c"      /* MEX-File interface mechanism */
  190. #else
  191. #include "cg_sfun.h"       /* Code generation registration function */
  192. #endif