ex33d_pid_acc.c

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

    real_T tMinusDelay = simTime - ex33D_pid_P->TransportDelay1_Delay;

    ex33D_pid_B->TransportDelay1 = rt_TDelayInterpolate(
      tMinusDelay,
     *tBuffer,
     *uBuffer,
     ex33D_pid_DWork->TransportDelay1_IWORK.CircularBufSize,
     &ex33D_pid_DWork->TransportDelay1_IWORK.Last,
     ex33D_pid_DWork->TransportDelay1_IWORK.Tail,
     ex33D_pid_DWork->TransportDelay1_IWORK.Head,
     0,
     (boolean_T) (ssIsMinorTimeStep(S) && (ssGetTimeOfLastOutput(S) ==
       ssGetT(S))));
  }
}

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

  /* simstruct variables */
  ex33D_pid_BlockIO *ex33D_pid_B = (ex33D_pid_BlockIO *) _ssGetBlockIO(S);
  ex33D_pid_D_Work *ex33D_pid_DWork = (ex33D_pid_D_Work *) ssGetRootDWork(S);
  ex33D_pid_Parameters *ex33D_pid_P = (ex33D_pid_Parameters *)
    ssGetDefaultParam(S);

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

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

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

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

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

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

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

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

  /* Derivative Block: <S3>/Derivative1 */
  {
    real_T timeStampA = ex33D_pid_DWork->Derivative1_RWORK_k.TimeStampA;
    real_T timeStampB = ex33D_pid_DWork->Derivative1_RWORK_k.TimeStampB;
    real_T *lastBank = &ex33D_pid_DWork->Derivative1_RWORK_k.TimeStampA;

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

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

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

  /* Derivative Block: <S4>/Derivative1 */
  {
    real_T timeStampA = ex33D_pid_DWork->Derivative1_RWORK_j.TimeStampA;
    real_T timeStampB = ex33D_pid_DWork->Derivative1_RWORK_j.TimeStampB;
    real_T *lastBank = &ex33D_pid_DWork->Derivative1_RWORK_j.TimeStampA;

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

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

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

  /* TransportDelay Block: <Root>/Transport Delay1 */
  {
    real_T **uBuffer =
      (real_T**)&ex33D_pid_DWork->TransportDelay1_PWORK.TUbufferPtrs[0];
    real_T **tBuffer =
      (real_T**)&ex33D_pid_DWork->TransportDelay1_PWORK.TUbufferPtrs[1];
    real_T simTime = ssGetT(S);

    ex33D_pid_DWork->TransportDelay1_IWORK.Head =
      ((ex33D_pid_DWork->TransportDelay1_IWORK.Head <
      (ex33D_pid_DWork->TransportDelay1_IWORK.CircularBufSize-1)) ?
      (ex33D_pid_DWork->TransportDelay1_IWORK.Head+1) : 0);

    if (ex33D_pid_DWork->TransportDelay1_IWORK.Head ==
     ex33D_pid_DWork->TransportDelay1_IWORK.Tail) {
      if (!rt_TDelayUpdateTailOrGrowBuf(
        &ex33D_pid_DWork->TransportDelay1_IWORK.CircularBufSize,
        &ex33D_pid_DWork->TransportDelay1_IWORK.Tail,
        &ex33D_pid_DWork->TransportDelay1_IWORK.Head,
        &ex33D_pid_DWork->TransportDelay1_IWORK.Last, simTime -
        ex33D_pid_P->TransportDelay1_Delay, tBuffer, uBuffer,
        &ex33D_pid_DWork->TransportDelay1_IWORK.MaxNewBufSize)) {
        ssSetErrorStatus(S, "tdelay memory allocation error");
      }
    }

    (*tBuffer)[ex33D_pid_DWork->TransportDelay1_IWORK.Head] = simTime;
    (*uBuffer)[ex33D_pid_DWork->TransportDelay1_IWORK.Head] =
      ex33D_pid_B->Gain11;
  }
}

/* Derivatives for root system: '<Root>' */
#define MDL_DERIVATIVES
static void mdlDerivatives(SimStruct *S)
{
  /* simstruct variables */
  ex33D_pid_BlockIO *ex33D_pid_B = (ex33D_pid_BlockIO *) _ssGetBlockIO(S);
  ex33D_pid_ContinuousStates *ex33D_pid_X = (ex33D_pid_ContinuousStates*)
    ssGetContStates(S);
  ex33D_pid_StateDerivatives *ex33D_pid_Xdot = (ex33D_pid_StateDerivatives*)
    ssGetdX(S);
  ex33D_pid_Parameters *ex33D_pid_P = (ex33D_pid_Parameters *)
    ssGetDefaultParam(S);

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

    ex33D_pid_Xdot->TransferFcn1_CSTATE[0] =
      ex33D_pid_P->TransferFcn1_B*ex33D_pid_B->Gain2;
    {
      static const int_T colAidxRow0[6] = {0, 1, 2, 3, 4, 5};
      const int_T *pAidx = &colAidxRow0[0];
      const real_T *pA0 = &ex33D_pid_P->TransferFcn1_A[0];
      const real_T *xc = &ex33D_pid_X->TransferFcn1_CSTATE[0];
      real_T *dx0 = &ex33D_pid_Xdot->TransferFcn1_CSTATE[0];
      int_T numNonZero = 6;

      while (numNonZero--) {
        *dx0 += (*pA0++) * xc[*pAidx++];
      }
    }

    ex33D_pid_Xdot->TransferFcn1_CSTATE[1] =
      (ex33D_pid_P->TransferFcn1_A[6])*ex33D_pid_X->TransferFcn1_CSTATE[0];

    ex33D_pid_Xdot->TransferFcn1_CSTATE[2] =
      (ex33D_pid_P->TransferFcn1_A[7])*ex33D_pid_X->TransferFcn1_CSTATE[1];

    ex33D_pid_Xdot->TransferFcn1_CSTATE[3] =
      (ex33D_pid_P->TransferFcn1_A[8])*ex33D_pid_X->TransferFcn1_CSTATE[2];

    ex33D_pid_Xdot->TransferFcn1_CSTATE[4] =
      (ex33D_pid_P->TransferFcn1_A[9])*ex33D_pid_X->TransferFcn1_CSTATE[3];

    ex33D_pid_Xdot->TransferFcn1_CSTATE[5] =
      (ex33D_pid_P->TransferFcn1_A[10])*ex33D_pid_X->TransferFcn1_CSTATE[4];
  }

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

    ex33D_pid_Xdot->TransferFcn2_CSTATE[0] =
      ex33D_pid_P->TransferFcn2_B*ex33D_pid_B->Gain5;
    {
      static const int_T colAidxRow0[6] = {0, 1, 2, 3, 4, 5};
      const int_T *pAidx = &colAidxRow0[0];
      const real_T *pA0 = &ex33D_pid_P->TransferFcn2_A[0];
      const real_T *xc = &ex33D_pid_X->TransferFcn2_CSTATE[0];
      real_T *dx0 = &ex33D_pid_Xdot->TransferFcn2_CSTATE[0];
      int_T numNonZero = 6;

      while (numNonZero--) {
        *dx0 += (*pA0++) * xc[*pAidx++];
      }
    }

    ex33D_pid_Xdot->TransferFcn2_CSTATE[1] =
      (ex33D_pid_P->TransferFcn2_A[6])*ex33D_pid_X->TransferFcn2_CSTATE[0];

    ex33D_pid_Xdot->TransferFcn2_CSTATE[2] =
      (ex33D_pid_P->TransferFcn2_A[7])*ex33D_pid_X->TransferFcn2_CSTATE[1];

    ex33D_pid_Xdot->TransferFcn2_CSTATE[3] =
      (ex33D_pid_P->TransferFcn2_A[8])*ex33D_pid_X->TransferFcn2_CSTATE[2];

    ex33D_pid_Xdot->TransferFcn2_CSTATE[4] =
      (ex33D_pid_P->TransferFcn2_A[9])*ex33D_pid_X->TransferFcn2_CSTATE[3];

    ex33D_pid_Xdot->TransferFcn2_CSTATE[5] =
      (ex33D_pid_P->TransferFcn2_A[10])*ex33D_pid_X->TransferFcn2_CSTATE[4];
  }

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

    ex33D_pid_Xdot->TransferFcn3_CSTATE[0] =
      ex33D_pid_P->TransferFcn3_B*ex33D_pid_B->Gain8;
    {
      static const int_T colAidxRow0[6] = {0, 1, 2, 3, 4, 5};
      const int_T *pAidx = &colAidxRow0[0];
      const real_T *pA0 = &ex33D_pid_P->TransferFcn3_A[0];
      const real_T *xc = &ex33D_pid_X->TransferFcn3_CSTATE[0];
      real_T *dx0 = &ex33D_pid_Xdot->TransferFcn3_CSTATE[0];
      int_T numNonZero = 6;

      while (numNonZero--) {
        *dx0 += (*pA0++) * xc[*pAidx++];
      }
    }

    ex33D_pid_Xdot->TransferFcn3_CSTATE[1] =
      (ex33D_pid_P->TransferFcn3_A[6])*ex33D_pid_X->TransferFcn3_CSTATE[0];

    ex33D_pid_Xdot->TransferFcn3_CSTATE[2] =
      (ex33D_pid_P->TransferFcn3_A[7])*ex33D_pid_X->TransferFcn3_CSTATE[1];

    ex33D_pid_Xdot->TransferFcn3_CSTATE[3] =
      (ex33D_pid_P->TransferFcn3_A[8])*ex33D_pid_X->TransferFcn3_CSTATE[2];

    ex33D_pid_Xdot->TransferFcn3_CSTATE[4] =
      (ex33D_pid_P->TransferFcn3_A[9])*ex33D_pid_X->TransferFcn3_CSTATE[3];

    ex33D_pid_Xdot->TransferFcn3_CSTATE[5] =
      (ex33D_pid_P->TransferFcn3_A[10])*ex33D_pid_X->TransferFcn3_CSTATE[4];
  }

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

    ex33D_pid_Xdot->TransferFcn4_CSTATE[0] =
      ex33D_pid_P->TransferFcn4_B*ex33D_pid_B->TransportDelay1;
    {
      static const int_T colAidxRow0[6] = {0, 1, 2, 3, 4, 5};
      const int_T *pAidx = &colAidxRow0[0];
      const real_T *pA0 = &ex33D_pid_P->TransferFcn4_A[0];
      const real_T *xc = &ex33D_pid_X->TransferFcn4_CSTATE[0];
      real_T *dx0 = &ex33D_pid_Xdot->TransferFcn4_CSTATE[0];
      int_T numNonZero = 6;

      while (numNonZero--) {
        *dx0 += (*pA0++) * xc[*pAidx++];
      }
    }

    ex33D_pid_Xdot->TransferFcn4_CSTATE[1] =
      (ex33D_pid_P->TransferFcn4_A[6])*ex33D_pid_X->TransferFcn4_CSTATE[0];

    ex33D_pid_Xdot->TransferFcn4_CSTATE[2] =
      (ex33D_pid_P->TransferFcn4_A[7])*ex33D_pid_X->TransferFcn4_CSTATE[1];

    ex33D_pid_Xdot->TransferFcn4_CSTATE[3] =
      (ex33D_pid_P->TransferFcn4_A[8])*ex33D_pid_X->TransferFcn4_CSTATE[2];

    ex33D_pid_Xdot->TransferFcn4_CSTATE[4] =
      (ex33D_pid_P->TransferFcn4_A[9])*ex33D_pid_X->TransferFcn4_CSTATE[3];

    ex33D_pid_Xdot->TransferFcn4_CSTATE[5] =
      (ex33D_pid_P->TransferFcn4_A[10])*ex33D_pid_X->TransferFcn4_CSTATE[4];
  }

  /* Integrator Block: <Root>/Integrator */
  {

    ex33D_pid_Xdot->Integrator_CSTATE = ex33D_pid_B->Sum8;
  }

  /* Integrator Block: <Root>/Integrator3 */
  {

    ex33D_pid_Xdot->Integrator3_CSTATE = ex33D_pid_B->Sum11;
  }

  /* Integrator Block: <Root>/Integrator1 */
  {

    ex33D_pid_Xdot->Integrator1_CSTATE = ex33D_pid_B->Sum9;
  }

  /* Integrator Block: <Root>/Integrator2 */
  {

    ex33D_pid_Xdot->Integrator2_CSTATE = ex33D_pid_B->Sum10;
  }
}

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

  /* checksum */
  ssSetChecksumVal(S, 0, 3329176652U);
  ssSetChecksumVal(S, 1, 1100950059U);
  ssSetChecksumVal(S, 2, 614778932U);
  ssSetChecksumVal(S, 3, 3536786239U);

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

  /* Accelerator check memory map size match for DWork */
  if (ssGetSizeofDWork(S) != sizeof(ex33D_pid_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(ex33D_pid_BlockIO)) {
    ssSetErrorStatus(S,"Unexpected error: Internal BlockIO sizes do "
     "not match for accelerator mex file.");
  }

  /* model parameters */
  _ssSetDefaultParam(S, (real_T *) &ex33D_pid_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"