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

/*
 * ex33_pid_acc.c
 * 
 * Real-Time Workshop code generation for Simulink model "ex33_pid_acc.mdl".
 *
 * Model Version              : 1.41
 * Real-Time Workshop version : 6.1  (R14SP1)  05-Sep-2004
 * C source code generated on : Fri May 27 06:36:45 2005
 */

#include <math.h>
#include <string.h>
#include "ex33_pid_acc.h"
#include "ex33_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 */
  ex33_pid_BlockIO *ex33_pid_B = (ex33_pid_BlockIO *) _ssGetBlockIO(S);
  ex33_pid_ContinuousStates *ex33_pid_X = (ex33_pid_ContinuousStates*)
    ssGetContStates(S);
  ex33_pid_D_Work *ex33_pid_DWork = (ex33_pid_D_Work *) ssGetRootDWork(S);
  ex33_pid_Parameters *ex33_pid_P = (ex33_pid_Parameters *) ssGetDefaultParam(S);

  /* local block i/o variables */

  real_T rtb_Derivative;
  real_T rtb_Derivative1;
  real_T rtb_Derivative2;
  real_T rtb_Derivative3;
  real_T rtb_Integrator;
  real_T rtb_Integrator3;
  real_T rtb_Integrator1;
  real_T rtb_Integrator2;

  /* tid is required for a uniform function interface. This system
   * is single rate, and in this case, tid is not accessed. */
  UNUSED_PARAMETER(tid);

  /* Step: '<Root>/Step' */
  if (ssIsMajorTimeStep(S)) {
    real_T currentTime = ssGetT(S);
    if (currentTime >= ex33_pid_P->Step_Time) {
      ex33_pid_DWork->Step_MODE = 1;
    } else {
      ex33_pid_DWork->Step_MODE = 0;
    }
  }
  /* Output value */
  ex33_pid_B->Step = (ex33_pid_DWork->Step_MODE == 1) ? ex33_pid_P->Step_YFinal
    : ex33_pid_P->Step_Y0;

  /* TransferFcn Block: <Root>/Transfer Fcn1 */
  ex33_pid_B->TransferFcn1 =
    ex33_pid_P->TransferFcn1_C*ex33_pid_X->TransferFcn1_CSTATE[1];

  /* TransferFcn Block: <Root>/Transfer Fcn2 */
  ex33_pid_B->TransferFcn2 =
    ex33_pid_P->TransferFcn2_C*ex33_pid_X->TransferFcn2_CSTATE[1];

  /* TransferFcn Block: <Root>/Transfer Fcn3 */
  ex33_pid_B->TransferFcn3 =
    ex33_pid_P->TransferFcn3_C*ex33_pid_X->TransferFcn3_CSTATE[1];

  /* TransferFcn Block: <Root>/Transfer Fcn4 */
  ex33_pid_B->TransferFcn4 =
    ex33_pid_P->TransferFcn4_C*ex33_pid_X->TransferFcn4_CSTATE[1];

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

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

  ex33_pid_B->Sum = ex33_pid_B->Step - ex33_pid_B->TransferFcn1;

  /* Derivative Block: <Root>/Derivative */
  {
    real_T t = ssGetT(S);
    real_T timeStampA = ex33_pid_DWork->Derivative_RWORK.TimeStampA;
    real_T timeStampB = ex33_pid_DWork->Derivative_RWORK.TimeStampB;

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

  ex33_pid_B->Sum2 = ex33_pid_B->Step - ex33_pid_B->TransferFcn2;

  /* Derivative Block: <Root>/Derivative1 */
  {
    real_T t = ssGetT(S);
    real_T timeStampA = ex33_pid_DWork->Derivative1_RWORK.TimeStampA;
    real_T timeStampB = ex33_pid_DWork->Derivative1_RWORK.TimeStampB;

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

  ex33_pid_B->Sum4 = ex33_pid_B->Step - ex33_pid_B->TransferFcn3;

  /* Derivative Block: <Root>/Derivative2 */
  {
    real_T t = ssGetT(S);
    real_T timeStampA = ex33_pid_DWork->Derivative2_RWORK.TimeStampA;
    real_T timeStampB = ex33_pid_DWork->Derivative2_RWORK.TimeStampB;

    if (timeStampA >= t && timeStampB >= t) {
      rtb_Derivative2 = 0.0;
    } else {
      real_T deltaT;
      real_T *lastBank = &ex33_pid_DWork->Derivative2_RWORK.TimeStampA;
      if (timeStampA < timeStampB) {
        if (timeStampB < t) {
          lastBank += 2;
        }
      } else if (timeStampA >= t) {
        lastBank += 2;
      }
      deltaT = t - *lastBank++;
      rtb_Derivative2 = (ex33_pid_B->Sum4 - *lastBank++) / deltaT;
    }
  }

  ex33_pid_B->Sum6 = ex33_pid_B->Step - ex33_pid_B->TransferFcn4;

  /* Derivative Block: <Root>/Derivative3 */
  {
    real_T t = ssGetT(S);
    real_T timeStampA = ex33_pid_DWork->Derivative3_RWORK.TimeStampA;
    real_T timeStampB = ex33_pid_DWork->Derivative3_RWORK.TimeStampB;

    if (timeStampA >= t && timeStampB >= t) {
      rtb_Derivative3 = 0.0;
    } else {
      real_T deltaT;
      real_T *lastBank = &ex33_pid_DWork->Derivative3_RWORK.TimeStampA;
      if (timeStampA < timeStampB) {
        if (timeStampB < t) {
          lastBank += 2;
        }
      } else if (timeStampA >= t) {
        lastBank += 2;
      }
      deltaT = t - *lastBank++;
      rtb_Derivative3 = (ex33_pid_B->Sum6 - *lastBank++) / deltaT;
    }
  }

  /* Integrator: '<Root>/Integrator' */
  rtb_Integrator = ex33_pid_X->Integrator_CSTATE;

  /* Integrator: '<Root>/Integrator3' */
  rtb_Integrator3 = ex33_pid_X->Integrator3_CSTATE;

  ex33_pid_B->Gain11 = ((ex33_pid_B->Sum6 + rtb_Integrator3 *
    ex33_pid_P->Gain9_Gain) + (rtb_Derivative3 * ex33_pid_P->Gain10_Gain)) *
    ex33_pid_P->Gain11_Gain;

  ex33_pid_B->Gain2 = ((ex33_pid_B->Sum + (rtb_Integrator *
    ex33_pid_P->Gain_Gain)) + (rtb_Derivative * ex33_pid_P->Gain1_Gain)) *
    ex33_pid_P->Gain2_Gain;

  /* Integrator: '<Root>/Integrator1' */
  rtb_Integrator1 = ex33_pid_X->Integrator1_CSTATE;

  ex33_pid_B->Gain5 = ((ex33_pid_B->Sum2 + rtb_Integrator1 *
    ex33_pid_P->Gain3_Gain) + rtb_Derivative1 * ex33_pid_P->Gain4_Gain) *
    ex33_pid_P->Gain5_Gain;

  /* Integrator: '<Root>/Integrator2' */
  rtb_Integrator2 = ex33_pid_X->Integrator2_CSTATE;

  ex33_pid_B->Gain8 = ((ex33_pid_B->Sum4 + rtb_Integrator2 *
    ex33_pid_P->Gain6_Gain) + rtb_Derivative2 * ex33_pid_P->Gain7_Gain) *
    ex33_pid_P->Gain8_Gain;

  /* TransportDelay Block: <Root>/Transport Delay */
  {

    real_T **uBuffer =
      (real_T**)&ex33_pid_DWork->TransportDelay_PWORK.TUbufferPtrs[0];
    real_T **tBuffer =
      (real_T**)&ex33_pid_DWork->TransportDelay_PWORK.TUbufferPtrs[1];
    real_T simTime = ssGetT(S);
    real_T tMinusDelay = simTime - ex33_pid_P->TransportDelay_Delay;

    ex33_pid_B->TransportDelay = rt_TDelayInterpolate(
      tMinusDelay,
     *tBuffer,
     *uBuffer,
     ex33_pid_DWork->TransportDelay_IWORK.CircularBufSize,
     &ex33_pid_DWork->TransportDelay_IWORK.Last,
     ex33_pid_DWork->TransportDelay_IWORK.Tail,
     ex33_pid_DWork->TransportDelay_IWORK.Head,
     0,
     (boolean_T) (ssIsMinorTimeStep(S) && (ssGetTimeOfLastOutput(S) ==
       ssGetT(S))));
  }
}

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

  /* simstruct variables */
  ex33_pid_BlockIO *ex33_pid_B = (ex33_pid_BlockIO *) _ssGetBlockIO(S);
  ex33_pid_D_Work *ex33_pid_DWork = (ex33_pid_D_Work *) ssGetRootDWork(S);