курсовая работа / sintez_avtomaticheskoy_sistemy_stabilizacii_temperatury_na_1 / JIeo_TAYK / A_accel_rtw / A_acc

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

/*
 * A_acc.c
 * 
 * Real-Time Workshop code generation for Simulink model "A_acc.mdl".
 *
 * Model Version              : 1.21
 * Real-Time Workshop version : 6.1  (R14SP1)  05-Sep-2004
 * C source code generated on : Sun May 17 18:21:44 2009
 */

#include <math.h>
#include <string.h>
#include "A_acc.h"
#include "A_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 */
  A_BlockIO *A_B = (A_BlockIO *) _ssGetBlockIO(S);
  A_ContinuousStates *A_X = (A_ContinuousStates*) ssGetContStates(S);
  A_D_Work *A_DWork = (A_D_Work *) ssGetRootDWork(S);
  A_Parameters *A_P = (A_Parameters *) ssGetDefaultParam(S);

  /* local block i/o variables */

  real_T rtb_Zadanie;
  real_T rtb_Switch;
  real_T rtb_Sum;
  real_T rtb_Gain;
  real_T rtb_Integrator;
  real_T rtb_Saturation;
  real_T rtb_Sum5;
  real_T rtb_Vozmuchenie;
  real_T rtb_Switch_c;
  boolean_T rtb_EnvironmentSwitch;
  boolean_T rtb_EnvironmentSwitch_n;

  real_T rtb_ZeroOrderHold;
  real_T rtb_Sum6;

  /* Step: '<Root>/Zadanie' */
  if (ssIsMajorTimeStep(S)) {
    real_T currentTime = ssGetTaskTime(S,tid);
    if (currentTime >= A_P->Zadanie_Time) {
      A_DWork->Zadanie_MODE = 1;
    } else {
      A_DWork->Zadanie_MODE = 0;
    }
  }
  /* Output value */
 rtb_Zadanie = (A_DWork->Zadanie_MODE == 1) ? A_P->Zadanie_YFinal :
    A_P->Zadanie_Y0;

  /* S-Function Block (sfun_manswitch): <S1>/SimValue */
  A_B->SimValue = A_P->SimValue_P1;

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

    A_B->SwitchControl = A_P->SwitchControl_Value;

    A_B->RTWValue = A_P->RTWValue_Value;
  }

  if(A_B->SwitchControl) {
    rtb_EnvironmentSwitch = A_B->SimValue;
  } else {
    rtb_EnvironmentSwitch = A_B->RTWValue;
  }

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

    A_B->Constant4 = A_P->Constant4_Value;
  }

  if(rtb_EnvironmentSwitch) {
    rtb_Switch = rtb_Zadanie;
  } else {
    rtb_Switch = A_B->Constant4;
  }

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

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

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

  rtb_Sum = rtb_Switch - A_B->TransportDelay;

  rtb_Gain = rtb_Sum * A_P->Gain_Gain;

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

  A_B->Sum1 = rtb_Gain + rtb_Integrator;

  /* Saturate: '<Root>/Saturation'
   *
   * Regarding '<Root>/Saturation':
   *   Lower limit: A_P->Saturation_LowerSat
   *   Upper limit: A_P->Saturation_UpperSat
   */
  if (ssIsMajorTimeStep(S)) {
    if (A_B->Sum1 >= A_P->Saturation_UpperSat) {
      A_DWork->Saturation_MODE = 1;
    } else if (A_B->Sum1 <= A_P->Saturation_LowerSat) {
      A_DWork->Saturation_MODE = -1;
    } else {
      A_DWork->Saturation_MODE = 0;
    }
  }
  /* Output value */
  if (A_DWork->Saturation_MODE == 1) {
    rtb_Saturation = A_P->Saturation_UpperSat;
  } else if (A_DWork->Saturation_MODE == -1) {
    rtb_Saturation = A_P->Saturation_LowerSat;
  } else {
    rtb_Saturation = A_B->Sum1;
  }

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

    real_T **uBuffer = (real_T**)&A_DWork->TransportDelay2_PWORK.TUbufferPtrs[0];
    real_T **tBuffer = (real_T**)&A_DWork->TransportDelay2_PWORK.TUbufferPtrs[1];
    real_T simTime = ssGetT(S);
    real_T tMinusDelay = simTime - A_P->TransportDelay2_Delay;

    A_B->TransportDelay2 = rt_TDelayInterpolate(
      tMinusDelay,
     *tBuffer,
     *uBuffer,
     A_DWork->TransportDelay2_IWORK.CircularBufSize,
     &A_DWork->TransportDelay2_IWORK.Last,
     A_DWork->TransportDelay2_IWORK.Tail,
     A_DWork->TransportDelay2_IWORK.Head,
     0,
     (boolean_T) (ssIsMinorTimeStep(S) && (ssGetTimeOfLastOutput(S) ==
       ssGetT(S))));
  }

  rtb_Sum5 = rtb_Switch - A_B->TransportDelay2;

  A_B->Gain4 = rtb_Sum5 * A_P->Gain4_Gain;

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

    /* ZeroOrderHold: '<Root>/Zero-Order Hold' */
    rtb_ZeroOrderHold = A_B->Gain4;
  }

  A_B->Gain5 = rtb_Sum5 * A_P->Gain5_Gain;

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

    if(A_DWork->DiscreteTimeIntegrator_SYSTEM) {
      A_B->DiscreteTimeIntegrator = A_DWork->DiscreteTimeIntegrator_DSTATE;
      A_DWork->DiscreteTimeIntegrator_SYSTEM = 0;
    } else {
      A_B->DiscreteTimeIntegrator = A_DWork->DiscreteTimeIntegrator_DSTATE +
        A_P->DiscreteTimeIntegrator_ga * A_B->Gain5;
    }

    rtb_Sum6 = rtb_ZeroOrderHold + A_B->DiscreteTimeIntegrator;

    A_B->Saturation1 = rt_SATURATE(rtb_Sum6, A_P->Saturation1_LowerSat,
     A_P->Saturation1_UpperSat);
  }
  if (ssIsSampleHit(S, 1, tid)) {       /* Sample time: [0.0s, 1.0s] */

    A_B->Constant1 = A_P->Constant1_Value;
  }

  A_B->Sum7[0] = rtb_Saturation + A_B->Constant1;
  A_B->Sum7[1] = A_B->Saturation1 + A_B->Constant1;

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

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

    A_B->Constant = A_P->Constant_Value;
  }

  A_B->Sum4[0] = A_B->TransportDelay + A_B->Constant;
  A_B->Sum4[1] = A_B->TransportDelay2 + A_B->Constant;

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

  A_B->Gain1 = rtb_Sum * A_P->Gain1_Gain;

  /* S-Function Block (sfun_manswitch): <S2>/SimValue */
  A_B->SimValue_f = A_P->SimValue_P1_a;

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

    A_B->SwitchControl_b = A_P->SwitchControl_Value_c;

    A_B->RTWValue_p = A_P->RTWValue_Value_a;
  }

  if(A_B->SwitchControl_b) {
    rtb_EnvironmentSwitch_n = A_B->SimValue_f;
  } else {
    rtb_EnvironmentSwitch_n = A_B->RTWValue_p;
  }

  /* Step: '<Root>/Vozmuchenie' */
  if (ssIsMajorTimeStep(S)) {
    real_T currentTime = ssGetTaskTime(S,tid);
    if (currentTime >= A_P->Vozmuchenie_Time) {
      A_DWork->Vozmuchenie_MODE = 1;
    } else {
      A_DWork->Vozmuchenie_MODE = 0;
    }
  }
  /* Output value */
 rtb_Vozmuchenie = (A_DWork->Vozmuchenie_MODE == 1) ? A_P->Vozmuchenie_YFinal :
    A_P->Vozmuchenie_Y0;

  if(rtb_EnvironmentSwitch_n) {
    rtb_Switch_c = A_B->Constant4;
  } else {
    rtb_Switch_c = rtb_Vozmuchenie;
  }

  A_B->Sum2 = rtb_Saturation + rtb_Switch_c;

  A_B->Sum3 = rtb_Switch_c + A_B->Saturation1;

  /* TransferFcn Block: <Root>/Transfer Fcn */
  A_B->TransferFcn = A_P->TransferFcn_C*A_X->TransferFcn_CSTATE[1];

  /* TransferFcn Block: <Root>/Transfer Fcn1 */
  A_B->TransferFcn1 = A_P->TransferFcn1_C*A_X->TransferFcn1_CSTATE[1];
}

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

  /* simstruct variables */
  A_BlockIO *A_B = (A_BlockIO *) _ssGetBlockIO(S);
  A_D_Work *A_DWork = (A_D_Work *) ssGetRootDWork(S);
  A_Parameters *A_P = (A_Parameters *) ssGetDefaultParam(S);

  /* TransportDelay Block: <Root>/Transport Delay */
  {
    real_T **uBuffer = (real_T**)&A_DWork->TransportDelay_PWORK.TUbufferPtrs[0];
    real_T **tBuffer = (real_T**)&A_DWork->TransportDelay_PWORK.TUbufferPtrs[1];
    real_T simTime = ssGetT(S);

    A_DWork->TransportDelay_IWORK.Head = ((A_DWork->TransportDelay_IWORK.Head <
      (A_DWork->TransportDelay_IWORK.CircularBufSize-1)) ?
      (A_DWork->TransportDelay_IWORK.Head+1) : 0);

    if (A_DWork->TransportDelay_IWORK.Head ==
     A_DWork->TransportDelay_IWORK.Tail) {
      if (!rt_TDelayUpdateTailOrGrowBuf(
        &A_DWork->TransportDelay_IWORK.CircularBufSize,
        &A_DWork->TransportDelay_IWORK.Tail,
        &A_DWork->TransportDelay_IWORK.Head,
        &A_DWork->TransportDelay_IWORK.Last, simTime -
        A_P->TransportDelay_Delay, tBuffer, uBuffer,
        &A_DWork->TransportDelay_IWORK.MaxNewBufSize)) {
        ssSetErrorStatus(S, "tdelay memory allocation error");
      }
    }

    (*tBuffer)[A_DWork->TransportDelay_IWORK.Head] = simTime;
    (*uBuffer)[A_DWork->TransportDelay_IWORK.Head] = A_B->TransferFcn;
  }

  /* TransportDelay Block: <Root>/Transport Delay2 */
  {
    real_T **uBuffer = (real_T**)&A_DWork->TransportDelay2_PWORK.TUbufferPtrs[0];
    real_T **tBuffer = (real_T**)&A_DWork->TransportDelay2_PWORK.TUbufferPtrs[1];
    real_T simTime = ssGetT(S);

    A_DWork->TransportDelay2_IWORK.Head = ((A_DWork->TransportDelay2_IWORK.Head
      < (A_DWork->TransportDelay2_IWORK.CircularBufSize-1)) ?
      (A_DWork->TransportDelay2_IWORK.Head+1) : 0);

    if (A_DWork->TransportDelay2_IWORK.Head ==
     A_DWork->TransportDelay2_IWORK.Tail) {
      if (!rt_TDelayUpdateTailOrGrowBuf(
        &A_DWork->TransportDelay2_IWORK.CircularBufSize,
        &A_DWork->TransportDelay2_IWORK.Tail,
        &A_DWork->TransportDelay2_IWORK.Head,
        &A_DWork->TransportDelay2_IWORK.Last, simTime -
        A_P->TransportDelay2_Delay, tBuffer, uBuffer,
        &A_DWork->TransportDelay2_IWORK.MaxNewBufSize)) {
        ssSetErrorStatus(S, "tdelay memory allocation error");
      }
    }

    (*tBuffer)[A_DWork->TransportDelay2_IWORK.Head] = simTime;
    (*uBuffer)[A_DWork->TransportDelay2_IWORK.Head] = A_B->TransferFcn1;
  }

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

    A_DWork->DiscreteTimeIntegrator_DSTATE = A_B->DiscreteTimeIntegrator;
  }
}

/* Derivatives for root system: '<Root>' */
#define MDL_DERIVATIVES
static void mdlDerivatives(SimStruct *S)
{
  /* simstruct variables */
  A_BlockIO *A_B = (A_BlockIO *) _ssGetBlockIO(S);
  A_ContinuousStates *A_X = (A_ContinuousStates*) ssGetContStates(S);
  A_StateDerivatives *A_Xdot = (A_StateDerivatives*) ssGetdX(S);
  A_Parameters *A_P = (A_Parameters *) ssGetDefaultParam(S);

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

    A_Xdot->Integrator_CSTATE = A_B->Gain1;
  }

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

    A_Xdot->TransferFcn_CSTATE[0] = A_P->TransferFcn_B*A_B->Sum2;
    A_Xdot->TransferFcn_CSTATE[0] +=
      (A_P->TransferFcn_A[0])*A_X->TransferFcn_CSTATE[0] +
      (A_P->TransferFcn_A[1])*A_X->TransferFcn_CSTATE[1];

    A_Xdot->TransferFcn_CSTATE[1] =
      (A_P->TransferFcn_A[2])*A_X->TransferFcn_CSTATE[0];
  }

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

    A_Xdot->TransferFcn1_CSTATE[0] = A_P->TransferFcn1_B*A_B->Sum3;
    A_Xdot->TransferFcn1_CSTATE[0] +=
      (A_P->TransferFcn1_A[0])*A_X->TransferFcn1_CSTATE[0] +
      (A_P->TransferFcn1_A[1])*A_X->TransferFcn1_CSTATE[1];

    A_Xdot->TransferFcn1_CSTATE[1] =
      (A_P->TransferFcn1_A[2])*A_X->TransferFcn1_CSTATE[0];
  }
}

/* ZeroCrossings for root system: '<Root>' */
#define MDL_ZERO_CROSSINGS
static void mdlZeroCrossings(SimStruct *S)
{
  /* simstruct variables */
  A_BlockIO *A_B = (A_BlockIO *) _ssGetBlockIO(S);
  A_Parameters *A_P = (A_Parameters *) ssGetDefaultParam(S);
  A_NonsampledZCs *A_NonsampledZC = (A_NonsampledZCs *) ssGetNonsampledZCs(S);

  /* Step Block: <Root>/Zadanie */
  A_NonsampledZC->Zadanie_NSZC = ssGetT(S) - A_P->Zadanie_Time;

  /* Saturate Block: '<Root>/Saturation' */
  /* Do zero crossings for the upper limit */
  A_NonsampledZC->Saturation_NSZC[0] = A_B->Sum1 -
    A_P->Saturation_UpperSat;
  /* Do zero crossings for the lower limit */
  A_NonsampledZC->Saturation_NSZC[1] = A_B->Sum1 -
    A_P->Saturation_LowerSat;

  /* Step Block: <Root>/Vozmuchenie */
  A_NonsampledZC->Vozmuchenie_NSZC = ssGetT(S) - A_P->Vozmuchenie_Time;
}

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

  /* checksum */
  ssSetChecksumVal(S, 0, 2234350440U);
  ssSetChecksumVal(S, 1, 257403404U);
  ssSetChecksumVal(S, 2, 2134139886U);
  ssSetChecksumVal(S, 3, 2449255879U);

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

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

  /* model parameters */
  _ssSetDefaultParam(S, (real_T *) &A_DefaultParameters);
}

/* 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"