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

/*
 * PID0413_acc.c
 * 
 * Real-Time Workshop code generation for Simulink model "PID0413_acc.mdl".
 *
 * Model Version              : 1.20
 * Real-Time Workshop version : 6.0  (R14)  05-May-2004
 * C source code generated on : Fri May 27 13:19:45 2005
 */

#include <math.h>
#include <string.h>
#include "PID0413_acc.h"
#include "PID0413_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 */
  PID0413_BlockIO *PID0413_B = (PID0413_BlockIO *) _ssGetBlockIO(S);
  PID0413_ContinuousStates *PID0413_X = (PID0413_ContinuousStates*)
    ssGetContStates(S);
  PID0413_D_Work *PID0413_DWork = (PID0413_D_Work *) ssGetRootDWork(S);
  PID0413_Parameters *PID0413_P = (PID0413_Parameters *) ssGetDefaultParam(S);

  /* local block i/o variables */

  real_T rtb_Clock;
  real_T rtb_Derivative;
  real_T rtb_Integral;

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

  /* TransferFcn Block: <Root>/Transfer Fcn */
  PID0413_B->TransferFcn =
    PID0413_P->TransferFcn_C*PID0413_X->TransferFcn_CSTATE[1];

  PID0413_B->Sum = PID0413_B->Step - PID0413_B->TransferFcn;

  /* Clock: '<Root>/Clock' */
  rtb_Clock = ssGetT(S);

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

    PID0413_B->Constant = PID0413_P->Constant_Value;
  }

  PID0413_B->Gain = (fabs(PID0413_B->Sum)) * (rtb_Clock + PID0413_B->Constant) *
    PID0413_P->Gain_Gain;

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

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

  PID0413_B->D = PID0413_B->Sum * PID0413_P->D_Gain;

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

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

  /* TransferFcn Block: <S1>/Integral */
  rtb_Integral = PID0413_P->Integral_C*PID0413_X->Integral_CSTATE;

  PID0413_B->Saturation = rt_SATURATE((PID0413_B->Sum *
    PID0413_P->Proportional_Gain + rtb_Integral) + rtb_Derivative,
   PID0413_P->Saturation_LowerSat, PID0413_P->Saturation_UpperSat);
}

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

  /* simstruct variables */
  PID0413_BlockIO *PID0413_B = (PID0413_BlockIO *) _ssGetBlockIO(S);
  PID0413_D_Work *PID0413_DWork = (PID0413_D_Work *) ssGetRootDWork(S);

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

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

/* Derivatives for root system: '<Root>' */
#define MDL_DERIVATIVES
static void mdlDerivatives(SimStruct *S)
{
  /* simstruct variables */
  PID0413_BlockIO *PID0413_B = (PID0413_BlockIO *) _ssGetBlockIO(S);
  PID0413_ContinuousStates *PID0413_X = (PID0413_ContinuousStates*)
    ssGetContStates(S);
  PID0413_StateDerivatives *PID0413_Xdot = (PID0413_StateDerivatives*)
    ssGetdX(S);
  PID0413_Parameters *PID0413_P = (PID0413_Parameters *) ssGetDefaultParam(S);

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

    PID0413_Xdot->TransferFcn_CSTATE[0] =
      PID0413_P->TransferFcn_B*PID0413_B->Saturation;
    PID0413_Xdot->TransferFcn_CSTATE[0] +=
      (PID0413_P->TransferFcn_A[0])*PID0413_X->TransferFcn_CSTATE[0]
      + (PID0413_P->TransferFcn_A[1])*PID0413_X->TransferFcn_CSTATE[1];

    PID0413_Xdot->TransferFcn_CSTATE[1] =
      (PID0413_P->TransferFcn_A[2])*PID0413_X->TransferFcn_CSTATE[0];
  }

  /* TransferFcn Block: <S1>/Integral */
  {

    PID0413_Xdot->Integral_CSTATE = PID0413_P->Integral_B*PID0413_B->Sum;
  }
}

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

  /* checksum */
  ssSetChecksumVal(S, 0, 4185810485U);
  ssSetChecksumVal(S, 1, 1133182330U);
  ssSetChecksumVal(S, 2, 1466143537U);
  ssSetChecksumVal(S, 3, 1280940384U);

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

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

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