ps_flc3c_control_acc.c

其中提到遺傳學的程式碼與應用提供給次淚相向的研究者參考下載

        PS_flc3C_control_B->IW211[i1] = PS_flc3C_control_P->IW211_Value[i1];

        rtb_Product_e[i1] = PS_flc3C_control_B->IW211[i1] *
          PS_flc3C_control_B->Saturation[i1];
      }
    }

    /* Sum: '<S23>/Sum' */
    rtb_Sum_l = rtb_Product_e[0];
    rtb_Sum_l += rtb_Product_e[1];
    rtb_Sum_l += rtb_Product_e[2];
    rtb_Sum_l += rtb_Product_e[3];
    rtb_Sum_l += rtb_Product_e[4];

    PS_flc3C_control_B->b2 = PS_flc3C_control_P->b2_Value;

    PS_flc3C_control_B->SU1 = (rtb_Sum_l + PS_flc3C_control_B->b2) *
      PS_flc3C_control_P->SU1_Gain;
  }

  PS_flc3C_control_B->Sum3 = PS_flc3C_control_B->Gain1 -
    PS_flc3C_control_B->TransferFcn1;

  /* Derivative Block: <S2>/Derivative1 */
  {
    real_T t = ssGetTaskTime(S,tid);
    real_T timeStampA = PS_flc3C_control_DWork->Derivative1_RWORK_m.TimeStampA;
    real_T timeStampB = PS_flc3C_control_DWork->Derivative1_RWORK_m.TimeStampB;

    if (timeStampA >= t && timeStampB >= t) {
      rtb_Derivative1_b = 0.0;
    } else {
      real_T deltaT;
      real_T *lastBank = &PS_flc3C_control_DWork->Derivative1_RWORK_m.TimeStampA;
      if (timeStampA < timeStampB) {
        if (timeStampB < t) {
          lastBank += 2;
        }
      } else if (timeStampA >= t) {
        lastBank += 2;
      }
      deltaT = t - *lastBank++;
      rtb_Derivative1_b = (PS_flc3C_control_B->Sum3 - *lastBank++) / deltaT;
    }
  }

  if (ssIsSampleHit(S, 2, tid)) {       /* Sample time: [0.001s, 0.0s] */

    PS_flc3C_control_B->IW111_e[0] = PS_flc3C_control_P->IW111_Value_f[0];
    PS_flc3C_control_B->IW111_e[1] = PS_flc3C_control_P->IW111_Value_f[1];

    PS_flc3C_control_B->IW112_l[0] = PS_flc3C_control_P->IW112_Value_i[0];
    PS_flc3C_control_B->IW112_l[1] = PS_flc3C_control_P->IW112_Value_i[1];

    PS_flc3C_control_B->IW113_p[0] = PS_flc3C_control_P->IW113_Value_f[0];
    PS_flc3C_control_B->IW113_p[1] = PS_flc3C_control_P->IW113_Value_f[1];

    PS_flc3C_control_B->IW114_b[0] = PS_flc3C_control_P->IW114_Value_e[0];
    PS_flc3C_control_B->IW114_b[1] = PS_flc3C_control_P->IW114_Value_e[1];

    PS_flc3C_control_B->IW115_c[0] = PS_flc3C_control_P->IW115_Value_a[0];
    PS_flc3C_control_B->IW115_c[1] = PS_flc3C_control_P->IW115_Value_a[1];
  }

  PS_flc3C_control_B->SE1_f = PS_flc3C_control_B->Sum3 *
    PS_flc3C_control_P->SE1_Gain_m;

  PS_flc3C_control_B->SDE001_i = rtb_Derivative1_b *
    PS_flc3C_control_P->SDE001_Gain_b;

  if (ssIsSampleHit(S, 2, tid)) {       /* Sample time: [0.001s, 0.0s] */

    rtb_Product_j4[0] = PS_flc3C_control_B->IW111_e[0] *
      PS_flc3C_control_B->SE1_f;
    rtb_Product_j4[1] = PS_flc3C_control_B->IW111_e[1] *
      PS_flc3C_control_B->SDE001_i;

    /* Sum: '<S35>/Sum' */
    rtb_Sum_i = rtb_Product_j4[0];
    rtb_Sum_i += rtb_Product_j4[1];

    rtb_Product_hb[0] = PS_flc3C_control_B->IW112_l[0] *
      PS_flc3C_control_B->SE1_f;
    rtb_Product_hb[1] = PS_flc3C_control_B->IW112_l[1] *
      PS_flc3C_control_B->SDE001_i;

    /* Sum: '<S36>/Sum' */
    rtb_Sum_h = rtb_Product_hb[0];
    rtb_Sum_h += rtb_Product_hb[1];

    rtb_Product_l[0] = PS_flc3C_control_B->IW113_p[0] *
      PS_flc3C_control_B->SE1_f;
    rtb_Product_l[1] = PS_flc3C_control_B->IW113_p[1] *
      PS_flc3C_control_B->SDE001_i;

    /* Sum: '<S37>/Sum' */
    rtb_Sum_n = rtb_Product_l[0];
    rtb_Sum_n += rtb_Product_l[1];

    rtb_Product_em[0] = PS_flc3C_control_B->IW114_b[0] *
      PS_flc3C_control_B->SE1_f;
    rtb_Product_em[1] = PS_flc3C_control_B->IW114_b[1] *
      PS_flc3C_control_B->SDE001_i;

    /* Sum: '<S38>/Sum' */
    rtb_Sum_f = rtb_Product_em[0];
    rtb_Sum_f += rtb_Product_em[1];

    rtb_Product_k[0] = PS_flc3C_control_B->IW115_c[0] *
      PS_flc3C_control_B->SE1_f;
    rtb_Product_k[1] = PS_flc3C_control_B->IW115_c[1] *
      PS_flc3C_control_B->SDE001_i;

    /* Sum: '<S39>/Sum' */
    rtb_Sum_o = rtb_Product_k[0];
    rtb_Sum_o += rtb_Product_k[1];

    {
      real_T cg_in_0_61_0[5];
      int32_T i1;

      for(i1=0; i1<5; i1++) {
        PS_flc3C_control_B->b1_i[i1] = PS_flc3C_control_P->b1_Value_k[i1];
      }

      cg_in_0_61_0[0] = rtb_Sum_i;
      cg_in_0_61_0[1] = rtb_Sum_h;
      cg_in_0_61_0[2] = rtb_Sum_n;
      cg_in_0_61_0[3] = rtb_Sum_f;
      cg_in_0_61_0[4] = rtb_Sum_o;
      for(i1=0; i1<5; i1++) {
        rtb_netsum_h[i1] = cg_in_0_61_0[i1] + PS_flc3C_control_B->b1_i[i1];

        PS_flc3C_control_B->Saturation_n[i1] = rt_SATURATE(rtb_netsum_h[i1],
         PS_flc3C_control_P->Saturation_LowerSat_p,
         PS_flc3C_control_P->Saturation_UpperSat_b);
      }
    }
  }
  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    {
      int32_T i1;

      for(i1=0; i1<5; i1++) {
        PS_flc3C_control_B->IW211_f[i1] = PS_flc3C_control_P->IW211_Value_k[i1];

        rtb_Product_i[i1] = PS_flc3C_control_B->IW211_f[i1] *
          PS_flc3C_control_B->Saturation_n[i1];
      }
    }

    /* Sum: '<S44>/Sum' */
    rtb_Sum_fp = rtb_Product_i[0];
    rtb_Sum_fp += rtb_Product_i[1];
    rtb_Sum_fp += rtb_Product_i[2];
    rtb_Sum_fp += rtb_Product_i[3];
    rtb_Sum_fp += rtb_Product_i[4];

    PS_flc3C_control_B->b2_d = PS_flc3C_control_P->b2_Value_a;

    PS_flc3C_control_B->SU1_g = (rtb_Sum_fp + PS_flc3C_control_B->b2_d) *
      PS_flc3C_control_P->SU1_Gain_p;
  }

  PS_flc3C_control_B->Sum1 = PS_flc3C_control_B->SU1 + PS_flc3C_control_B->Sum;

  PS_flc3C_control_B->Sum4 = PS_flc3C_control_B->SU1_g +
    PS_flc3C_control_B->Sum3;
}

/* Update for root system: '<Root>' */
#define MDL_UPDATE
static void mdlUpdate(SimStruct *S, int_T tid)
{

  /* simstruct variables */
  PS_flc3C_control_BlockIO *PS_flc3C_control_B = (PS_flc3C_control_BlockIO *)
    _ssGetBlockIO(S);
  PS_flc3C_control_D_Work *PS_flc3C_control_DWork = (PS_flc3C_control_D_Work *)
    ssGetRootDWork(S);

  /* Derivative Block: <S1>/Derivative1 */
  {
    real_T timeStampA = PS_flc3C_control_DWork->Derivative1_RWORK.TimeStampA;
    real_T timeStampB = PS_flc3C_control_DWork->Derivative1_RWORK.TimeStampB;
    real_T *lastBank = &PS_flc3C_control_DWork->Derivative1_RWORK.TimeStampA;

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

  /* Derivative Block: <S2>/Derivative1 */
  {
    real_T timeStampA = PS_flc3C_control_DWork->Derivative1_RWORK_m.TimeStampA;
    real_T timeStampB = PS_flc3C_control_DWork->Derivative1_RWORK_m.TimeStampB;
    real_T *lastBank = &PS_flc3C_control_DWork->Derivative1_RWORK_m.TimeStampA;

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

/* Derivatives for root system: '<Root>' */
#define MDL_DERIVATIVES
static void mdlDerivatives(SimStruct *S)
{
  /* simstruct variables */
  PS_flc3C_control_BlockIO *PS_flc3C_control_B = (PS_flc3C_control_BlockIO *)
    _ssGetBlockIO(S);
  PS_flc3C_control_ContinuousStates *PS_flc3C_control_X =
    (PS_flc3C_control_ContinuousStates*) ssGetContStates(S);
  PS_flc3C_control_StateDerivatives *PS_flc3C_control_Xdot =
    (PS_flc3C_control_StateDerivatives*) ssGetdX(S);
  PS_flc3C_control_Parameters *PS_flc3C_control_P = (PS_flc3C_control_Parameters
    *) ssGetDefaultParam(S);

  /* TransferFcn Block: <Root>/Transfer Fcn2 */
  {

    PS_flc3C_control_Xdot->TransferFcn2_CSTATE[0] =
      PS_flc3C_control_P->TransferFcn2_B*PS_flc3C_control_B->Sum1;
    PS_flc3C_control_Xdot->TransferFcn2_CSTATE[0] +=
      (PS_flc3C_control_P->TransferFcn2_A[0])*PS_flc3C_control_X->TransferFcn2_CSTATE[0]
      +
      (PS_flc3C_control_P->TransferFcn2_A[1])*PS_flc3C_control_X->TransferFcn2_CSTATE[1]
      +
      (PS_flc3C_control_P->TransferFcn2_A[2])*PS_flc3C_control_X->TransferFcn2_CSTATE[2];

    PS_flc3C_control_Xdot->TransferFcn2_CSTATE[1] =
      (PS_flc3C_control_P->TransferFcn2_A[3])*PS_flc3C_control_X->TransferFcn2_CSTATE[0];

    PS_flc3C_control_Xdot->TransferFcn2_CSTATE[2] =
      (PS_flc3C_control_P->TransferFcn2_A[4])*PS_flc3C_control_X->TransferFcn2_CSTATE[1];
  }

  /* TransferFcn Block: <Root>/Transfer Fcn1 */
  {

    PS_flc3C_control_Xdot->TransferFcn1_CSTATE[0] =
      PS_flc3C_control_P->TransferFcn1_B*PS_flc3C_control_B->Sum4;
    PS_flc3C_control_Xdot->TransferFcn1_CSTATE[0] +=
      (PS_flc3C_control_P->TransferFcn1_A[0])*PS_flc3C_control_X->TransferFcn1_CSTATE[0]
      +
      (PS_flc3C_control_P->TransferFcn1_A[1])*PS_flc3C_control_X->TransferFcn1_CSTATE[1]
      +
      (PS_flc3C_control_P->TransferFcn1_A[2])*PS_flc3C_control_X->TransferFcn1_CSTATE[2];

    PS_flc3C_control_Xdot->TransferFcn1_CSTATE[1] =
      (PS_flc3C_control_P->TransferFcn1_A[3])*PS_flc3C_control_X->TransferFcn1_CSTATE[0];

    PS_flc3C_control_Xdot->TransferFcn1_CSTATE[2] =
      (PS_flc3C_control_P->TransferFcn1_A[4])*PS_flc3C_control_X->TransferFcn1_CSTATE[1];
  }
}

/* Function to initialize sizes */
static void mdlInitializeSizes(SimStruct *S)
{

  /* checksum */
  ssSetChecksumVal(S, 0, 3543348741U);
  ssSetChecksumVal(S, 1, 4262638731U);
  ssSetChecksumVal(S, 2, 2636631497U);
  ssSetChecksumVal(S, 3, 205013058U);

  /* options */
  ssSetOptions(S, SS_OPTION_EXCEPTION_FREE_CODE);

  /* Accelerator check memory map size match for DWork */
  if (ssGetSizeofDWork(S) != sizeof(PS_flc3C_control_D_Work)) {
    ssSetErrorStatus(S,"Unexpected error: Internal DWork sizes do "
     "not match for accelerator mex file.");
  }

  /* Accelerator check memory map size match for BlockIO */
  if (ssGetSizeofGlobalBlockIO(S) != sizeof(PS_flc3C_control_BlockIO)) {
    ssSetErrorStatus(S,"Unexpected error: Internal BlockIO sizes do "
     "not match for accelerator mex file.");
  }

  /* model parameters */
  _ssSetDefaultParam(S, (real_T *) &PS_flc3C_control_DefaultParameters);

  /* non-finites */
  rt_InitInfAndNaN(sizeof(real_T));
}

/* Empty mdlInitializeSampleTimes function (never called) */
static void mdlInitializeSampleTimes(SimStruct *S) { }

/* Empty mdlTerminate function (never called) */
static void mdlTerminate(SimStruct *S) { }

/* MATLAB MEX Glue */
#include "simulink.c"