model20to03_converted.c

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

      model20to03_converted_M->ModelData.odeY;
    model20to03_converted_M->ModelData.intgData.f[0] =
      model20to03_converted_M->ModelData.odeF[0];
    model20to03_converted_M->ModelData.intgData.f[1] =
      model20to03_converted_M->ModelData.odeF[1];
    model20to03_converted_M->ModelData.intgData.f[2] =
      model20to03_converted_M->ModelData.odeF[2];
    model20to03_converted_M->ModelData.intgData.f[3] =
      model20to03_converted_M->ModelData.odeF[3];
    model20to03_converted_M->ModelData.intgData.f[4] =
      model20to03_converted_M->ModelData.odeF[4];
    model20to03_converted_M->ModelData.intgData.f[5] =
      model20to03_converted_M->ModelData.odeF[5];
    model20to03_converted_M->ModelData.contStates = ((real_T *)
      &model20to03_converted_X);
    rtsiSetSolverData(&model20to03_converted_M->solverInfo, (void
      *)&model20to03_converted_M->ModelData.intgData);
    rtsiSetSolverName(&model20to03_converted_M->solverInfo,"ode5");

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

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

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

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

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

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

    rtmSetTFinal(model20to03_converted_M, 20.0);
    model20to03_converted_M->Timing.stepSize0 = 0.4;
    model20to03_converted_M->Timing.stepSize1 = 0.4;

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

      model20to03_converted_M->rtwLogInfo = &rt_DataLoggingInfo;

      rtliSetLogFormat(model20to03_converted_M->rtwLogInfo, 0);

      rtliSetLogMaxRows(model20to03_converted_M->rtwLogInfo, 0);

      rtliSetLogDecimation(model20to03_converted_M->rtwLogInfo, 1);

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

      rtliSetLogT(model20to03_converted_M->rtwLogInfo, "tout");

      rtliSetLogX(model20to03_converted_M->rtwLogInfo, "");

      rtliSetLogXFinal(model20to03_converted_M->rtwLogInfo, "");

      rtliSetLogXSignalInfo(model20to03_converted_M->rtwLogInfo, NULL);

      rtliSetLogXSignalPtrs(model20to03_converted_M->rtwLogInfo, NULL);

      rtliSetLogY(model20to03_converted_M->rtwLogInfo, "yout");

      /*
       * Set pointers to the data and signal info for each output
       */
      {
        static void * rt_LoggedOutputSignalPtrs[] = {
          &model20to03_converted_Y.Out1,
          &model20to03_converted_Y.Out2
        };

        rtliSetLogYSignalPtrs(model20to03_converted_M->rtwLogInfo,
         ((LogSignalPtrsType)rt_LoggedOutputSignalPtrs));
      }
      {

        static int_T rt_LoggedOutputWidths[] = {
          1,
          1
        };

        static int_T rt_LoggedOutputNumDimensions[] = {
          1,
          1
        };

        static int_T rt_LoggedOutputDimensions[] = {
          1,
          1
        };

        static BuiltInDTypeId rt_LoggedOutputDataTypeIds[] = {
          SS_DOUBLE,
          SS_DOUBLE
        };

        static int_T rt_LoggedOutputComplexSignals[] = {
          0,
          0
        };

        static const char_T *rt_LoggedOutputLabels[] = {
          "x1",
          "x2"};

        static const char_T *rt_LoggedOutputBlockNames[] = {
          "model20to03_converted/Out1",
          "model20to03_converted/Out2"};

        static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
          { 0, SS_DOUBLE, SS_DOUBLE, 1.0, 0, 0.0},
          { 0, SS_DOUBLE, SS_DOUBLE, 1.0, 0, 0.0}
        };

        static RTWLogSignalInfo rt_LoggedOutputSignalInfo[] = {
          {
            2,
            rt_LoggedOutputWidths,
            rt_LoggedOutputNumDimensions,
            rt_LoggedOutputDimensions,
            rt_LoggedOutputDataTypeIds,
            rt_LoggedOutputComplexSignals,
            NULL,
            rt_LoggedOutputLabels,
            NULL,
            NULL,
            NULL,
            rt_LoggedOutputBlockNames,
            NULL,
            rt_RTWLogDataTypeConvert
          }
        };

        rtliSetLogYSignalInfo(model20to03_converted_M->rtwLogInfo,
         rt_LoggedOutputSignalInfo);
      }
    }

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

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

      {

        int_T i;
        b =&model20to03_converted_B.x1;
        for (i = 0; i < 4; i++) {
          ((real_T*)b)[i] = 0.0;
        }
      }
    }
    /* states */
    {
      int_T i;
      real_T *x = (real_T *) &model20to03_converted_X;
      model20to03_converted_M->ModelData.contStates = (x);
      for(i = 0; i <
       (int_T)(sizeof(ContinuousStates_model20to03_converted)/sizeof(real_T));
       i++)
      {
        x[i] = 0.0;
      }
    }

    /* data type work */
    model20to03_converted_M->Work.dwork = ((void *)
      &model20to03_converted_DWork);
    (void)memset((char_T *) &model20to03_converted_DWork, 0,
     sizeof(D_Work_model20to03_converted));

    /* external outputs */
    model20to03_converted_M->ModelData.outputs = (&model20to03_converted_Y);
    model20to03_converted_Y.Out1 = 0.0;
    model20to03_converted_Y.Out2 = 0.0;

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

    /* Model Initialize fcn for ModelReference block <Root>/vdpmult */
    mr_vdpmult_initialize(1, rtmGetErrorStatusPointer(model20to03_converted_M),
     &(model20to03_converted_M->solverInfo), 0,
     &(model20to03_converted_DWork.vdpmult_DWORK1.rtm));
  }
}

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

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

void MdlOutputs(int_T tid) {

  model20to03_converted_output(tid);
}

void MdlUpdate(int_T tid) {

  model20to03_converted_update(tid);
}

void MdlInitializeSizes(void) {
  model20to03_converted_M->Sizes.numContStates = (2); /* Number of continuous states */
  model20to03_converted_M->Sizes.numY = (2); /* Number of model outputs */
  model20to03_converted_M->Sizes.numU = (0); /* Number of model inputs */
  model20to03_converted_M->Sizes.sysDirFeedThru = (0); /* The model is not direct feedthrough */
  model20to03_converted_M->Sizes.numSampTimes = (2); /* Number of sample times */
  model20to03_converted_M->Sizes.numBlocks = (7); /* Number of blocks */
  model20to03_converted_M->Sizes.numBlockIO = (4); /* Number of block outputs */
}

void MdlInitializeSampleTimes(void) {
}

void MdlStart(void) {

  /* Integrator Block: <Root>/x1 */
  (void)memcpy(&model20to03_converted_B.x1, &model20to03_converted_ConstP.x1_IC,
   1 * sizeof(real_T));

  /* Integrator Block: <Root>/x2 */
  (void)memcpy(&model20to03_converted_B.x2, &model20to03_converted_ConstP.x2_IC,
   1 * sizeof(real_T));

  /* Integrator Block: <Root>/x1 */
  model20to03_converted_X.x1_CSTATE = 2.0;

  /* Integrator Block: <Root>/x2 */
  model20to03_converted_X.x2_CSTATE = 0.0;
}

rtModel_model20to03_converted *model20to03_converted(void) {
  model20to03_converted_initialize(1);
  return model20to03_converted_M;
}

void MdlTerminate(void) {
  model20to03_converted_terminate();
}

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