ex38s_acc.c

书籍代码:遗传演算法原理与应用_活用MATLAB(Source Code)

  }

  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0, 1.0] */
    /* Constant Block: <Root>/Constant */
    ex38s_B->root_Constant = (ex38s_P->root_Constant_Value);
  }

  if (ssIsContinuousTask(S, tid)) {     /* Sample time: [0.0, 0.0] */
    /* RelationalOperator Block: <Root>/Relational Operator */
    if (ssIsMajorTimeStep(S)) {
      ex38s_DWork->root_Relational_Operator_MODE = (int_T)(ex38s_B->root_Gain > ex38s_B->root_Constant);
    }
    ex38s_B->root_Relational_Operator = (real_T)(ex38s_DWork->root_Relational_Operator_MODE);

    /* Outport Block: <Root>/Out3 */
    /* Call into Simulink for root Outports */
    ssCallAccelRunBlock(S, 0, 52, SS_CALL_MDL_OUTPUTS);

    /* Outport Block: <Root>/Out4 */
    /* Call into Simulink for root Outports */
    ssCallAccelRunBlock(S, 0, 53, SS_CALL_MDL_OUTPUTS);

    /* Display Block: <Root>/Display */
    /* Call into Simulink for Display */
    ssCallAccelRunBlock(S, 0, 54, SS_CALL_MDL_OUTPUTS);
  }

  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0, 1.0] */
    /* Display Block: <Root>/Display1 */
    /* Call into Simulink for Display */
    ssCallAccelRunBlock(S, 0, 55, SS_CALL_MDL_OUTPUTS);
  }

  if (ssIsContinuousTask(S, tid)) {     /* Sample time: [0.0, 0.0] */
    /* Scope Block: <Root>/Scope */
    /* Call into Simulink for Scope */
    ssCallAccelRunBlock(S, 0, 56, SS_CALL_MDL_OUTPUTS);

    /* Scope Block: <Root>/Scope1 */
    /* Call into Simulink for Scope */
    ssCallAccelRunBlock(S, 0, 57, SS_CALL_MDL_OUTPUTS);
  }

  if (ssIsSampleHit(S, 2, tid)) {       /* Sample time: [0.01, 0.0] */
    /* ToWorkspace Block: <Root>/To Workspace */
    /* Call into Simulink for To Workspace */
    ssCallAccelRunBlock(S, 0, 59, SS_CALL_MDL_OUTPUTS);

    /* ZeroOrderHold Block: <Root>/Zero-Order Hold1 */
    ex38s_B->root_Zero_Order_Hold1[0] = ex38s_B->s5_Gain;
    ex38s_B->root_Zero_Order_Hold1[1] = ex38s_B->s7_Internal;

    /* ToWorkspace Block: <Root>/To Workspace1 */
    /* Call into Simulink for To Workspace */
    ssCallAccelRunBlock(S, 0, 61, SS_CALL_MDL_OUTPUTS);
  }

  if (ssIsContinuousTask(S, tid)) {     /* Sample time: [0.0, 0.0] */
    /* Derivative Block: <Root>/Derivative */
    {
      real_T t = ssGetTaskTime(S,tid);
      real_T timeStampA = ex38s_DWork->root_Derivative_RWORK.TimeStampA;
      real_T timeStampB = ex38s_DWork->root_Derivative_RWORK.TimeStampB;

      if (timeStampA >= t && timeStampB >= t) {
        rtb_temp31 = 0.0;
      } else {
        real_T deltaT;
        real_T *lastBank = &ex38s_DWork->root_Derivative_RWORK.TimeStampA;
        if (timeStampA < timeStampB) {
          if (timeStampB < t) {
            lastBank += 2;
          }
        } else if (timeStampA >= t) {
          lastBank += 2;
        }
        deltaT = t - *lastBank++;
        rtb_temp31 = (ex38s_B->root_Sum - *lastBank++) / deltaT;
      }
    }

    /* Gain Block: <S6>/Gain */
    ex38s_B->s6_Gain = ex38s_B->root_Sum * (ex38s_P->s6_Gain_Gain);

    /* Saturate Block: <S6>/Saturation */
    if (ssIsMajorTimeStep(S)) {
      if (ex38s_B->s6_Gain >= (ex38s_P->s6_Saturation_UpperSat)) {
        ex38s_DWork->s6_Saturation_MODE = 1;
      } else if (ex38s_B->s6_Gain > (ex38s_P->s6_Saturation_LowerSat)) {
        ex38s_DWork->s6_Saturation_MODE = 0;
      } else {
        ex38s_DWork->s6_Saturation_MODE = -1;
      }
    }
    /* Output value */
    if (ex38s_DWork->s6_Saturation_MODE == 1) {
      ex38s_B->s6_Saturation = (ex38s_P->s6_Saturation_UpperSat);
    } else if (ex38s_DWork->s6_Saturation_MODE == -1) {
      ex38s_B->s6_Saturation = (ex38s_P->s6_Saturation_LowerSat);
    } else {
      ex38s_B->s6_Saturation = ex38s_B->s6_Gain;
    }

    /* Gain Block: <S6>/Gain1 */
    ex38s_B->s6_Gain1 = rtb_temp31 * (ex38s_P->s6_Gain1_Gain);

    /* Saturate Block: <S6>/Saturation1 */
    if (ssIsMajorTimeStep(S)) {
      if (ex38s_B->s6_Gain1 >= (ex38s_P->s6_Saturation1_UpperSat)) {
        ex38s_DWork->s6_Saturation1_MODE = 1;
      } else if (ex38s_B->s6_Gain1 > (ex38s_P->s6_Saturation1_LowerSat)) {
        ex38s_DWork->s6_Saturation1_MODE = 0;
      } else {
        ex38s_DWork->s6_Saturation1_MODE = -1;
      }
    }
    /* Output value */
    if (ex38s_DWork->s6_Saturation1_MODE == 1) {
      ex38s_B->s6_Saturation1 = (ex38s_P->s6_Saturation1_UpperSat);
    } else if (ex38s_DWork->s6_Saturation1_MODE == -1) {
      ex38s_B->s6_Saturation1 = (ex38s_P->s6_Saturation1_LowerSat);
    } else {
      ex38s_B->s6_Saturation1 = ex38s_B->s6_Gain1;
    }

    /* Level2 S-Function Block: <S8>/FIS S-function (sffis) */
    /* Call into Simulink for MEX-version of S-function */
    ssCallAccelRunBlock(S, 0, 67, SS_CALL_MDL_OUTPUTS);

    /* Gain Block: <S6>/Gain2 */
    rtb_temp31 = ex38s_B->s8_FIS_S_function * (ex38s_P->s6_Gain2_Gain);
  }

  if (ssIsSampleHit(S, 2, tid)) {       /* Sample time: [0.01, 0.0] */
    /* UnitDelay Block: <Root>/Unit Delay Ts=0.01 */
    ex38s_B->root_Unit_Delay_Ts_0_01 = ex38s_DWork->root_Unit_Delay_Ts_0_01_DSTATE;
  }

  if (ssIsContinuousTask(S, tid)) {     /* Sample time: [0.0, 0.0] */
    /* Sum Block: <Root>/Sum1 */
    ex38s_B->root_Sum1 = rtb_temp31 + ex38s_B->root_Unit_Delay_Ts_0_01;
  }
}

/* Perform model update */
#define MDL_UPDATE
static void mdlUpdate(SimStruct *S, int_T tid)
{
  /* simstruct variables */
  ex38s_BlockIO *ex38s_B = (ex38s_BlockIO *) _ssGetBlockIO(S);
  ex38s_D_Work *ex38s_DWork = (ex38s_D_Work *) ssGetRootDWork(S);
  ex38s_Parameters *ex38s_P = (ex38s_Parameters *) ssGetDefaultParam(S);

  if (ssIsSampleHit(S, 3, tid)) {       /* Sample time: [30.0, 0.0] */
    /* RandomNumber Block: <S5>/White Noise */

    ex38s_DWork->s5_White_Noise_RWORK.NextOutput = rt_NormalRand((uint_T *)&ex38s_DWork->s5_White_Noise_IWORK.RandSeed)*(ex38s_P->s5_White_Noise_StdDev)+(ex38s_P->s5_White_Noise_Mean);
  }

  if (ssIsSampleHit(S, 2, tid)) {       /* Sample time: [0.01, 0.0] */
    /* UnitDelay Block: <S4>/Unit Delay Ts=0.1 */
    ex38s_DWork->s4_Unit_Delay_Ts_0_1_DSTATE = ex38s_B->s4_Sum2;

    /* UnitDelay Block: <S3>/Unit Delay Ts=0.1 */
    ex38s_DWork->s3_Unit_Delay_Ts_0_1_DSTATE = ex38s_B->s3_Sum2;

    /* UnitDelay Block: <S2>/Unit Delay Ts=0.1 */
    ex38s_DWork->s2_Unit_Delay_Ts_0_1_DSTATE = ex38s_B->s2_Sum2;

    /* UnitDelay Block: <S1>/Unit Delay Ts=0.1 */
    ex38s_DWork->s1_Unit_Delay_Ts_0_1_DSTATE = ex38s_B->s1_Sum2;
  }

  if (ssIsContinuousTask(S, tid)) {     /* Sample time: [0.0, 0.0] */
    /* Stop Block: <Root>/Stop Simulation */
    if (ex38s_B->root_Relational_Operator != 0.0) {
      ssSetStopRequested(S, 1);
    }

    /* Derivative Block: <Root>/Derivative */
    {
      real_T timeStampA = ex38s_DWork->root_Derivative_RWORK.TimeStampA;
      real_T timeStampB = ex38s_DWork->root_Derivative_RWORK.TimeStampB;
      real_T *lastBank = &ex38s_DWork->root_Derivative_RWORK.TimeStampA;

      if (timeStampA != rtInf) {
        if (timeStampB == rtInf) {
          lastBank += 2;
        } else if (timeStampA >= timeStampB) {
          lastBank += 2;
        }
      }
      *lastBank++ = ssGetTaskTime(S,tid);
      *lastBank++ = ex38s_B->root_Sum;
    }
  }

  if (ssIsSampleHit(S, 2, tid)) {       /* Sample time: [0.01, 0.0] */
    /* UnitDelay Block: <Root>/Unit Delay Ts=0.01 */
    ex38s_DWork->root_Unit_Delay_Ts_0_01_DSTATE = ex38s_B->root_Sum1;
  }
}

/* Compute model derivatives */
#define MDL_DERIVATIVES
static void mdlDerivatives(SimStruct *S)
{
  /* simstruct variables */
  ex38s_BlockIO *ex38s_B = (ex38s_BlockIO *) _ssGetBlockIO(S);
  ex38s_ContinuousStates *ex38s_X = (ex38s_ContinuousStates*) ssGetContStates(S);
  ex38s_Parameters *ex38s_P = (ex38s_Parameters *) ssGetDefaultParam(S);

  /* StateSpace Block: <S7>/Internal */
  {
    real_T *dx = ssGetdX(S)+0;

    dx[0] = (ex38s_P->s7_Internal_B)*ex38s_B->root_Sum1;
    dx[0] += (ex38s_P->s7_Internal_A[0])*ex38s_X->s7_Internal[0]+(ex38s_P->s7_Internal_A[1])*ex38s_X->s7_Internal[1];

    dx[1] = (ex38s_P->s7_Internal_A[2])*ex38s_X->s7_Internal[0];
  }
}

/* Compute model zero crossings */
#define MDL_ZERO_CROSSINGS
static void mdlZeroCrossings(SimStruct *S)
{
  /* simstruct variables */
  ex38s_BlockIO *ex38s_B = (ex38s_BlockIO *) _ssGetBlockIO(S);
  ex38s_Parameters *ex38s_P = (ex38s_Parameters *) ssGetDefaultParam(S);
  ex38s_NonsampledZCs *ex38s_NonsampledZC = (ex38s_NonsampledZCs *) ssGetNonsampledZCs(S);

  /* Abs Block: <S4>/Abs */
  ex38s_NonsampledZC->s4_Abs = ex38s_B->root_Sum;

  /* Abs Block: <S3>/Abs */
  ex38s_NonsampledZC->s3_Abs = ex38s_B->root_Sum;

  /* Abs Block: <S2>/Abs */
  ex38s_NonsampledZC->s2_Abs = ex38s_B->root_Sum;

  /* Abs Block: <S1>/Abs */
  ex38s_NonsampledZC->s1_Abs = ex38s_B->root_Sum;

  /* RelationalOperator Block: <Root>/Relational Operator */
  ex38s_NonsampledZC->root_Relational_Operator = ex38s_B->root_Gain - ex38s_B->root_Constant;

  /* Saturate Block: <S6>/Saturation */
  /* Do zero crossings for the upper limit */
  ex38s_NonsampledZC->s6_Saturation[0] = ex38s_B->s6_Gain -
    (ex38s_P->s6_Saturation_UpperSat);
  /* Do zero crossings for the lower limit */
  ex38s_NonsampledZC->s6_Saturation[1] = ex38s_B->s6_Gain -
    (ex38s_P->s6_Saturation_LowerSat);

  /* Saturate Block: <S6>/Saturation1 */
  /* Do zero crossings for the upper limit */
  ex38s_NonsampledZC->s6_Saturation1[0] = ex38s_B->s6_Gain1 -
    (ex38s_P->s6_Saturation1_UpperSat);
  /* Do zero crossings for the lower limit */
  ex38s_NonsampledZC->s6_Saturation1[1] = ex38s_B->s6_Gain1 -
    (ex38s_P->s6_Saturation1_LowerSat);
}

/* End of Functions in model "ex38s_acc" */

#include "ex38s_acc_reg.h"

/* [EOF] ex38s_acc.c */