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

/*
 * pidNNtune_NCD_acc.c
 * 
 * Real-Time Workshop code generation for Simulink model "pidNNtune_NCD_acc.mdl".
 *
 * Model Version              : 1.206
 * Real-Time Workshop version : 6.1  (R14SP1)  05-Sep-2004
 * C source code generated on : Thu May 26 04:56:18 2005
 */

#include <math.h>
#include <string.h>
#include "pidNNtune_NCD_acc.h"
#include "pidNNtune_NCD_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 */
  pidNNtune_NCD_BlockIO *pidNNtune_NCD_B = (pidNNtune_NCD_BlockIO *)
    _ssGetBlockIO(S);
  pidNNtune_NCD_ContinuousStates *pidNNtune_NCD_X =
    (pidNNtune_NCD_ContinuousStates*) ssGetContStates(S);
  pidNNtune_NCD_D_Work *pidNNtune_NCD_DWork = (pidNNtune_NCD_D_Work *)
    ssGetRootDWork(S);
  pidNNtune_NCD_Parameters *pidNNtune_NCD_P = (pidNNtune_NCD_Parameters *)
    ssGetDefaultParam(S);

  /* local block i/o variables */

  real_T rtb_Step;
  real_T rtb_Step1;
  real_T rtb_SU2;
  real_T rtb_IdentifiedPlantModel;
  real_T rtb_Abs;
  real_T rtb_Derivative1_j;
  real_T rtb_Sum1;
  real_T rtb_BandlimitedDerivative;
  real_T rtb_Integrator;

  real_T rtb_Product_dn[5];
  real_T rtb_Sum_o;

  real_T rtb_Product[2];
  real_T rtb_Sum_l;
  real_T rtb_Product_g[2];
  real_T rtb_Sum_p;
  real_T rtb_Product_a[2];
  real_T rtb_Sum_le;
  real_T rtb_Product_l[2];
  real_T rtb_Sum_j;
  real_T rtb_Product_d[2];
  real_T rtb_Sum_px;
  real_T rtb_netsum[5];

  /* Step: '<Root>/Step' */
  if (ssIsMajorTimeStep(S)) {
    real_T currentTime = ssGetTaskTime(S,tid);
    if (currentTime >= pidNNtune_NCD_P->Step_Time) {
      pidNNtune_NCD_DWork->Step_MODE = 1;
    } else {
      pidNNtune_NCD_DWork->Step_MODE = 0;
    }
  }
  /* Output value */
  rtb_Step = (pidNNtune_NCD_DWork->Step_MODE == 1) ?
    pidNNtune_NCD_P->Step_YFinal : pidNNtune_NCD_P->Step_Y0;

  /* Step: '<Root>/Step1' */
  if (ssIsMajorTimeStep(S)) {
    real_T currentTime = ssGetTaskTime(S,tid);
    if (currentTime >= pidNNtune_NCD_P->Step1_Time) {
      pidNNtune_NCD_DWork->Step1_MODE = 1;
    } else {
      pidNNtune_NCD_DWork->Step1_MODE = 0;
    }
  }
  /* Output value */
  rtb_Step1 = (pidNNtune_NCD_DWork->Step1_MODE == 1) ?
    pidNNtune_NCD_P->Step1_YFinal : pidNNtune_NCD_P->Step1_Y0;

  rtb_SU2 = (rtb_Step + rtb_Step1) * pidNNtune_NCD_P->SU2_Gain;

  /* TransferFcn Block: <S4>/Identified Plant Model */
  rtb_IdentifiedPlantModel =
    pidNNtune_NCD_P->IdentifiedPlantModel_C*pidNNtune_NCD_X->IdentifiedPlantModel_CSTATE[2];

  pidNNtune_NCD_B->Sum = rtb_SU2 - rtb_IdentifiedPlantModel;

  /* Abs: '<Root>/Abs' */
  if (ssIsMajorTimeStep(S)) {
    pidNNtune_NCD_DWork->Abs_MODE = pidNNtune_NCD_B->Sum >= 0.0;
  }
  rtb_Abs = (pidNNtune_NCD_DWork->Abs_MODE)?
    pidNNtune_NCD_B->Sum:-(pidNNtune_NCD_B->Sum);

  pidNNtune_NCD_B->SU3[0] = rtb_SU2 * pidNNtune_NCD_P->SU3_Gain;
  pidNNtune_NCD_B->SU3[1] = rtb_IdentifiedPlantModel * pidNNtune_NCD_P->SU3_Gain;
  pidNNtune_NCD_B->SU3[2] = rtb_Abs * pidNNtune_NCD_P->SU3_Gain;

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

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

    if (timeStampA >= t && timeStampB >= t) {
      rtb_Derivative1_j = 0.0;
    } else {
      real_T deltaT;
      real_T *lastBank = &pidNNtune_NCD_DWork->Derivative1_RWORK.TimeStampA;
      if (timeStampA < timeStampB) {
        if (timeStampB < t) {
          lastBank += 2;
        }
      } else if (timeStampA >= t) {
        lastBank += 2;
      }
      deltaT = t - *lastBank++;
      rtb_Derivative1_j = (pidNNtune_NCD_B->Sum - *lastBank++) / deltaT;
    }
  }

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

    pidNNtune_NCD_B->IW111[0] = pidNNtune_NCD_P->IW111_Value[0];
    pidNNtune_NCD_B->IW111[1] = pidNNtune_NCD_P->IW111_Value[1];

    pidNNtune_NCD_B->IW112[0] = pidNNtune_NCD_P->IW112_Value[0];
    pidNNtune_NCD_B->IW112[1] = pidNNtune_NCD_P->IW112_Value[1];

    pidNNtune_NCD_B->IW113[0] = pidNNtune_NCD_P->IW113_Value[0];
    pidNNtune_NCD_B->IW113[1] = pidNNtune_NCD_P->IW113_Value[1];

    pidNNtune_NCD_B->IW114[0] = pidNNtune_NCD_P->IW114_Value[0];
    pidNNtune_NCD_B->IW114[1] = pidNNtune_NCD_P->IW114_Value[1];

    pidNNtune_NCD_B->IW115[0] = pidNNtune_NCD_P->IW115_Value[0];
    pidNNtune_NCD_B->IW115[1] = pidNNtune_NCD_P->IW115_Value[1];
  }

  pidNNtune_NCD_B->SE1 = pidNNtune_NCD_B->Sum * pidNNtune_NCD_P->SE1_Gain;

  pidNNtune_NCD_B->SDE001 = rtb_Derivative1_j * pidNNtune_NCD_P->SDE001_Gain;

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

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

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

    rtb_Product_g[0] = pidNNtune_NCD_B->IW112[0] * pidNNtune_NCD_B->SE1;
    rtb_Product_g[1] = pidNNtune_NCD_B->IW112[1] * pidNNtune_NCD_B->SDE001;

    /* Sum: '<S17>/Sum' */
    rtb_Sum_p = rtb_Product_g[0];
    rtb_Sum_p += rtb_Product_g[1];

    rtb_Product_a[0] = pidNNtune_NCD_B->IW113[0] * pidNNtune_NCD_B->SE1;
    rtb_Product_a[1] = pidNNtune_NCD_B->IW113[1] * pidNNtune_NCD_B->SDE001;

    /* Sum: '<S18>/Sum' */
    rtb_Sum_le = rtb_Product_a[0];
    rtb_Sum_le += rtb_Product_a[1];

    rtb_Product_l[0] = pidNNtune_NCD_B->IW114[0] * pidNNtune_NCD_B->SE1;
    rtb_Product_l[1] = pidNNtune_NCD_B->IW114[1] * pidNNtune_NCD_B->SDE001;

    /* Sum: '<S19>/Sum' */
    rtb_Sum_j = rtb_Product_l[0];
    rtb_Sum_j += rtb_Product_l[1];

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

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

    {
      real_T cg_in_0_28_0[5];
      int32_T i1;

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

      cg_in_0_28_0[0] = rtb_Sum_l;
      cg_in_0_28_0[1] = rtb_Sum_p;
      cg_in_0_28_0[2] = rtb_Sum_le;
      cg_in_0_28_0[3] = rtb_Sum_j;
      cg_in_0_28_0[4] = rtb_Sum_px;
      for(i1=0; i1<5; i1++) {
        rtb_netsum[i1] = cg_in_0_28_0[i1] + pidNNtune_NCD_B->b1[i1];

        pidNNtune_NCD_B->Saturation[i1] = rt_SATURATE(rtb_netsum[i1],
         pidNNtune_NCD_P->Saturation_LowerSat,
         pidNNtune_NCD_P->Saturation_UpperSat);
      }
    }
  }
  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    {
      int32_T i1;

      for(i1=0; i1<5; i1++) {
        pidNNtune_NCD_B->IW211[i1] = pidNNtune_NCD_P->IW211_Value[i1];

        rtb_Product_dn[i1] = pidNNtune_NCD_B->IW211[i1] *
          pidNNtune_NCD_B->Saturation[i1];
      }
    }

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

    pidNNtune_NCD_B->b2 = pidNNtune_NCD_P->b2_Value;

    pidNNtune_NCD_B->SU1 = (rtb_Sum_o + pidNNtune_NCD_B->b2) *
      pidNNtune_NCD_P->SU1_Gain * pidNNtune_NCD_P->SU1_Gain_o;
  }

  rtb_Sum1 = pidNNtune_NCD_B->SU1 + pidNNtune_NCD_B->Sum;

  pidNNtune_NCD_B->Derivative = rtb_Sum1 * pidNNtune_NCD_P->Derivative_Gain;

  /* TransferFcn Block: <S3>/Band-limited Derivative */
  rtb_BandlimitedDerivative =
    pidNNtune_NCD_P->BandlimitedDerivative_D*pidNNtune_NCD_B->Derivative;
  rtb_BandlimitedDerivative +=
    (pidNNtune_NCD_P->BandlimitedDerivative_C)*pidNNtune_NCD_X->BandlimitedDerivative_CSTATE;

  pidNNtune_NCD_B->Integral = rtb_Sum1 * pidNNtune_NCD_P->Integral_Gain;

  /* Integrator: '<S3>/Integrator' */
  rtb_Integrator = pidNNtune_NCD_X->Integrator_CSTATE;

  pidNNtune_NCD_B->Sum_h = (rtb_Sum1 * pidNNtune_NCD_P->Proportional_Gain +
    rtb_Integrator) + rtb_BandlimitedDerivative;

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

    pidNNtune_NCD_B->Derivative_p = pidNNtune_NCD_P->Derivative_Value;

    /* Display: '<Root>/Derivative Gain' */
    /* Call into Simulink for Display */
    ssCallAccelRunBlock(S, 0, 45, SS_CALL_MDL_OUTPUTS);

    pidNNtune_NCD_B->Derivative1 = pidNNtune_NCD_P->Derivative1_Value;

    /* Display: '<Root>/Derivative Gain1' */
    /* Call into Simulink for Display */
    ssCallAccelRunBlock(S, 0, 47, SS_CALL_MDL_OUTPUTS);

    pidNNtune_NCD_B->Derivative2 = pidNNtune_NCD_P->Derivative2_Value;

    /* Display: '<Root>/Derivative Gain2' */
    /* Call into Simulink for Display */
    ssCallAccelRunBlock(S, 0, 49, SS_CALL_MDL_OUTPUTS);

    pidNNtune_NCD_B->Integral_h = pidNNtune_NCD_P->Integral_Value;

    /* Display: '<Root>/Integral Gain' */
    /* Call into Simulink for Display */
    ssCallAccelRunBlock(S, 0, 51, SS_CALL_MDL_OUTPUTS);

    pidNNtune_NCD_B->Integral1 = pidNNtune_NCD_P->Integral1_Value;

    /* Display: '<Root>/Integral Gain1' */
    /* Call into Simulink for Display */
    ssCallAccelRunBlock(S, 0, 53, SS_CALL_MDL_OUTPUTS);

    pidNNtune_NCD_B->Proportional = pidNNtune_NCD_P->Proportional_Value;

    /* Display: '<Root>/Proportional Gain' */
    /* Call into Simulink for Display */
    ssCallAccelRunBlock(S, 0, 55, SS_CALL_MDL_OUTPUTS);

    pidNNtune_NCD_B->Proportional1 = pidNNtune_NCD_P->Proportional1_Value;

    /* Display: '<Root>/Proportional Gain1' */
    /* Call into Simulink for Display */
    ssCallAccelRunBlock(S, 0, 57, SS_CALL_MDL_OUTPUTS);
  }
}

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

  /* simstruct variables */
  pidNNtune_NCD_BlockIO *pidNNtune_NCD_B = (pidNNtune_NCD_BlockIO *)
    _ssGetBlockIO(S);
  pidNNtune_NCD_D_Work *pidNNtune_NCD_DWork = (pidNNtune_NCD_D_Work *)
    ssGetRootDWork(S);

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

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

/* Derivatives for root system: '<Root>' */
#define MDL_DERIVATIVES
static void mdlDerivatives(SimStruct *S)
{
  /* simstruct variables */
  pidNNtune_NCD_BlockIO *pidNNtune_NCD_B = (pidNNtune_NCD_BlockIO *)
    _ssGetBlockIO(S);
  pidNNtune_NCD_ContinuousStates *pidNNtune_NCD_X =
    (pidNNtune_NCD_ContinuousStates*) ssGetContStates(S);
  pidNNtune_NCD_StateDerivatives *pidNNtune_NCD_Xdot =
    (pidNNtune_NCD_StateDerivatives*) ssGetdX(S);
  pidNNtune_NCD_Parameters *pidNNtune_NCD_P = (pidNNtune_NCD_Parameters *)
    ssGetDefaultParam(S);

  /* TransferFcn Block: <S4>/Identified Plant Model */
  {

    pidNNtune_NCD_Xdot->IdentifiedPlantModel_CSTATE[0] =
      pidNNtune_NCD_P->IdentifiedPlantModel_B*pidNNtune_NCD_B->Sum_h;
    pidNNtune_NCD_Xdot->IdentifiedPlantModel_CSTATE[0] +=
      (pidNNtune_NCD_P->IdentifiedPlantModel_A[0])*pidNNtune_NCD_X->IdentifiedPlantModel_CSTATE[0]
      +
      (pidNNtune_NCD_P->IdentifiedPlantModel_A[1])*pidNNtune_NCD_X->IdentifiedPlantModel_CSTATE[1]
      +
      (pidNNtune_NCD_P->IdentifiedPlantModel_A[2])*pidNNtune_NCD_X->IdentifiedPlantModel_CSTATE[2];

    pidNNtune_NCD_Xdot->IdentifiedPlantModel_CSTATE[1] =
      (pidNNtune_NCD_P->IdentifiedPlantModel_A[3])*pidNNtune_NCD_X->IdentifiedPlantModel_CSTATE[0];

    pidNNtune_NCD_Xdot->IdentifiedPlantModel_CSTATE[2] =
      (pidNNtune_NCD_P->IdentifiedPlantModel_A[4])*pidNNtune_NCD_X->IdentifiedPlantModel_CSTATE[1];
  }

  /* TransferFcn Block: <S3>/Band-limited Derivative */
  {

    pidNNtune_NCD_Xdot->BandlimitedDerivative_CSTATE =
      pidNNtune_NCD_P->BandlimitedDerivative_B*pidNNtune_NCD_B->Derivative;
    pidNNtune_NCD_Xdot->BandlimitedDerivative_CSTATE +=
      (pidNNtune_NCD_P->BandlimitedDerivative_A)*pidNNtune_NCD_X->BandlimitedDerivative_CSTATE;
  }

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

    pidNNtune_NCD_Xdot->Integrator_CSTATE = pidNNtune_NCD_B->Integral;
  }
}

/* ZeroCrossings for root system: '<Root>' */
#define MDL_ZERO_CROSSINGS
static void mdlZeroCrossings(SimStruct *S)
{
  /* simstruct variables */
  pidNNtune_NCD_BlockIO *pidNNtune_NCD_B = (pidNNtune_NCD_BlockIO *)
    _ssGetBlockIO(S);
  pidNNtune_NCD_Parameters *pidNNtune_NCD_P = (pidNNtune_NCD_Parameters *)
    ssGetDefaultParam(S);
  pidNNtune_NCD_NonsampledZCs *pidNNtune_NCD_NonsampledZC =
    (pidNNtune_NCD_NonsampledZCs *) ssGetNonsampledZCs(S);

  /* Step Block: <Root>/Step */
  pidNNtune_NCD_NonsampledZC->Step_NSZC = ssGetT(S) - pidNNtune_NCD_P->Step_Time;

  /* Step Block: <Root>/Step1 */
  pidNNtune_NCD_NonsampledZC->Step1_NSZC = ssGetT(S) -
    pidNNtune_NCD_P->Step1_Time;

  /* Abs Block: <Root>/Abs */
  pidNNtune_NCD_NonsampledZC->Abs_NSZC = pidNNtune_NCD_B->Sum;
}

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

  /* checksum */
  ssSetChecksumVal(S, 0, 2226731927U);
  ssSetChecksumVal(S, 1, 891949189U);
  ssSetChecksumVal(S, 2, 1696375423U);
  ssSetChecksumVal(S, 3, 2809399889U);

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

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

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