model20to03_converted.c

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

/*
 * model20to03_converted.c
 * 
 * Real-Time Workshop code generation for Simulink model "model20to03_converted.mdl".
 *
 * Model Version              : 1.7
 * Real-Time Workshop version : 6.0  (R14)  05-May-2004
 * C source code generated on : Thu Feb 24 17:59:23 2005
 */

#include "model20to03_converted.h"
#include "model20to03_converted_private.h"

/* Block signals (auto storage) */
BlockIO_model20to03_converted model20to03_converted_B;

/* Continuous states */
ContinuousStates_model20to03_converted model20to03_converted_X;

/* Solver Matrices */

/* A and B matrices used by ODE5 fixed-step solver */
static const real_T rt_ODE5_A[6] = {
  1.0/5.0, 3.0/10.0, 4.0/5.0, 8.0/9.0, 1.0, 1.0
};
static const real_T rt_ODE5_B[6][6] = {
  {1.0/5.0, 0.0, 0.0, 0.0, 0.0, 0.0},
  {3.0/40.0, 9.0/40.0, 0.0, 0.0, 0.0, 0.0},
  {44.0/45.0, -56.0/15.0, 32.0/9.0, 0.0, 0.0, 0.0},
  {19372.0/6561.0, -25360.0/2187.0, 64448.0/6561.0, -212.0/729.0, 0.0, 0.0},
  {9017.0/3168.0,-355.0/33.0,46732.0/5247.0,49.0/176.0,-5103.0/18656.0,0.0},
  {35.0/384.0, 0.0, 500.0/1113.0, 125.0/192.0, -2187.0/6784.0, 11.0/84.0}
};

/* Block states (auto storage) */
D_Work_model20to03_converted model20to03_converted_DWork;

/* External output (root outports fed by signals with auto storage) */
ExternalOutputs_model20to03_converted model20to03_converted_Y;

/* Real-time model */
rtModel_model20to03_converted model20to03_converted_M_;
rtModel_model20to03_converted *model20to03_converted_M =
  &model20to03_converted_M_;

/* This function implements a singletasking scheduler for a system with 2
 * rates.  This function is called by the generated step function, hence the
 * generated code self-manages all its subrates.
 */
static void rate_scheduler(void)
{

  /* Compute which subrates run during the next base time step.  Subrates
   * are an integer multiple of the base rate counter.  Therefore, the subtask
   * counter is reset when it reaches its limit (zero means run).
   */
}

/* This function updates continuous states using the ODE5 fixed-step
 * solver algorithm
 */
static void rt_ertODEUpdateContinuousStates(RTWSolverInfo *si , int_T tid)
{
  time_T t = rtsiGetT(si);
  time_T tnew = rtsiGetSolverStopTime(si);
  time_T h = rtsiGetStepSize(si);
  real_T *x = rtsiGetContStates(si);
  ODE5_IntgData *id = rtsiGetSolverData(si);
  real_T *y = id->y;
  real_T *f0 = id->f[0];
  real_T *f1 = id->f[1];
  real_T *f2 = id->f[2];
  real_T *f3 = id->f[3];
  real_T *f4 = id->f[4];
  real_T *f5 = id->f[5];
  real_T hB[6];
  int_T i;

  int_T nXc = 2;

  rtsiSetSimTimeStep(si,MINOR_TIME_STEP);

  /* Save the state values at time t in y, we'll use x as ynew. */
  (void)memcpy(y, x, nXc*sizeof(real_T));

  /* Assumes that rtsiSetT and ModelOutputs are up-to-date */
  /* f0 = f(t,y) */
  rtsiSetdX(si, f0);
  model20to03_converted_derivatives();

  /* f(:,2) = feval(odefile, t + hA(1), y + f*hB(:,1), args(:)(*)); */
  hB[0] = h * rt_ODE5_B[0][0];
  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (f0[i]*hB[0]);
  }
  rtsiSetT(si, t + h*rt_ODE5_A[0]);
  rtsiSetdX(si, f1);
  model20to03_converted_output(0);
  model20to03_converted_derivatives();

  /* f(:,3) = feval(odefile, t + hA(2), y + f*hB(:,2), args(:)(*)); */
  for (i = 0; i <= 1; i++) hB[i] = h * rt_ODE5_B[1][i];
  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (f0[i]*hB[0] + f1[i]*hB[1]);
  }
  rtsiSetT(si, t + h*rt_ODE5_A[1]);
  rtsiSetdX(si, f2);
  model20to03_converted_output(0);
  model20to03_converted_derivatives();

  /* f(:,4) = feval(odefile, t + hA(3), y + f*hB(:,3), args(:)(*)); */
  for (i = 0; i <= 2; i++) hB[i] = h * rt_ODE5_B[2][i];
  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (f0[i]*hB[0] + f1[i]*hB[1] + f2[i]*hB[2]);
  }
  rtsiSetT(si, t + h*rt_ODE5_A[2]);
  rtsiSetdX(si, f3);
  model20to03_converted_output(0);
  model20to03_converted_derivatives();

  /* f(:,5) = feval(odefile, t + hA(4), y + f*hB(:,4), args(:)(*)); */
  for (i = 0; i <= 3; i++) hB[i] = h * rt_ODE5_B[3][i];
  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (f0[i]*hB[0] + f1[i]*hB[1] + f2[i]*hB[2] +
      f3[i]*hB[3]);
  }
  rtsiSetT(si, t + h*rt_ODE5_A[3]);
  rtsiSetdX(si, f4);
  model20to03_converted_output(0);
  model20to03_converted_derivatives();

  /* f(:,6) = feval(odefile, t + hA(5), y + f*hB(:,5), args(:)(*)); */
  for (i = 0; i <= 4; i++) hB[i] = h * rt_ODE5_B[4][i];
  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (f0[i]*hB[0] + f1[i]*hB[1] + f2[i]*hB[2] +
      f3[i]*hB[3] + f4[i]*hB[4]);
  }
  rtsiSetT(si, tnew);
  rtsiSetdX(si, f5);
  model20to03_converted_output(0);
  model20to03_converted_derivatives();

  /* tnew = t + hA(6);
     ynew = y + f*hB(:,6); */
  for (i = 0; i <= 5; i++) hB[i] = h * rt_ODE5_B[5][i];
  for (i = 0; i < nXc; i++) {
    x[i] = y[i] + (f0[i]*hB[0] + f1[i]*hB[1] + f2[i]*hB[2] +
      f3[i]*hB[3] + f4[i]*hB[4] + f5[i]*hB[5]);
  }

  rtsiSetSimTimeStep(si,MAJOR_TIME_STEP);
}

/* Model output function */
void model20to03_converted_output(int_T tid)
{

  /* Update absolute time of base rate at minor time step */
  if (rtmIsMinorTimeStep(model20to03_converted_M)) {
    model20to03_converted_M->Timing.t[0] =
      rtsiGetT(&model20to03_converted_M->solverInfo);
  }

  if (rtmIsMajorTimeStep(model20to03_converted_M)) {
    /* set solver stop time */
    rtsiSetSolverStopTime(&model20to03_converted_M->solverInfo,
     ((model20to03_converted_M->Timing.clockTick0+1)*model20to03_converted_M->Timing.stepSize0));
  }                                     /* end MajorTimeStep */

  /* Integrator: '<Root>/x1' */
  model20to03_converted_B.x1 = model20to03_converted_X.x1_CSTATE;

  /* Outport: '<Root>/Out1' */
  model20to03_converted_Y.Out1 = model20to03_converted_B.x1;

  /* Integrator: '<Root>/x2' */
  model20to03_converted_B.x2 = model20to03_converted_X.x2_CSTATE;

  /* Outport: '<Root>/Out2' */
  model20to03_converted_Y.Out2 = model20to03_converted_B.x2;

  /* OutputUpdate for ModelReference block <Root>/vdpmult */
  mr_vdpmult(&model20to03_converted_B.x1, &model20to03_converted_B.x2,
   &model20to03_converted_B.vdpmult,
   &(model20to03_converted_DWork.vdpmult_DWORK1.rtm));

  /* Sum: '<Root>/Sum' */
  model20to03_converted_B.Sum = model20to03_converted_B.vdpmult -
    model20to03_converted_B.x1;
}

/* Model update function */
void model20to03_converted_update(int_T tid)
{

  if (rtmIsMajorTimeStep(model20to03_converted_M)) {
    rt_ertODEUpdateContinuousStates(&model20to03_converted_M->solverInfo, 0);
  }

  /* Update absolute time for base rate */

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

  if (rtmIsMajorTimeStep(model20to03_converted_M) &&
   model20to03_converted_M->Timing.TaskCounters.TID[1] == 0) {
    /* Update absolute timer for sample time: [0.4s, 0.0s] */

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

  rate_scheduler();
}

/* Derivatives for root system: '<Root>' */
void model20to03_converted_derivatives(void)
{
  /* simstruct variables */
  StateDerivatives_model20to03_converted *model20to03_converted_Xdot =
    (StateDerivatives_model20to03_converted*)
    model20to03_converted_M->ModelData.derivs;

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

    model20to03_converted_Xdot->x1_CSTATE = model20to03_converted_B.x2;
  }

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

    model20to03_converted_Xdot->x2_CSTATE = model20to03_converted_B.Sum;
  }
}

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

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

    {
      /* Setup solver object */

      rtsiSetSimTimeStepPtr(&model20to03_converted_M->solverInfo,
       &model20to03_converted_M->Timing.simTimeStep);
      rtsiSetTPtr(&model20to03_converted_M->solverInfo,
       &rtmGetTPtr(model20to03_converted_M));
      rtsiSetStepSizePtr(&model20to03_converted_M->solverInfo,
       &model20to03_converted_M->Timing.stepSize0);
      rtsiSetdXPtr(&model20to03_converted_M->solverInfo,
       &model20to03_converted_M->ModelData.derivs);
      rtsiSetContStatesPtr(&model20to03_converted_M->solverInfo,
       &model20to03_converted_M->ModelData.contStates);
      rtsiSetNumContStatesPtr(&model20to03_converted_M->solverInfo,
       &model20to03_converted_M->Sizes.numContStates);
      rtsiSetErrorStatusPtr(&model20to03_converted_M->solverInfo,
       &rtmGetErrorStatus(model20to03_converted_M));

      rtsiSetRTModelPtr(&model20to03_converted_M->solverInfo,
       model20to03_converted_M);
    }
    rtsiSetSimTimeStep(&model20to03_converted_M->solverInfo, MAJOR_TIME_STEP);
    model20to03_converted_M->ModelData.intgData.y =