ex33d_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.
 */

/*
 * ex33D_pid_acc.c
 * 
 * Real-Time Workshop code generation for Simulink model "ex33D_pid_acc.mdl".
 *
 * Model Version              : 1.74
 * Real-Time Workshop version : 6.1  (R14SP1)  05-Sep-2004
 * C source code generated on : Wed Jul 20 11:56:57 2005
 */

#include <math.h>
#include <string.h>
#include "ex33D_pid_acc.h"
#include "ex33D_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 */
  ex33D_pid_BlockIO *ex33D_pid_B = (ex33D_pid_BlockIO *) _ssGetBlockIO(S);
  ex33D_pid_ContinuousStates *ex33D_pid_X = (ex33D_pid_ContinuousStates*)
    ssGetContStates(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);

  /* 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_k[2];
  real_T rtb_Sum_c;
  real_T rtb_Product_m[2];
  real_T rtb_Sum_e;
  real_T rtb_Product_p[2];
  real_T rtb_Sum_h;
  real_T rtb_Product_d[2];
  real_T rtb_Sum_ed;
  real_T rtb_netsum[5];
  real_T rtb_Product_kw[5];
  real_T rtb_Sum_e5;
  real_T rtb_Derivative;
  real_T rtb_Derivative1_a;
  real_T rtb_Product_f[2];
  real_T rtb_Sum_g;
  real_T rtb_Product_b[2];
  real_T rtb_Sum_l;
  real_T rtb_Product_dc[2];
  real_T rtb_Sum_hl;
  real_T rtb_Product_o[2];
  real_T rtb_Sum_o;
  real_T rtb_Product_l[2];
  real_T rtb_Sum_hq;
  real_T rtb_netsum_o[5];
  real_T rtb_Product_kr[5];
  real_T rtb_Sum_f;
  real_T rtb_Derivative1_k;
  real_T rtb_Derivative1_j;
  real_T rtb_Product_kv[2];
  real_T rtb_Sum_ho;
  real_T rtb_Product_og[2];
  real_T rtb_Sum_k;
  real_T rtb_Product_c[2];
  real_T rtb_Sum_lj;
  real_T rtb_Product_fa[2];
  real_T rtb_Sum_n;
  real_T rtb_Product_e[2];
  real_T rtb_Sum_hw;
  real_T rtb_netsum_a[5];
  real_T rtb_Product_eu[5];
  real_T rtb_Sum_kj;
  real_T rtb_Derivative2;
  real_T rtb_Derivative1_jp;
  real_T rtb_Product_j[2];
  real_T rtb_Sum_k1;
  real_T rtb_Product_cn[2];
  real_T rtb_Sum_fo;
  real_T rtb_Product_n[2];
  real_T rtb_Sum_gl;
  real_T rtb_Product_cw[2];
  real_T rtb_Sum_g2;
  real_T rtb_Product_k1[2];
  real_T rtb_Sum_k2;
  real_T rtb_netsum_ge[5];
  real_T rtb_Product_l5[5];
  real_T rtb_Sum_h0;
  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 < ex33D_pid_P->Step_Time) {
      rtb_Step = ex33D_pid_P->Step_Y0;
    } else {
      rtb_Step = ex33D_pid_P->Step_YFinal;
    }
  }

  rtb_Gain12 = rtb_Step * ex33D_pid_P->Gain12_Gain;

  /* TransferFcn Block: <Root>/Transfer Fcn1 */
  rtb_TransferFcn1 =
    (ex33D_pid_P->TransferFcn1_C[0])*ex33D_pid_X->TransferFcn1_CSTATE[3]
    + (ex33D_pid_P->TransferFcn1_C[1])*ex33D_pid_X->TransferFcn1_CSTATE[4]
    + (ex33D_pid_P->TransferFcn1_C[2])*ex33D_pid_X->TransferFcn1_CSTATE[5];

  /* TransferFcn Block: <Root>/Transfer Fcn2 */
  rtb_TransferFcn2 =
    (ex33D_pid_P->TransferFcn2_C[0])*ex33D_pid_X->TransferFcn2_CSTATE[3]
    + (ex33D_pid_P->TransferFcn2_C[1])*ex33D_pid_X->TransferFcn2_CSTATE[4]
    + (ex33D_pid_P->TransferFcn2_C[2])*ex33D_pid_X->TransferFcn2_CSTATE[5];

  /* TransferFcn Block: <Root>/Transfer Fcn3 */
  rtb_TransferFcn3 =
    (ex33D_pid_P->TransferFcn3_C[0])*ex33D_pid_X->TransferFcn3_CSTATE[3]
    + (ex33D_pid_P->TransferFcn3_C[1])*ex33D_pid_X->TransferFcn3_CSTATE[4]
    + (ex33D_pid_P->TransferFcn3_C[2])*ex33D_pid_X->TransferFcn3_CSTATE[5];

  /* TransferFcn Block: <Root>/Transfer Fcn4 */
  rtb_TransferFcn4 =
    (ex33D_pid_P->TransferFcn4_C[0])*ex33D_pid_X->TransferFcn4_CSTATE[3]
    + (ex33D_pid_P->TransferFcn4_C[1])*ex33D_pid_X->TransferFcn4_CSTATE[4]
    + (ex33D_pid_P->TransferFcn4_C[2])*ex33D_pid_X->TransferFcn4_CSTATE[5];

  {
    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++) {
      ex33D_pid_B->Gain13[i1] = cg_in_0_6_0[i1] * ex33D_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);
  }

  ex33D_pid_B->Gain14[0] = rtb_Gain12 * ex33D_pid_P->Gain14_Gain;
  ex33D_pid_B->Gain14[1] = rtb_TransferFcn1 * ex33D_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);
  }

  ex33D_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++) {
        ex33D_pid_B->IW211[i1] = ex33D_pid_P->IW211_Value[i1];
      }

      ex33D_pid_B->IW111[0] = ex33D_pid_P->IW111_Value[0];
      ex33D_pid_B->IW111[1] = ex33D_pid_P->IW111_Value[1];
    }
  }

  ex33D_pid_B->SE1 = ex33D_pid_B->Sum12 * ex33D_pid_P->SE1_Gain;

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

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

  ex33D_pid_B->SDE001 = rtb_Derivative1 * ex33D_pid_P->SDE001_Gain;

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

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

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

    ex33D_pid_B->IW112[0] = ex33D_pid_P->IW112_Value[0];
    ex33D_pid_B->IW112[1] = ex33D_pid_P->IW112_Value[1];

    rtb_Product_k[0] = ex33D_pid_B->IW112[0] * ex33D_pid_B->SE1;
    rtb_Product_k[1] = ex33D_pid_B->IW112[1] * ex33D_pid_B->SDE001;

    /* Sum: '<S17>/Sum' */
    rtb_Sum_c = rtb_Product_k[0];
    rtb_Sum_c += rtb_Product_k[1];

    ex33D_pid_B->IW113[0] = ex33D_pid_P->IW113_Value[0];
    ex33D_pid_B->IW113[1] = ex33D_pid_P->IW113_Value[1];

    rtb_Product_m[0] = ex33D_pid_B->IW113[0] * ex33D_pid_B->SE1;
    rtb_Product_m[1] = ex33D_pid_B->IW113[1] * ex33D_pid_B->SDE001;

    /* Sum: '<S18>/Sum' */
    rtb_Sum_e = rtb_Product_m[0];
    rtb_Sum_e += rtb_Product_m[1];

    ex33D_pid_B->IW114[0] = ex33D_pid_P->IW114_Value[0];
    ex33D_pid_B->IW114[1] = ex33D_pid_P->IW114_Value[1];

    rtb_Product_p[0] = ex33D_pid_B->IW114[0] * ex33D_pid_B->SE1;
    rtb_Product_p[1] = ex33D_pid_B->IW114[1] * ex33D_pid_B->SDE001;

    /* Sum: '<S19>/Sum' */
    rtb_Sum_h = rtb_Product_p[0];
    rtb_Sum_h += rtb_Product_p[1];

    ex33D_pid_B->IW115[0] = ex33D_pid_P->IW115_Value[0];
    ex33D_pid_B->IW115[1] = ex33D_pid_P->IW115_Value[1];

    rtb_Product_d[0] = ex33D_pid_B->IW115[0] * ex33D_pid_B->SE1;
    rtb_Product_d[1] = ex33D_pid_B->IW115[1] * ex33D_pid_B->SDE001;

    /* Sum: '<S20>/Sum' */
    rtb_Sum_ed = rtb_Product_d[0];
    rtb_Sum_ed += rtb_Product_d[1];

    {
      real_T cg_in_0_31_0[5];
      int32_T i1;

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

      cg_in_0_31_0[0] = rtb_Sum;
      cg_in_0_31_0[1] = rtb_Sum_c;
      cg_in_0_31_0[2] = rtb_Sum_e;
      cg_in_0_31_0[3] = rtb_Sum_h;
      cg_in_0_31_0[4] = rtb_Sum_ed;
      for(i1=0; i1<5; i1++) {
        rtb_netsum[i1] = cg_in_0_31_0[i1] + ex33D_pid_B->b1[i1];

        rtb_Product_kw[i1] = ex33D_pid_B->IW211[i1] *
        rt_SATURATE(rtb_netsum[i1], ex33D_pid_P->Saturation_LowerSat,
         ex33D_pid_P->Saturation_UpperSat);
      }
    }

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

    ex33D_pid_B->b2 = ex33D_pid_P->b2_Value;

    ex33D_pid_B->SU1 = (rtb_Sum_e5 + ex33D_pid_B->b2) * ex33D_pid_P->SU1_Gain;
  }

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

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

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

  ex33D_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++) {
        ex33D_pid_B->IW211_a[i1] = ex33D_pid_P->IW211_Value_g[i1];
      }

      ex33D_pid_B->IW111_i[0] = ex33D_pid_P->IW111_Value_l[0];
      ex33D_pid_B->IW111_i[1] = ex33D_pid_P->IW111_Value_l[1];
    }
  }

  ex33D_pid_B->SE1_a = ex33D_pid_B->Sum2 * ex33D_pid_P->SE1_Gain_p;

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

    if (timeStampA >= t && timeStampB >= t) {
      rtb_Derivative1_a = 0.0;
    } else {
      real_T deltaT;
      real_T *lastBank = &ex33D_pid_DWork->Derivative1_RWORK_n.TimeStampA;
      if (timeStampA < timeStampB) {
        if (timeStampB < t) {
          lastBank += 2;
        }
      } else if (timeStampA >= t) {
        lastBank += 2;
      }
      deltaT = t - *lastBank++;
      rtb_Derivative1_a = (ex33D_pid_B->Sum2 - *lastBank++) / deltaT;
    }
  }

  ex33D_pid_B->SDE001_b = rtb_Derivative1_a * ex33D_pid_P->SDE001_Gain_j;

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

    rtb_Product_f[0] = ex33D_pid_B->IW111_i[0] * ex33D_pid_B->SE1_a;
    rtb_Product_f[1] = ex33D_pid_B->IW111_i[1] * ex33D_pid_B->SDE001_b;

    /* Sum: '<S37>/Sum' */
    rtb_Sum_g = rtb_Product_f[0];
    rtb_Sum_g += rtb_Product_f[1];

    ex33D_pid_B->IW112_g[0] = ex33D_pid_P->IW112_Value_e[0];
    ex33D_pid_B->IW112_g[1] = ex33D_pid_P->IW112_Value_e[1];

    rtb_Product_b[0] = ex33D_pid_B->IW112_g[0] * ex33D_pid_B->SE1_a;
    rtb_Product_b[1] = ex33D_pid_B->IW112_g[1] * ex33D_pid_B->SDE001_b;

    /* Sum: '<S38>/Sum' */
    rtb_Sum_l = rtb_Product_b[0];
    rtb_Sum_l += rtb_Product_b[1];

    ex33D_pid_B->IW113_h[0] = ex33D_pid_P->IW113_Value_e[0];
    ex33D_pid_B->IW113_h[1] = ex33D_pid_P->IW113_Value_e[1];

    rtb_Product_dc[0] = ex33D_pid_B->IW113_h[0] * ex33D_pid_B->SE1_a;
    rtb_Product_dc[1] = ex33D_pid_B->IW113_h[1] * ex33D_pid_B->SDE001_b;

    /* Sum: '<S39>/Sum' */
    rtb_Sum_hl = rtb_Product_dc[0];
    rtb_Sum_hl += rtb_Product_dc[1];

    ex33D_pid_B->IW114_o[0] = ex33D_pid_P->IW114_Value_g[0];
    ex33D_pid_B->IW114_o[1] = ex33D_pid_P->IW114_Value_g[1];

    rtb_Product_o[0] = ex33D_pid_B->IW114_o[0] * ex33D_pid_B->SE1_a;
    rtb_Product_o[1] = ex33D_pid_B->IW114_o[1] * ex33D_pid_B->SDE001_b;

    /* Sum: '<S40>/Sum' */
    rtb_Sum_o = rtb_Product_o[0];
    rtb_Sum_o += rtb_Product_o[1];