f14.c

matlab实用教程

        { 0, SS_DOUBLE, SS_DOUBLE, 1.0, 0, 0.0 },

        { 0, SS_DOUBLE, SS_DOUBLE, 1.0, 0, 0.0 },

        { 0, SS_DOUBLE, SS_DOUBLE, 1.0, 0, 0.0 },

        { 0, SS_DOUBLE, SS_DOUBLE, 1.0, 0, 0.0 },

        { 0, SS_DOUBLE, SS_DOUBLE, 1.0, 0, 0.0 }
      };

      static RTWLogSignalInfo rt_LoggedStateSignalInfo = {
        9,
        rt_LoggedStateWidths,
        rt_LoggedStateNumDimensions,
        rt_LoggedStateDimensions,
        rt_LoggedStateDataTypeIds,
        rt_LoggedStateComplexSignals,
        NULL,

        { rt_LoggedStateLabels },
        NULL,
        NULL,
        NULL,

        { rt_LoggedStateBlockNames },

        { rt_LoggedStateNames },
        rt_LoggedStateCrossMdlRef,
        rt_RTWLogDataTypeConvert
      };

      rtliSetLogXSignalInfo(f14_M->rtwLogInfo, &rt_LoggedStateSignalInfo);
    }

    {
      static void * rt_LoggedStateSignalPtrs[9];
      rt_LoggedStateSignalPtrs[0] = (void*)&f14_X.TransferFcn2_CSTATE;
      rt_LoggedStateSignalPtrs[1] = (void*)&f14_X.TransferFcn1_CSTATE;
      rt_LoggedStateSignalPtrs[2] = (void*)&f14_X.ActuatorModel_CSTATE;
      rt_LoggedStateSignalPtrs[3] = (void*)&f14_X.Wgustmodel_CSTATE[0];
      rt_LoggedStateSignalPtrs[4] = (void*)&f14_X.Qgustmodel_CSTATE;
      rt_LoggedStateSignalPtrs[5] = (void*)
        &f14_X.AlphasensorLowpassFilter_CSTATE;
      rt_LoggedStateSignalPtrs[6] = (void*)&f14_X.StickPrefilter_CSTATE;
      rt_LoggedStateSignalPtrs[7] = (void*)&f14_X.PitchRateLeadFilter_CSTATE;
      rt_LoggedStateSignalPtrs[8] = (void*)
        &f14_X.Proportionalplusintegralcompens;
      rtliSetLogXSignalPtrs(f14_M->rtwLogInfo, (LogSignalPtrsType)
                            rt_LoggedStateSignalPtrs);
    }

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

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

      rtliSetLogYSignalPtrs(f14_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[] = {
        "",
        "" };

      static const char_T *rt_LoggedOutputBlockNames[] = {
        "f14/alpha (rad)",
        "f14/Nz Pilot (g)" };

      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 },
          NULL,
          rt_RTWLogDataTypeConvert
        }
      };

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

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

  /* block I/O */
  f14_M->ModelData.blockIO = ((void *) &f14_B);

  {
    int_T i;
    void *pVoidBlockIORegion;
    pVoidBlockIORegion = (void *)(&f14_B.TransferFcn2);
    for (i = 0; i < 11; i++) {
      ((real_T*)pVoidBlockIORegion)[i] = 0.0;
    }
  }

  /* parameters */
  f14_M->ModelData.defaultParam = ((real_T *) &f14_P);

  /* states (continuous) */
  {
    real_T *x = (real_T *) &f14_X;
    f14_M->ModelData.contStates = (x);
    (void) memset((char_T *)x,0,
                  sizeof(ContinuousStates_f14));
  }

  /* states (dwork) */
  f14_M->Work.dwork = ((void *) &f14_DWork);
  (void) memset((char_T *) &f14_DWork,0,
                sizeof(D_Work_f14));

  {
    int_T i;
    real_T *dwork_ptr = (real_T *) &f14_DWork.Derivative_RWORK.TimeStampA;
    for (i = 0; i < 9; i++) {
      dwork_ptr[i] = 0.0;
    }
  }

  /* external inputs */
  f14_M->ModelData.inputs = (((void*) &f14_U));
  f14_U.u = 0.0;

  /* external outputs */
  f14_M->ModelData.outputs = (&f14_Y);
  f14_Y.alpharad = 0.0;
  f14_Y.NzPilotg = 0.0;

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

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

/*========================================================================*
 * Start of GRT compatible call interface                                 *
 *========================================================================*/
void MdlOutputs(int_T tid)
{
  f14_output(tid);
}

void MdlUpdate(int_T tid)
{
  f14_update(tid);
}

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

void MdlInitializeSampleTimes(void)
{
}

void MdlInitialize(void)
{
  /* TransferFcn Block: '<S1>/Transfer Fcn.2' */
  f14_X.TransferFcn2_CSTATE = 0.0;

  /* Derivative Block: '<S4>/Derivative' */
  f14_DWork.Derivative_RWORK.TimeStampA = rtInf;
  f14_DWork.Derivative_RWORK.TimeStampB = rtInf;

  /* TransferFcn Block: '<S1>/Transfer Fcn.1' */
  f14_X.TransferFcn1_CSTATE = 0.0;

  /* Derivative Block: '<S4>/Derivative1' */
  f14_DWork.Derivative1_RWORK.TimeStampA = rtInf;
  f14_DWork.Derivative1_RWORK.TimeStampB = rtInf;

  /* TransferFcn Block: '<Root>/Actuator Model' */
  f14_X.ActuatorModel_CSTATE = 0.0;

  /* TransferFcn Block: '<S3>/W-gust model' */
  f14_X.Wgustmodel_CSTATE[0] = 0.0;
  f14_X.Wgustmodel_CSTATE[1] = 0.0;

  /* TransferFcn Block: '<S3>/Q-gust model' */
  f14_X.Qgustmodel_CSTATE = 0.0;

  /* TransferFcn Block: '<S2>/Alpha-sensor Low-pass Filter' */
  f14_X.AlphasensorLowpassFilter_CSTATE = 0.0;

  /* TransferFcn Block: '<S2>/Stick Prefilter' */
  f14_X.StickPrefilter_CSTATE = 0.0;

  /* TransferFcn Block: '<S2>/Pitch Rate Lead Filter' */
  f14_X.PitchRateLeadFilter_CSTATE = 0.0;

  /* TransferFcn Block: '<S2>/Proportional plus integral compensator' */
  f14_X.Proportionalplusintegralcompens = 0.0;
}

void MdlStart(void)
{
  /* Scope Block: '<Root>/Angle of  Attack' */
  {
    int_T numCols = 2;
    f14_DWork.AngleofAttack_PWORK.LoggedData = rt_CreateLogVar(
      f14_M->rtwLogInfo,
      rtmGetTFinal(f14_M),
      f14_M->Timing.stepSize0,
      (&rtmGetErrorStatus(f14_M)),
      "Angl_of_Attack",
      SS_DOUBLE,
      0,
      0,
      0,
      2,
      1,
      (int_T *)&numCols,
      5000,
      1,
      0.05,
      1);
    if (f14_DWork.AngleofAttack_PWORK.LoggedData == NULL)
      return;
  }

  /* Scope Block: '<Root>/Pilot G force Scope' */
  {
    int_T numCols = 2;
    f14_DWork.PilotGforceScope_PWORK.LoggedData = rt_CreateLogVar(
      f14_M->rtwLogInfo,
      rtmGetTFinal(f14_M),
      f14_M->Timing.stepSize0,
      (&rtmGetErrorStatus(f14_M)),
      "Pilot_G_force_Scope",
      SS_DOUBLE,
      0,
      0,
      0,
      2,
      1,
      (int_T *)&numCols,
      5000,
      1,
      0.05,
      1);
    if (f14_DWork.PilotGforceScope_PWORK.LoggedData == NULL)
      return;
  }

  /* Scope Block: '<Root>/Stick Input' */
  {
    int_T numCols = 2;
    f14_DWork.StickInput_PWORK.LoggedData = rt_CreateLogVar(
      f14_M->rtwLogInfo,
      rtmGetTFinal(f14_M),
      f14_M->Timing.stepSize0,
      (&rtmGetErrorStatus(f14_M)),
      "Stick_Input",
      SS_DOUBLE,
      0,
      0,
      0,
      2,
      1,
      (int_T *)&numCols,
      5000,
      1,
      0.05,
      1);
    if (f14_DWork.StickInput_PWORK.LoggedData == NULL)
      return;
  }

  /* RandomNumber Block: '<S5>/White Noise' */
  {
    uint32_T *RandSeed = (uint32_T *) &f14_DWork.WhiteNoise_IWORK.RandSeed;
    uint32_T r, t;
    *RandSeed = (uint32_T)f14_P.WhiteNoise_Seed;
    r = *RandSeed >> 16;
    t = *RandSeed & RT_BIT16;
    *RandSeed = ((*RandSeed - (r << 16) - t) << 16) + t + r;
    if (*RandSeed < 1) {
      *RandSeed = SEED0;
    }

    if (*RandSeed > MAXSEED) {
      *RandSeed = MAXSEED;
    }

    f14_DWork.WhiteNoise_RWORK.NextOutput =
      rt_NormalRand(RandSeed++) * f14_P.WhiteNoise_StdDev +
      f14_P.WhiteNoise_Mean;
  }

  MdlInitialize();
}

RT_MODEL_f14 *f14(void)
{
  f14_initialize(1);
  return f14_M;
}

void MdlTerminate(void)
{
  f14_terminate();
}

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