f14.c

matlab实用教程

  rtb_Proportionalplusintegralcom = f14_P.Proportionalplusintegral_C*
    f14_X.Proportionalplusintegralcompens;

  /* Sum: '<S2>/Sum' */
  f14_B.Sum = rtb_Gain_f + rtb_Proportionalplusintegralcom;
  if (rtmIsMajorTimeStep(f14_M) &&
      f14_M->Timing.TaskCounters.TID[2] == 0) {/* Sample time: [0.1s, 0.0s] */
    /* RandomNumber: '<S5>/White Noise' */
    rtb_WhiteNoise = f14_DWork.WhiteNoise_RWORK.NextOutput;

    /* Gain: '<S5>/Output' */
    f14_B.Output = f14_P.Output_Gain * rtb_WhiteNoise;
  }

  UNUSED_PARAMETER(tid);
}

/* Model update function */
void f14_update(int_T tid)
{
  /* Derivative Block: '<S4>/Derivative' */
  {
    real_T timeStampA = f14_DWork.Derivative_RWORK.TimeStampA;
    real_T timeStampB = f14_DWork.Derivative_RWORK.TimeStampB;
    real_T *lastBank = &f14_DWork.Derivative_RWORK.TimeStampA;
    if (timeStampA != rtInf) {
      if (timeStampB == rtInf) {
        lastBank += 2;
      } else if (timeStampA >= timeStampB) {
        lastBank += 2;
      }
    }

    *lastBank++ = f14_M->Timing.t[0];
    *lastBank++ = f14_B.TransferFcn2;
  }

  /* Derivative Block: '<S4>/Derivative1' */
  {
    real_T timeStampA = f14_DWork.Derivative1_RWORK.TimeStampA;
    real_T timeStampB = f14_DWork.Derivative1_RWORK.TimeStampB;
    real_T *lastBank = &f14_DWork.Derivative1_RWORK.TimeStampA;
    if (timeStampA != rtInf) {
      if (timeStampB == rtInf) {
        lastBank += 2;
      } else if (timeStampA >= timeStampB) {
        lastBank += 2;
      }
    }

    *lastBank++ = f14_M->Timing.t[0];
    *lastBank++ = f14_B.TransferFcn1;
  }

  if (rtmIsMajorTimeStep(f14_M) &&
      f14_M->Timing.TaskCounters.TID[2] == 0) {/* Sample time: [0.1s, 0.0s] */
    /* RandomNumber Block: '<S5>/White Noise' */
    f14_DWork.WhiteNoise_RWORK.NextOutput = rt_NormalRand((uint32_T *)
      &f14_DWork.WhiteNoise_IWORK.RandSeed)*f14_P.WhiteNoise_StdDev+
      f14_P.WhiteNoise_Mean;
  }

  if (rtmIsMajorTimeStep(f14_M)) {
    rt_ertODEUpdateContinuousStates(&f14_M->solverInfo);
  }

  /* Update absolute time for base rate */
  if (!(++f14_M->Timing.clockTick0))
    ++f14_M->Timing.clockTickH0;
  f14_M->Timing.t[0] = f14_M->Timing.clockTick0 * f14_M->Timing.stepSize0 +
    f14_M->Timing.clockTickH0 * f14_M->Timing.stepSize0 * 4294967296.0;
  if (rtmIsMajorTimeStep(f14_M) &&
      f14_M->Timing.TaskCounters.TID[1] == 0) {
    /* Update absolute timer for sample time: [0.05s, 0.0s] */
    if (!(++f14_M->Timing.clockTick1))
      ++f14_M->Timing.clockTickH1;
    f14_M->Timing.t[1] = f14_M->Timing.clockTick1 * f14_M->Timing.stepSize1 +
      f14_M->Timing.clockTickH1 * f14_M->Timing.stepSize1 * 4294967296.0;
  }

  if (rtmIsMajorTimeStep(f14_M) &&
      f14_M->Timing.TaskCounters.TID[2] == 0) {
    /* Update absolute timer for sample time: [0.1s, 0.0s] */
    if (!(++f14_M->Timing.clockTick2))
      ++f14_M->Timing.clockTickH2;
    f14_M->Timing.t[2] = f14_M->Timing.clockTick2 * f14_M->Timing.stepSize2 +
      f14_M->Timing.clockTickH2 * f14_M->Timing.stepSize2 * 4294967296.0;
  }

  rate_scheduler();
  UNUSED_PARAMETER(tid);
}

/* Derivatives for root system: '<Root>' */
void f14_derivatives(void)
{
  /* TransferFcn Block: '<S1>/Transfer Fcn.2' */
  {
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->TransferFcn2_CSTATE =
      f14_B.Sum1_b;
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->TransferFcn2_CSTATE +=
      (f14_P.TransferFcn2_A)*f14_X.TransferFcn2_CSTATE;
  }

  /* TransferFcn Block: '<S1>/Transfer Fcn.1' */
  {
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->TransferFcn1_CSTATE =
      f14_B.Sum2;
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->TransferFcn1_CSTATE +=
      (f14_P.TransferFcn1_A)*f14_X.TransferFcn1_CSTATE;
  }

  /* TransferFcn Block: '<Root>/Actuator Model' */
  {
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->ActuatorModel_CSTATE =
      f14_B.Sum;
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->ActuatorModel_CSTATE +=
      (f14_P.ActuatorModel_A)*f14_X.ActuatorModel_CSTATE;
  }

  /* TransferFcn Block: '<S3>/W-gust model' */
  {
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->Wgustmodel_CSTATE[0] =
      f14_B.Output;
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->Wgustmodel_CSTATE[0] +=
      (f14_P.Wgustmodel_A[0])*f14_X.Wgustmodel_CSTATE[0] + (f14_P.Wgustmodel_A[1])*
      f14_X.Wgustmodel_CSTATE[1];
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->Wgustmodel_CSTATE[1]=
      f14_X.Wgustmodel_CSTATE[0];
  }

  /* TransferFcn Block: '<S3>/Q-gust model' */
  {
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->Qgustmodel_CSTATE =
      f14_B.Wgustmodel;
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->Qgustmodel_CSTATE +=
      (f14_P.Qgustmodel_A)*f14_X.Qgustmodel_CSTATE;
  }

  /* TransferFcn Block: '<S2>/Alpha-sensor Low-pass Filter' */
  {
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)
      ->AlphasensorLowpassFilter_CSTATE = f14_B.Gain5;
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)
      ->AlphasensorLowpassFilter_CSTATE += (f14_P.AlphasensorLowpassFilt_A)*
      f14_X.AlphasensorLowpassFilter_CSTATE;
  }

  /* TransferFcn Block: '<S2>/Stick Prefilter' */
  {
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->StickPrefilter_CSTATE =
      f14_B.Sum1;
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)->StickPrefilter_CSTATE +=
      (f14_P.StickPrefilter_A)*f14_X.StickPrefilter_CSTATE;
  }

  /* TransferFcn Block: '<S2>/Pitch Rate Lead Filter' */
  {
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)
      ->PitchRateLeadFilter_CSTATE = f14_B.TransferFcn1;
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)
      ->PitchRateLeadFilter_CSTATE += (f14_P.PitchRateLeadFilter_A)*
      f14_X.PitchRateLeadFilter_CSTATE;
  }

  /* TransferFcn Block: '<S2>/Proportional plus integral compensator' */
  {
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)
      ->Proportionalplusintegralcompens = f14_B.Sum2_f;
    ((StateDerivatives_f14 *) f14_M->ModelData.derivs)
      ->Proportionalplusintegralcompens += (f14_P.Proportionalplusintegral_A)*
      f14_X.Proportionalplusintegralcompens;
  }
}

/* Model initialize function */
void f14_initialize(boolean_T firstTime)
{
  (void)firstTime;

  /* Registration code */
  /* initialize real-time model */
  (void) memset((char_T *)f14_M,0,
                sizeof(RT_MODEL_f14));

  {
    /* Setup solver object */
    rtsiSetSimTimeStepPtr(&f14_M->solverInfo, &f14_M->Timing.simTimeStep);
    rtsiSetTPtr(&f14_M->solverInfo, &rtmGetTPtr(f14_M));
    rtsiSetStepSizePtr(&f14_M->solverInfo, &f14_M->Timing.stepSize0);
    rtsiSetdXPtr(&f14_M->solverInfo, &f14_M->ModelData.derivs);
    rtsiSetContStatesPtr(&f14_M->solverInfo, &f14_M->ModelData.contStates);
    rtsiSetNumContStatesPtr(&f14_M->solverInfo, &f14_M->Sizes.numContStates);
    rtsiSetErrorStatusPtr(&f14_M->solverInfo, (&rtmGetErrorStatus(f14_M)));
    rtsiSetRTModelPtr(&f14_M->solverInfo, f14_M);
  }

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

  /* Initialize timing info */
  {
    int_T *mdlTsMap = f14_M->Timing.sampleTimeTaskIDArray;
    mdlTsMap[0] = 0;
    mdlTsMap[1] = 1;
    mdlTsMap[2] = 2;
    f14_M->Timing.sampleTimeTaskIDPtr = (&mdlTsMap[0]);
    f14_M->Timing.sampleTimes = (&f14_M->Timing.sampleTimesArray[0]);
    f14_M->Timing.offsetTimes = (&f14_M->Timing.offsetTimesArray[0]);

    /* task periods */
    f14_M->Timing.sampleTimes[0] = (0.0);
    f14_M->Timing.sampleTimes[1] = (0.05);
    f14_M->Timing.sampleTimes[2] = (0.1);

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

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

  {
    int_T *mdlSampleHits = f14_M->Timing.sampleHitArray;
    mdlSampleHits[0] = 1;
    mdlSampleHits[1] = 1;
    mdlSampleHits[2] = 1;
    f14_M->Timing.sampleHits = (&mdlSampleHits[0]);
  }

  rtmSetTFinal(f14_M, 60.0);
  f14_M->Timing.stepSize0 = 0.05;
  f14_M->Timing.stepSize1 = 0.05;
  f14_M->Timing.stepSize2 = 0.1;

  /* Setup for data logging */
  {
    static RTWLogInfo rt_DataLoggingInfo;
    f14_M->rtwLogInfo = &rt_DataLoggingInfo;
    rtliSetLogFormat(f14_M->rtwLogInfo, 0);
    rtliSetLogMaxRows(f14_M->rtwLogInfo, 0);
    rtliSetLogDecimation(f14_M->rtwLogInfo, 1);
    rtliSetLogVarNameModifier(f14_M->rtwLogInfo, "rt_");
    rtliSetLogT(f14_M->rtwLogInfo, "tout");
    rtliSetLogX(f14_M->rtwLogInfo, "xout");
    rtliSetLogXFinal(f14_M->rtwLogInfo, "");
    rtliSetSigLog(f14_M->rtwLogInfo, "");

    /*
     * Set pointers to the data and signal info each state
     */
    {
      static int_T rt_LoggedStateWidths[] = {
        1,
        1,
        1,
        2,
        1,
        1,
        1,
        1,
        1
      };

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

      static int_T rt_LoggedStateDimensions[] = {
        1,
        1,
        1,
        2,
        1,
        1,
        1,
        1,
        1
      };

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

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

      static const char_T *rt_LoggedStateLabels[] = {
        "CSTATE",
        "CSTATE",
        "CSTATE",
        "CSTATE",
        "CSTATE",
        "CSTATE",
        "CSTATE",
        "CSTATE",
        "CSTATE" };

      static const char_T *rt_LoggedStateBlockNames[] = {
        "f14/Aircraft\nDynamics\nModel/Transfer Fcn.2",
        "f14/Aircraft\nDynamics\nModel/Transfer Fcn.1",
        "f14/Actuator\nModel",
        "f14/Dryden Wind\nGust Models/W-gust model",
        "f14/Dryden Wind\nGust Models/Q-gust model",
        "f14/Controller/Alpha-sensor\nLow-pass Filter",
        "f14/Controller/Stick\nPrefilter",
        "f14/Controller/Pitch Rate\nLead Filter",
        "f14/Controller/Proportional\nplus integral\ncompensator" };

      static const char_T *rt_LoggedStateNames[] = {
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "",
        "" };

      static boolean_T rt_LoggedStateCrossMdlRef[] = {
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0
      };

      static RTWLogDataTypeConvert rt_RTWLogDataTypeConvert[] = {
        { 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 },