model20to01.c

《MATLAB7.0_Simulink6.0建模仿真开发与高级工程应用》书中程序

/*
 * model20to01.c
 * 
 * Real-Time Workshop code generation for Simulink model "model20to01.mdl".
 *
 * Model Version              : 1.6
 * Real-Time Workshop version : 6.0  (R14)  05-May-2004
 * C source code generated on : Thu Feb 24 16:06:37 2005
 */

#include "model20to01.h"
#include "model20to01_private.h"

/* Block signals (auto storage) */
BlockIO_model20to01 model20to01_B;

/* Block states (auto storage) */
D_Work_model20to01 model20to01_DWork;

/* Real-time model */
rtModel_model20to01 model20to01_M_;
rtModel_model20to01 *model20to01_M = &model20to01_M_;

/* Model output function */
static void model20to01_output(int_T tid)
{

  /* local block i/o variables */

  real_T rtb_sin_out;

  /* Sin Block: '<Root>/Sine Wave' */

  rtb_sin_out = model20to01_P.SineWave_Amp *
    sin(model20to01_P.SineWave_Freq * model20to01_M->Timing.t[0] +
    model20to01_P.SineWave_Phase) + model20to01_P.SineWave_Bias;

  /* Gain: '<Root>/Gain' */
  model20to01_B.gain_out = rtb_sin_out * model20to01_P.Gain_Gain;
}

/* Model update function */
static void model20to01_update(int_T tid)
{

  /* Update absolute time for base rate */

  if(!(++model20to01_M->Timing.clockTick0)) ++model20to01_M->Timing.clockTickH0;
  model20to01_M->Timing.t[0] = model20to01_M->Timing.clockTick0 *
    model20to01_M->Timing.stepSize0 + model20to01_M->Timing.clockTickH0 *
    model20to01_M->Timing.stepSize0 * 4294967296.0;

  {
    /* Update absolute timer for sample time: [0.2s, 0.0s] */

    if(!(++model20to01_M->Timing.clockTick1))
    ++model20to01_M->Timing.clockTickH1;
    model20to01_M->Timing.t[1] = model20to01_M->Timing.clockTick1 *
      model20to01_M->Timing.stepSize1 + model20to01_M->Timing.clockTickH1 *
      model20to01_M->Timing.stepSize1 * 4294967296.0;
  }
}

/* Model initialize function */
void model20to01_initialize(boolean_T firstTime)
{

  if (firstTime) {
    /* registration code */
    /* initialize real-time model */
    (void)memset((char_T *)model20to01_M, 0, sizeof(rtModel_model20to01));

    {
      /* Setup solver object */

      rtsiSetSimTimeStepPtr(&model20to01_M->solverInfo,
       &model20to01_M->Timing.simTimeStep);
      rtsiSetTPtr(&model20to01_M->solverInfo, &rtmGetTPtr(model20to01_M));
      rtsiSetStepSizePtr(&model20to01_M->solverInfo,
       &model20to01_M->Timing.stepSize0);
      rtsiSetErrorStatusPtr(&model20to01_M->solverInfo,
       &rtmGetErrorStatus(model20to01_M));

      rtsiSetRTModelPtr(&model20to01_M->solverInfo, model20to01_M);
    }
    rtsiSetSimTimeStep(&model20to01_M->solverInfo, MAJOR_TIME_STEP);

    /* Initialize timing info */
    {
      int_T *mdlTsMap = model20to01_M->Timing.sampleTimeTaskIDArray;
      int_T i;

      for(i = 0; i < 2; i++) {
        mdlTsMap[i] = i;
      }
      model20to01_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
      model20to01_M->Timing.sampleTimes =
        (&model20to01_M->Timing.sampleTimesArray[0]);
      model20to01_M->Timing.offsetTimes =
        (&model20to01_M->Timing.offsetTimesArray[0]);
      /* task periods */
      model20to01_M->Timing.sampleTimes[0] = (0.0);
      model20to01_M->Timing.sampleTimes[1] = (0.2);

      /* task offsets */
      model20to01_M->Timing.offsetTimes[0] = (0.0);
      model20to01_M->Timing.offsetTimes[1] = (0.0);
    }

    rtmSetTPtr(model20to01_M, &model20to01_M->Timing.tArray[0]);

    {
      int_T *mdlSampleHits = model20to01_M->Timing.sampleHitArray;
      int_T i;

      for(i = 0; i < 2; i++) {
        mdlSampleHits[i] = 1;
      }
      model20to01_M->Timing.sampleHits = (&mdlSampleHits[0]);
    }

    rtmSetTFinal(model20to01_M, 10.0);
    model20to01_M->Timing.stepSize0 = 0.2;
    model20to01_M->Timing.stepSize1 = 0.2;

    /* Setup for data logging */
    {
      static RTWLogInfo rt_DataLoggingInfo;

      model20to01_M->rtwLogInfo = &rt_DataLoggingInfo;

      rtliSetLogFormat(model20to01_M->rtwLogInfo, 0);

      rtliSetLogMaxRows(model20to01_M->rtwLogInfo, 0);

      rtliSetLogDecimation(model20to01_M->rtwLogInfo, 1);

      rtliSetLogVarNameModifier(model20to01_M->rtwLogInfo, "rt_");

      rtliSetLogT(model20to01_M->rtwLogInfo, "");

      rtliSetLogX(model20to01_M->rtwLogInfo, "");

      rtliSetLogXFinal(model20to01_M->rtwLogInfo, "");

      rtliSetLogXSignalInfo(model20to01_M->rtwLogInfo, NULL);

      rtliSetLogXSignalPtrs(model20to01_M->rtwLogInfo, NULL);

      rtliSetLogY(model20to01_M->rtwLogInfo, "");

      rtliSetLogYSignalInfo(model20to01_M->rtwLogInfo, NULL);

      rtliSetLogYSignalPtrs(model20to01_M->rtwLogInfo, NULL);
    }

    model20to01_M->solverInfoPtr = (&model20to01_M->solverInfo);
    model20to01_M->Timing.stepSize = (0.2);
    rtsiSetFixedStepSize(&model20to01_M->solverInfo, 0.2);
    rtsiSetSolverMode(&model20to01_M->solverInfo, SOLVER_MODE_SINGLETASKING);

    {
      /* block I/O */
      void *b = (void *) &model20to01_B;
      model20to01_M->ModelData.blockIO = (b);

      {

        int_T i;
        b =&model20to01_B.gain_out;
        for (i = 0; i < 1; i++) {
          ((real_T*)b)[i] = 0.0;
        }
      }
    }
    /* parameters */
    model20to01_M->ModelData.defaultParam = ((real_T *) &model20to01_P);

    /* data type work */
    model20to01_M->Work.dwork = ((void *) &model20to01_DWork);
    (void)memset((char_T *) &model20to01_DWork, 0, sizeof(D_Work_model20to01));

    /* initialize non-finites */
    rt_InitInfAndNaN(sizeof(real_T));
  }
}

/* Model terminate function */
void model20to01_terminate(void)
{
}

/*========================================================================*
 * Start of GRT compatible call interface                                 *
 *========================================================================*/

void MdlOutputs(int_T tid) {

  model20to01_output(tid);
}

void MdlUpdate(int_T tid) {

  model20to01_update(tid);
}

void MdlInitializeSizes(void) {
  model20to01_M->Sizes.numContStates = (0); /* Number of continuous states */
  model20to01_M->Sizes.numY = (0);      /* Number of model outputs */
  model20to01_M->Sizes.numU = (0);      /* Number of model inputs */
  model20to01_M->Sizes.sysDirFeedThru = (0); /* The model is not direct feedthrough */
  model20to01_M->Sizes.numSampTimes = (2); /* Number of sample times */
  model20to01_M->Sizes.numBlocks = (3); /* Number of blocks */
  model20to01_M->Sizes.numBlockIO = (1); /* Number of block outputs */
  model20to01_M->Sizes.numBlockPrms = (5); /* Sum of parameter "widths" */
}

void MdlInitializeSampleTimes(void) {
}

void MdlStart(void) {
}

rtModel_model20to01 *model20to01(void) {
  model20to01_initialize(1);
  return model20to01_M;
}

void MdlTerminate(void) {
  model20to01_terminate();
}

/*========================================================================*
 * End of GRT compatible call interface                                   *
 *========================================================================*/