ex33c_pid_acc.c

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

/*
 * This file is not available for use in any application other than as a
 * MATLAB(R) MEX file for use with the Simulink(R) Accelerator product.
 */

/*
 * ex33C_pid_acc.c
 * 
 * Real-Time Workshop code generation for Simulink model "ex33C_pid_acc.mdl".
 *
 * Model Version              : 1.64
 * Real-Time Workshop version : 6.1  (R14SP1)  05-Sep-2004
 * C source code generated on : Tue Jul 19 08:14:52 2005
 */

#include <math.h>
#include <string.h>
#include "ex33C_pid_acc.h"
#include "ex33C_pid_acc_private.h"
#include <stdio.h>
#include "simstruc.h"
#include "fixedpoint.h"

#define CodeFormat                      S-Function
#define AccDefine1                      Accelerator_S-Function

/* Outputs for root system: '<Root>' */
static void mdlOutputs(SimStruct *S, int_T tid)
{
  /* simstruct variables */
  ex33C_pid_BlockIO *ex33C_pid_B = (ex33C_pid_BlockIO *) _ssGetBlockIO(S);
  ex33C_pid_ContinuousStates *ex33C_pid_X = (ex33C_pid_ContinuousStates*)
    ssGetContStates(S);
  ex33C_pid_D_Work *ex33C_pid_DWork = (ex33C_pid_D_Work *) ssGetRootDWork(S);
  ex33C_pid_Parameters *ex33C_pid_P = (ex33C_pid_Parameters *)
    ssGetDefaultParam(S);

  /* local block i/o variables */

  real_T rtb_Step;
  real_T rtb_Gain12;
  real_T rtb_TransferFcn1;
  real_T rtb_TransferFcn2;
  real_T rtb_TransferFcn3;
  real_T rtb_TransferFcn4;
  real_T rtb_Derivative1;
  real_T rtb_Product[2];
  real_T rtb_Sum;
  real_T rtb_Product_i[2];
  real_T rtb_Sum_b;
  real_T rtb_Product_d[2];
  real_T rtb_Sum_l;
  real_T rtb_Product_o[2];
  real_T rtb_Sum_a;
  real_T rtb_Product_p[2];
  real_T rtb_Sum_i;
  real_T rtb_netsum[5];
  real_T rtb_Product_oc[5];
  real_T rtb_Sum_e;
  real_T rtb_Derivative;
  real_T rtb_Derivative1_p;
  real_T rtb_Product_k[2];
  real_T rtb_Sum_j;
  real_T rtb_Product_m[2];
  real_T rtb_Sum_l1;
  real_T rtb_Product_e[2];
  real_T rtb_Sum_ao;
  real_T rtb_Product_h[2];
  real_T rtb_Sum_ls;
  real_T rtb_Product_j[2];
  real_T rtb_Sum_m;
  real_T rtb_netsum_h[5];
  real_T rtb_Product_a[5];
  real_T rtb_Sum_f;
  real_T rtb_Derivative1_c;
  real_T rtb_Derivative1_g;
  real_T rtb_Product_mi[2];
  real_T rtb_Sum_my;
  real_T rtb_Product_g[2];
  real_T rtb_Sum_c;
  real_T rtb_Product_n[2];
  real_T rtb_Sum_jn;
  real_T rtb_Product_mn[2];
  real_T rtb_Sum_lq;
  real_T rtb_Product_jm[2];
  real_T rtb_Sum_g;
  real_T rtb_netsum_l[5];
  real_T rtb_Product_et[5];
  real_T rtb_Sum_p;
  real_T rtb_Derivative2;
  real_T rtb_Derivative1_a;
  real_T rtb_Product_gv[2];
  real_T rtb_Sum_ic;
  real_T rtb_Product_f[2];
  real_T rtb_Sum_lj;
  real_T rtb_Product_n0[2];
  real_T rtb_Sum_fv;
  real_T rtb_Product_np[2];
  real_T rtb_Sum_bz;
  real_T rtb_Product_op[2];
  real_T rtb_Sum_h;
  real_T rtb_netsum_b[5];
  real_T rtb_Product_hb[5];
  real_T rtb_Sum_ht;
  real_T rtb_Derivative3;
  real_T rtb_Integrator;
  real_T rtb_Integrator3;
  real_T rtb_Integrator1;
  real_T rtb_Integrator2;

  /* Step: '<Root>/Step' */
  {
    real_T currentTime = ssGetTaskTime(S,tid);
    if (currentTime < ex33C_pid_P->Step_Time) {
      rtb_Step = ex33C_pid_P->Step_Y0;
    } else {
      rtb_Step = ex33C_pid_P->Step_YFinal;
    }
  }

  rtb_Gain12 = rtb_Step * ex33C_pid_P->Gain12_Gain;

  /* TransferFcn Block: <Root>/Transfer Fcn1 */
  rtb_TransferFcn1 =
    ex33C_pid_P->TransferFcn1_C*ex33C_pid_X->TransferFcn1_CSTATE[1];

  /* TransferFcn Block: <Root>/Transfer Fcn2 */
  rtb_TransferFcn2 =
    ex33C_pid_P->TransferFcn2_C*ex33C_pid_X->TransferFcn2_CSTATE[1];

  /* TransferFcn Block: <Root>/Transfer Fcn3 */
  rtb_TransferFcn3 =
    ex33C_pid_P->TransferFcn3_C*ex33C_pid_X->TransferFcn3_CSTATE[1];

  /* TransferFcn Block: <Root>/Transfer Fcn4 */
  rtb_TransferFcn4 =
    ex33C_pid_P->TransferFcn4_C*ex33C_pid_X->TransferFcn4_CSTATE[1];

  {
    real_T cg_in_0_6_0[5];
    int32_T i1;

    cg_in_0_6_0[0] = rtb_Gain12;
    cg_in_0_6_0[1] = rtb_TransferFcn1;
    cg_in_0_6_0[2] = rtb_TransferFcn2;
    cg_in_0_6_0[3] = rtb_TransferFcn3;
    cg_in_0_6_0[4] = rtb_TransferFcn4;
    for(i1=0; i1<5; i1++) {
      ex33C_pid_B->Gain13[i1] = cg_in_0_6_0[i1] * ex33C_pid_P->Gain13_Gain;
    }
  }

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

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

  ex33C_pid_B->Gain14[0] = rtb_Gain12 * ex33C_pid_P->Gain14_Gain;
  ex33C_pid_B->Gain14[1] = rtb_TransferFcn1 * ex33C_pid_P->Gain14_Gain;

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

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

  ex33C_pid_B->Sum12 = rtb_Gain12 - rtb_TransferFcn1;

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

    {
      int32_T i1;

      for(i1=0; i1<5; i1++) {
        ex33C_pid_B->IW211[i1] = ex33C_pid_P->IW211_Value[i1];
      }

      ex33C_pid_B->IW111[0] = ex33C_pid_P->IW111_Value[0];
      ex33C_pid_B->IW111[1] = ex33C_pid_P->IW111_Value[1];
    }
  }

  ex33C_pid_B->SE1 = ex33C_pid_B->Sum12 * ex33C_pid_P->SE1_Gain;

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

    if (timeStampA >= t && timeStampB >= t) {
      rtb_Derivative1 = 0.0;
    } else {
      real_T deltaT;
      real_T *lastBank = &ex33C_pid_DWork->Derivative1_RWORK.TimeStampA;
      if (timeStampA < timeStampB) {
        if (timeStampB < t) {
          lastBank += 2;
        }
      } else if (timeStampA >= t) {
        lastBank += 2;
      }
      deltaT = t - *lastBank++;
      rtb_Derivative1 = (ex33C_pid_B->Sum12 - *lastBank++) / deltaT;
    }
  }

  ex33C_pid_B->SDE001 = rtb_Derivative1 * ex33C_pid_P->SDE001_Gain;

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

    rtb_Product[0] = ex33C_pid_B->IW111[0] * ex33C_pid_B->SE1;
    rtb_Product[1] = ex33C_pid_B->IW111[1] * ex33C_pid_B->SDE001;

    /* Sum: '<S16>/Sum' */
    rtb_Sum = rtb_Product[0];
    rtb_Sum += rtb_Product[1];

    ex33C_pid_B->IW112[0] = ex33C_pid_P->IW112_Value[0];
    ex33C_pid_B->IW112[1] = ex33C_pid_P->IW112_Value[1];

    rtb_Product_i[0] = ex33C_pid_B->IW112[0] * ex33C_pid_B->SE1;
    rtb_Product_i[1] = ex33C_pid_B->IW112[1] * ex33C_pid_B->SDE001;

    /* Sum: '<S17>/Sum' */
    rtb_Sum_b = rtb_Product_i[0];
    rtb_Sum_b += rtb_Product_i[1];

    ex33C_pid_B->IW113[0] = ex33C_pid_P->IW113_Value[0];
    ex33C_pid_B->IW113[1] = ex33C_pid_P->IW113_Value[1];

    rtb_Product_d[0] = ex33C_pid_B->IW113[0] * ex33C_pid_B->SE1;
    rtb_Product_d[1] = ex33C_pid_B->IW113[1] * ex33C_pid_B->SDE001;

    /* Sum: '<S18>/Sum' */
    rtb_Sum_l = rtb_Product_d[0];
    rtb_Sum_l += rtb_Product_d[1];

    ex33C_pid_B->IW114[0] = ex33C_pid_P->IW114_Value[0];
    ex33C_pid_B->IW114[1] = ex33C_pid_P->IW114_Value[1];

    rtb_Product_o[0] = ex33C_pid_B->IW114[0] * ex33C_pid_B->SE1;
    rtb_Product_o[1] = ex33C_pid_B->IW114[1] * ex33C_pid_B->SDE001;

    /* Sum: '<S19>/Sum' */
    rtb_Sum_a = rtb_Product_o[0];
    rtb_Sum_a += rtb_Product_o[1];

    ex33C_pid_B->IW115[0] = ex33C_pid_P->IW115_Value[0];
    ex33C_pid_B->IW115[1] = ex33C_pid_P->IW115_Value[1];

    rtb_Product_p[0] = ex33C_pid_B->IW115[0] * ex33C_pid_B->SE1;
    rtb_Product_p[1] = ex33C_pid_B->IW115[1] * ex33C_pid_B->SDE001;

    /* Sum: '<S20>/Sum' */
    rtb_Sum_i = rtb_Product_p[0];
    rtb_Sum_i += rtb_Product_p[1];

    {
      real_T cg_in_0_31_0[5];
      int32_T i1;

      for(i1=0; i1<5; i1++) {
        ex33C_pid_B->b1[i1] = ex33C_pid_P->b1_Value[i1];
      }

      cg_in_0_31_0[0] = rtb_Sum;
      cg_in_0_31_0[1] = rtb_Sum_b;
      cg_in_0_31_0[2] = rtb_Sum_l;
      cg_in_0_31_0[3] = rtb_Sum_a;
      cg_in_0_31_0[4] = rtb_Sum_i;
      for(i1=0; i1<5; i1++) {
        rtb_netsum[i1] = cg_in_0_31_0[i1] + ex33C_pid_B->b1[i1];

        rtb_Product_oc[i1] = ex33C_pid_B->IW211[i1] *
        rt_SATURATE(rtb_netsum[i1], ex33C_pid_P->Saturation_LowerSat,
         ex33C_pid_P->Saturation_UpperSat);
      }
    }

    /* Sum: '<S25>/Sum' */
    rtb_Sum_e = rtb_Product_oc[0];
    rtb_Sum_e += rtb_Product_oc[1];
    rtb_Sum_e += rtb_Product_oc[2];
    rtb_Sum_e += rtb_Product_oc[3];
    rtb_Sum_e += rtb_Product_oc[4];

    ex33C_pid_B->b2 = ex33C_pid_P->b2_Value;

    ex33C_pid_B->SU1 = (rtb_Sum_e + ex33C_pid_B->b2) * ex33C_pid_P->SU1_Gain;
  }

  ex33C_pid_B->Sum8 = ex33C_pid_B->Sum12 + ex33C_pid_B->SU1;

  /* Derivative Block: <Root>/Derivative */
  {
    real_T t = ssGetTaskTime(S,tid);
    real_T timeStampA = ex33C_pid_DWork->Derivative_RWORK.TimeStampA;
    real_T timeStampB = ex33C_pid_DWork->Derivative_RWORK.TimeStampB;

    if (timeStampA >= t && timeStampB >= t) {
      rtb_Derivative = 0.0;
    } else {
      real_T deltaT;
      real_T *lastBank = &ex33C_pid_DWork->Derivative_RWORK.TimeStampA;
      if (timeStampA < timeStampB) {
        if (timeStampB < t) {
          lastBank += 2;
        }
      } else if (timeStampA >= t) {
        lastBank += 2;
      }
      deltaT = t - *lastBank++;
      rtb_Derivative = (ex33C_pid_B->Sum8 - *lastBank++) / deltaT;
    }
  }

  ex33C_pid_B->Sum2 = rtb_Gain12 - rtb_TransferFcn2;

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

    {
      int32_T i1;

      for(i1=0; i1<5; i1++) {
        ex33C_pid_B->IW211_e[i1] = ex33C_pid_P->IW211_Value_d[i1];
      }

      ex33C_pid_B->IW111_f[0] = ex33C_pid_P->IW111_Value_i[0];
      ex33C_pid_B->IW111_f[1] = ex33C_pid_P->IW111_Value_i[1];
    }
  }

  ex33C_pid_B->SE1_d = ex33C_pid_B->Sum2 * ex33C_pid_P->SE1_Gain_l;

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

    if (timeStampA >= t && timeStampB >= t) {
      rtb_Derivative1_p = 0.0;
    } else {
      real_T deltaT;
      real_T *lastBank = &ex33C_pid_DWork->Derivative1_RWORK_h.TimeStampA;
      if (timeStampA < timeStampB) {
        if (timeStampB < t) {
          lastBank += 2;
        }
      } else if (timeStampA >= t) {
        lastBank += 2;
      }
      deltaT = t - *lastBank++;
      rtb_Derivative1_p = (ex33C_pid_B->Sum2 - *lastBank++) / deltaT;
    }
  }

  ex33C_pid_B->SDE001_m = rtb_Derivative1_p * ex33C_pid_P->SDE001_Gain_j;

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

    rtb_Product_k[0] = ex33C_pid_B->IW111_f[0] * ex33C_pid_B->SE1_d;
    rtb_Product_k[1] = ex33C_pid_B->IW111_f[1] * ex33C_pid_B->SDE001_m;

    /* Sum: '<S37>/Sum' */
    rtb_Sum_j = rtb_Product_k[0];
    rtb_Sum_j += rtb_Product_k[1];

    ex33C_pid_B->IW112_j[0] = ex33C_pid_P->IW112_Value_m[0];
    ex33C_pid_B->IW112_j[1] = ex33C_pid_P->IW112_Value_m[1];

    rtb_Product_m[0] = ex33C_pid_B->IW112_j[0] * ex33C_pid_B->SE1_d;
    rtb_Product_m[1] = ex33C_pid_B->IW112_j[1] * ex33C_pid_B->SDE001_m;

    /* Sum: '<S38>/Sum' */
    rtb_Sum_l1 = rtb_Product_m[0];