ipa_control.c

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

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_ZE_Value[0];
        real_T *y0 = &rtb_s14_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp138;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S15>/andorMethod */
    {
      real_T min = rtb_temp155;

      if (rtb_temp152 < min) {
        min = rtb_temp152;
      }
      rtb_temp139 = min;
    }

    /* Product Block: <S15>/Weighting */
    rtb_temp139 = (rtP.s15_Weight_Value) *
      rtb_temp139;

    /* MinMax Block: <S15>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_NS_Value[0];
        real_T *y0 = &rtb_s15_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp139;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S16>/andorMethod */
    {
      real_T min = rtb_temp155;

      if (rtb_temp153 < min) {
        min = rtb_temp153;
      }
      rtb_temp140 = min;
    }

    /* Product Block: <S16>/Weighting */
    rtb_temp140 = (rtP.s16_Weight_Value) *
      rtb_temp140;

    /* MinMax Block: <S16>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_NS_Value[0];
        real_T *y0 = &rtb_s16_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp140;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S18>/andorMethod */
    {
      real_T min = rtb_temp155;

      if (rtb_temp158 < min) {
        min = rtb_temp158;
      }
      rtb_temp155 = min;
    }

    /* Product Block: <S18>/Weighting */
    rtb_temp155 = (rtP.s18_Weight_Value) *
      rtb_temp155;

    /* MinMax Block: <S18>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_NL_Value[0];
        real_T *y0 = &rtb_s18_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp155;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* Sum Block: <S41>/Sum */
    rtb_temp156 = rtb_temp157 - (rtP.s41_a_Value);
  }

  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* Sum Block: <S41>/Sum1 */
    rtB.s41_b_a = - (rtP.s41_a_Value) + (rtP.s41_b_Value);
  }

  if (ssIsContinuousTask(rtS, tid)) {   /* Sample time: [0.0, 0.0] */
    /* Product Block: <S41>/Product ab (trimf) */
    rtb_temp156 = rtb_temp156 /
      rtB.s41_b_a;
  }

  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* Sum Block: <S41>/Sum2 */
    rtB.s41_c_b = - (rtP.s41_b_Value) + (rtP.s41_c_Value);
  }

  if (ssIsContinuousTask(rtS, tid)) {   /* Sample time: [0.0, 0.0] */
    /* Sum Block: <S41>/Sum3 */
    rtb_temp157 = (rtP.s41_c_Value) - rtb_temp157;

    /* Product Block: <S41>/Product cd (trimf) */
    rtb_temp157 = 1.0 / rtB.s41_c_b *
      rtb_temp157;

    /* MinMax Block: <S41>/Min (trimf) */
    rtb_temp156 = (rtb_temp156 < rtb_temp157) ? rtb_temp156 : rtb_temp157;

    /* MinMax Block: <S41>/Max (trimf) */
    rtb_temp156 = (rtb_temp156 > (rtP.s41_0_Value)) ? rtb_temp156 : (rtP.s41_0_Value);

    /* MinMax Block: <S19>/andorMethod */
    {
      real_T min = rtb_temp156;

      if (rtb_temp159 < min) {
        min = rtb_temp159;
      }
      rtb_temp157 = min;
    }

    /* Product Block: <S19>/Weighting */
    rtb_temp157 = (rtP.s19_Weight_Value) *
      rtb_temp157;

    /* MinMax Block: <S19>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_NS_Value[0];
        real_T *y0 = &rtb_s19_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp157;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S20>/andorMethod */
    {
      real_T min = rtb_temp156;

      if (rtb_temp151 < min) {
        min = rtb_temp151;
      }
      rtb_temp159 = min;
    }

    /* Product Block: <S20>/Weighting */
    rtb_temp159 = (rtP.s20_Weight_Value) *
      rtb_temp159;

    /* MinMax Block: <S20>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_NS_Value[0];
        real_T *y0 = &rtb_s20_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp159;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S21>/andorMethod */
    {
      real_T min = rtb_temp156;

      if (rtb_temp152 < min) {
        min = rtb_temp152;
      }
      rtb_temp151 = min;
    }

    /* Product Block: <S21>/Weighting */
    rtb_temp151 = (rtP.s21_Weight_Value) *
      rtb_temp151;

    /* MinMax Block: <S21>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_NL_Value[0];
        real_T *y0 = &rtb_s21_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp151;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S22>/andorMethod */
    {
      real_T min = rtb_temp156;

      if (rtb_temp153 < min) {
        min = rtb_temp153;
      }
      rtb_temp152 = min;
    }

    /* Product Block: <S22>/Weighting */
    rtb_temp152 = (rtP.s22_Weight_Value) *
      rtb_temp152;

    /* MinMax Block: <S22>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_NL_Value[0];
        real_T *y0 = &rtb_s22_impMethod[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp152;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S23>/andorMethod */
    {
      real_T min = rtb_temp156;

      if (rtb_temp158 < min) {
        min = rtb_temp158;
      }
      rtb_temp156 = min;
    }

    /* Product Block: <S23>/Weighting */
    rtb_temp156 = (rtP.s23_Weight_Value) *
      rtb_temp156;

    /* MinMax Block: <S23>/impMethod */
    {
      real_T min;

      {
        int_T i1;
        const real_T *u1 = &rtP.s33_NL_Value[0];
        real_T *y0 = &rtb_temp141[0];

        for (i1=0; i1 < 101; i1++) {
          min = rtb_temp156;
          if (u1[i1] < min) {
            min = u1[i1];
          }
          y0[i1] = min;
        }
      }
    }

    /* MinMax Block: <S4>/aggMethod1 */
    {
      real_T max;

      {
        int_T i1;
        const real_T *u0 = &rtb_temp131[0];
        const real_T *u1 = &rtb_s17_impMethod[0];
        const real_T *u2 = &rtb_s24_impMethod[0];
        const real_T *u3 = &rtb_s25_impMethod[0];
        const real_T *u4 = &rtb_s26_impMethod[0];
        const real_T *u5 = &rtb_s27_impMethod[0];
        const real_T *u6 = &rtb_s28_impMethod[0];
        const real_T *u7 = &rtb_s29_impMethod[0];
        const real_T *u8 = &rtb_s30_impMethod[0];
        const real_T *u9 = &rtb_s7_impMethod[0];
        const real_T *u10 = &rtb_s8_impMethod[0];
        const real_T *u11 = &rtb_s9_impMethod[0];
        const real_T *u12 = &rtb_s10_impMethod[0];
        const real_T *u13 = &rtb_s11_impMethod[0];
        const real_T *u14 = &rtb_s12_impMethod[0];
        const real_T *u15 = &rtb_s13_impMethod[0];
        const real_T *u16 = &rtb_s14_impMethod[0];
        const real_T *u17 = &rtb_s15_impMethod[0];
        const real_T *u18 = &rtb_s16_impMethod[0];
        const real_T *u19 = &rtb_s18_impMethod[0];
        const real_T *u20 = &rtb_s19_impMethod[0];
        const real_T *u21 = &rtb_s20_impMethod[0];
        const real_T *u22 = &rtb_s21_impMethod[0];
        const real_T *u23 = &rtb_s22_impMethod[0];
        const real_T *u24 = &rtb_temp141[0];
        real_T *y0 = &rtb_temp131[0];

        for (i1=0; i1 < 101; i1++) {
          max = u0[i1];
          if (u1[i1] > max) {
            max = u1[i1];
          }
          if (u2[i1] > max) {
            max = u2[i1];
          }
          if (u3[i1] > max) {
            max = u3[i1];
          }
          if (u4[i1] > max) {
            max = u4[i1];
          }
          if (u5[i1] > max) {
            max = u5[i1];
          }
          if (u6[i1] > max) {
            max = u6[i1];
          }
          if (u7[i1] > max) {
            max = u7[i1];
          }
          if (u8[i1] > max) {
            max = u8[i1];
          }
          if (u9[i1] > max) {
            max = u9[i1];
          }
          if (u10[i1] > max) {
            max = u10[i1];
          }
          if (u11[i1] > max) {
            max = u11[i1];
          }
          if (u12[i1] > max) {
            max = u12[i1];
          }
          if (u13[i1] > max) {
            max = u13[i1];
          }
          if (u14[i1] > max) {
            max = u14[i1];
          }
          if (u15[i1] > max) {
            max = u15[i1];
          }
          if (u16[i1] > max) {
            max = u16[i1];
          }
          if (u17[i1] > max) {
            max = u17[i1];
          }
          if (u18[i1] > max) {
            max = u18[i1];
          }
          if (u19[i1] > max) {
            max = u19[i1];
          }
          if (u20[i1] > max) {
            max = u20[i1];
          }
          if (u21[i1] > max) {
            max = u21[i1];
          }
          if (u22[i1] > max) {
            max = u22[i1];
          }
          if (u23[i1] > max) {
            max = u23[i1];
          }
          if (u24[i1] > max) {
            max = u24[i1];
          }
          y0[i1] = max;
        }
      }
    }

    /* Product Block: <S5>/Product (COA) */
    {
      int_T i1;
      const real_T *u0 = &rtP.s5_x_data_Value[0];
      const real_T *u1 = &rtb_temp131[0];
      real_T *y0 = &rtb_temp141[0];

      for (i1=0; i1 < 101; i1++) {
        y0[i1] = u0[i1] *
          u1[i1];
      }
    }

    /* Sum Block: <S5>/Sum */
    rtb_temp158 = rtb_temp141[0];
    {
      int_T i1;
      const real_T *u0 = &rtb_temp141[1];

      for (i1=0; i1 < 100; i1++) {
        rtb_temp158 += u0[i1];
      }
    }

    /* Sum Block: <S5>/Sum1 */
    rtb_temp153 = rtb_temp131[0];
    {
      int_T i1;
      const real_T *u0 = &rtb_temp131[1];

      for (i1=0; i1 < 100; i1++) {
        rtb_temp153 += u0[i1];
      }
    }

    /* RelationalOperator Block: <S5>/Zero Strength (COA) */
    rtb_temp142 = (rtb_temp153 <= (rtP.s5_Prevent_Div_1_Value));

    /* MinMax Block: <S5>/Max (COA) */
    rtb_temp153 = (rtb_temp153 > rtb_temp142) ? rtb_temp153 : rtb_temp142;

    /* Product Block: <S5>/Averaging (COA) */
    rtb_temp158 = rtb_temp158 /
      rtb_temp153;

    /* Sum Block: <S4>/Total Firing Strength */
    rtb_temp150 = rtb_temp150 + rtb_temp143 + rtb_temp144 + rtb_temp145
      + rtb_temp149 + rtb_temp146 + rtb_temp132 + rtb_temp133 + rtb_temp134
      + rtb_temp160 + rtb_temp147 + rtb_temp135 + rtb_temp136 + rtb_temp137
      + rtb_temp154 + rtb_temp148 + rtb_temp138 + rtb_temp139 + rtb_temp140
      + rtb_temp155 + rtb_temp157 + rtb_temp159 + rtb_temp151 + rtb_temp152
      + rtb_temp156;

    /* RelationalOperator Block: <S4>/Zero Firing Strength? */
    rtb_temp150 = (rtb_temp150 > (rtP.s4_Zero_Value));

    /* Switch Block: <S4>/Switch */
    if (rtb_temp150 >= (rtP.s4_Switch_Threshold)) {
      rtb_temp158 = rtb_temp158;
    } else {
      rtb_temp158 = (rtP.s4_MidRange_Value);
    }

    /* Gain Block: <S1>/Gain3 */
    rtB.s1_Gain3 = rtb_temp158 * (rtP.s1_Gain3_Gain);

    /* TransferFcn Block: <S2>/Motor Transfer Fcn */
    rtb_temp142 = rtP.s2_Motor_Transfer_Fcn_C*rtX.s2_Motor_Transfer_Fcn;
    /* Fcn Block: <S2>/Fcn */
    /* Expression: 6*(9.8*sin(u(1))+0.6667*cos(u(1))*(-u(3)-0.25*u(2)*u(2)*sin(u(1))))/(4-cos(u(1))*cos(u(1))) */
    rtB.s2_Fcn = 6.0 * ( 9.8 * sin( rtb_temp130 ) + 0.6667 * cos(
        rtb_temp130 ) * ( ( -rtb_temp142 ) - 0.25 * rtB.s2_Integrator *
        rtB.s2_Integrator * sin( rtb_temp130 ) ) ) / ( 4.0 - cos(
        rtb_temp130 ) * cos( rtb_temp130 ) );

    /* Clock Block: <Root>/Clock */
    rtB.root_Clock = ssGetT(rtS);
  }

  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* ToWorkspace Block: <Root>/To Workspace2 */
    rt_UpdateLogVar((LogVar*) (rtDWork.root_To_Workspace2_PWORK.LoggedData), &rtB.root_Clock);
  }
}

/* Perform model update */
void MdlUpdate(int_T tid)
{
  if (ssIsSampleHit(rtS, 1, tid)) {     /* Sample time: [0.01, 0.0] */
    /* RandomNumber Block: <Root>/Random Number */

    rtDWork.root_Random_Number_RWORK.NextOutput = rt_NormalRand((uint_T *)&rtDWork.root_Random_Number_IWORK.RandSeed)*(rtP.root_Random_Number_StdDev)+(rtP.root_Random_Number_Mean);
  }

  if (ssIsContinuousTask(rtS, tid)) {   /* Sample time: [0.0, 0.0] */
    /* Derivative Block: <Root>/Derivative */
    {
      real_T timeStampA = rtDWork.root_Derivative_RWORK.TimeStampA;
      real_T timeStampB = rtDWork.root_Derivative_RWORK.TimeStampB;
      real_T *lastBank = &rtDWork.root_Derivative_RWORK.TimeStampA;

      if (timeStampA != rtInf) {
        if (timeStampB == rtInf) {
          lastBank += 2;
        } else if (timeStampA >= timeStampB) {
          lastBank += 2;
        }
      }
      *lastBank++ = ssGetTaskTime(rtS,tid);
      *lastBank++ = rtB.root_Sum;
    }
  }
}

/* Compute model derivatives */
void MdlDerivatives(void)
{
  /* Integrator Block: <S2>/Integrator1 */
  {
    real_T *dx = ssGetdX(rtS);

    dx[0] = rtB.s2_Integrator;
  }

  /* Integrator Block: <S2>/Integrator */
  {
    real_T *dx = ssGetdX(rtS);

    dx[1] = rtB.s2_Fcn;
  }

  /* TransferFcn Block: <S2>/Motor Transfer Fcn */
  {
    real_T *dx = ssGetdX(rtS)+2;

    dx[0] = rtB.s1_Gain3;
    dx[0] += (rtP.s2_Motor_Transfer_Fcn_A)*rtX.s2_Motor_Transfer_Fcn;
  }
}

/* Terminate function */
void MdlTerminate(void)
{
  /* (no terminate code required) */
}

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

#include "IPa_control_reg.h"

/* [EOF] IPa_control.c */