f14.h

matlab实用教程

    real_T LastUAtTimeA;
    real_T TimeStampB;
    real_T LastUAtTimeB;
  } Derivative1_RWORK;                 /* '<S4>/Derivative1' */

  struct {
    real_T NextOutput;
  } WhiteNoise_RWORK;                  /* '<S5>/White Noise' */

  struct {
    void *LoggedData;
  } AngleofAttack_PWORK;               /* '<Root>/Angle of  Attack' */

  struct {
    void *LoggedData;
  } PilotGforceScope_PWORK;            /* '<Root>/Pilot G force Scope' */

  struct {
    void *LoggedData;
  } StickInput_PWORK;                  /* '<Root>/Stick Input' */

  struct {
    int_T RandSeed;
  } WhiteNoise_IWORK;                  /* '<S5>/White Noise' */
} D_Work_f14;

/* Continuous states (auto storage) */
typedef struct {
  real_T TransferFcn2_CSTATE;          /* '<S1>/Transfer Fcn.2' */
  real_T TransferFcn1_CSTATE;          /* '<S1>/Transfer Fcn.1' */
  real_T ActuatorModel_CSTATE;         /* '<Root>/Actuator Model' */
  real_T Wgustmodel_CSTATE[2];         /* '<S3>/W-gust model' */
  real_T Qgustmodel_CSTATE;            /* '<S3>/Q-gust model' */
  real_T AlphasensorLowpassFilter_CSTATE;/* '<S2>/Alpha-sensor Low-pass Filter' */
  real_T StickPrefilter_CSTATE;        /* '<S2>/Stick Prefilter' */
  real_T PitchRateLeadFilter_CSTATE;   /* '<S2>/Pitch Rate Lead Filter' */
  real_T Proportionalplusintegralcompens;/* '<S2>/Proportional plus integral compensator' */
} ContinuousStates_f14;

/* State derivatives (auto storage) */
typedef struct {
  real_T TransferFcn2_CSTATE;          /* '<S1>/Transfer Fcn.2' */
  real_T TransferFcn1_CSTATE;          /* '<S1>/Transfer Fcn.1' */
  real_T ActuatorModel_CSTATE;         /* '<Root>/Actuator Model' */
  real_T Wgustmodel_CSTATE[2];         /* '<S3>/W-gust model' */
  real_T Qgustmodel_CSTATE;            /* '<S3>/Q-gust model' */
  real_T AlphasensorLowpassFilter_CSTATE;/* '<S2>/Alpha-sensor Low-pass Filter' */
  real_T StickPrefilter_CSTATE;        /* '<S2>/Stick Prefilter' */
  real_T PitchRateLeadFilter_CSTATE;   /* '<S2>/Pitch Rate Lead Filter' */
  real_T Proportionalplusintegralcompens;/* '<S2>/Proportional plus integral compensator' */
} StateDerivatives_f14;

/* State disabled  */
typedef struct {
  boolean_T TransferFcn2_CSTATE;       /* '<S1>/Transfer Fcn.2' */
  boolean_T TransferFcn1_CSTATE;       /* '<S1>/Transfer Fcn.1' */
  boolean_T ActuatorModel_CSTATE;      /* '<Root>/Actuator Model' */
  boolean_T Wgustmodel_CSTATE[2];      /* '<S3>/W-gust model' */
  boolean_T Qgustmodel_CSTATE;         /* '<S3>/Q-gust model' */
  boolean_T AlphasensorLowpassFilter_CSTATE;/* '<S2>/Alpha-sensor Low-pass Filter' */
  boolean_T StickPrefilter_CSTATE;     /* '<S2>/Stick Prefilter' */
  boolean_T PitchRateLeadFilter_CSTATE;/* '<S2>/Pitch Rate Lead Filter' */
  boolean_T Proportionalplusintegralcompens;/* '<S2>/Proportional plus integral compensator' */
} StateDisabled_f14;

#ifndef ODE5_INTG
#define ODE5_INTG

/* ODE5 Integration Data */
typedef struct {
  real_T *y;                           /* output */
  real_T *f[6];                        /* derivatives */
} ODE5_IntgData;

#endif

/* External inputs (root inport signals with auto storage) */
typedef struct {
  real_T u;                            /* '<Root>/u' */
} ExternalInputs_f14;

/* External outputs (root outports fed by signals with auto storage) */
typedef struct {
  real_T alpharad;                     /* '<Root>/alpha (rad)' */
  real_T NzPilotg;                     /* '<Root>/Nz Pilot (g)' */
} ExternalOutputs_f14;

/* Backward compatible GRT Identifiers */
#define rtB                            f14_B
#define BlockIO                        BlockIO_f14
#define rtU                            f14_U
#define ExternalInputs                 ExternalInputs_f14
#define rtX                            f14_X
#define ContinuousStates               ContinuousStates_f14
#define rtY                            f14_Y
#define ExternalOutputs                ExternalOutputs_f14
#define rtP                            f14_P
#define Parameters                     Parameters_f14
#define rtDWork                        f14_DWork
#define D_Work                         D_Work_f14

/* Parameters (auto storage) */
struct Parameters_f14 {
  real_T TransferFcn2_A;               /* Computed Parameter: A
                                        * '<S1>/Transfer Fcn.2'
                                        */
  real_T TransferFcn2_C;               /* Computed Parameter: C
                                        * '<S1>/Transfer Fcn.2'
                                        */
  real_T Gain5_Gain;                   /* Expression: 1/Uo
                                        * '<Root>/Gain5'
                                        */
  real_T TransferFcn1_A;               /* Computed Parameter: A
                                        * '<S1>/Transfer Fcn.1'
                                        */
  real_T TransferFcn1_C;               /* Computed Parameter: C
                                        * '<S1>/Transfer Fcn.1'
                                        */
  real_T Gain1_Gain;                   /* Expression: 22.8
                                        * '<S4>/Gain1'
                                        */
  real_T Constant_Value;               /* Expression: Uo
                                        * '<S4>/Constant'
                                        */
  real_T Gain2_Gain;                   /* Expression: 1/g
                                        * '<S4>/Gain2'
                                        */
  real_T Pilot_Amplitude;              /* Expression: 1
                                        * '<Root>/Pilot'
                                        */
  real_T Pilot_Frequency;              /* Computed Parameter: Frequency
                                        * '<Root>/Pilot'
                                        */
  real_T ActuatorModel_A;              /* Computed Parameter: A
                                        * '<Root>/Actuator Model'
                                        */
  real_T ActuatorModel_C;              /* Computed Parameter: C
                                        * '<Root>/Actuator Model'
                                        */
  real_T Gain3_Gain;                   /* Expression: Uo
                                        * '<S1>/Gain3'
                                        */
  real_T Gain4_Gain;                   /* Expression: Mw
                                        * '<S1>/Gain4'
                                        */
  real_T Gain5_Gain_k;                 /* Expression: Zd
                                        * '<S1>/Gain5'
                                        */
  real_T Gain6_Gain;                   /* Expression: Md
                                        * '<S1>/Gain6'
                                        */
  real_T Wgustmodel_A[2];              /* Computed Parameter: A
                                        * '<S3>/W-gust model'
                                        */
  real_T Wgustmodel_C[2];              /* Computed Parameter: C
                                        * '<S3>/W-gust model'
                                        */
  real_T Gain_Gain;                    /* Expression: Zw
                                        * '<Root>/Gain'
                                        */
  real_T Gain2_Gain_c;                 /* Expression: Mw
                                        * '<Root>/Gain2'
                                        */
  real_T Qgustmodel_A;                 /* Computed Parameter: A
                                        * '<S3>/Q-gust model'
                                        */
  real_T Qgustmodel_C;                 /* Computed Parameter: C
                                        * '<S3>/Q-gust model'
                                        */
  real_T Qgustmodel_D;                 /* Computed Parameter: D
                                        * '<S3>/Q-gust model'
                                        */
  real_T Gain1_Gain_e;                 /* Expression: Mq
                                        * '<Root>/Gain1'
                                        */
  real_T AlphasensorLowpassFilt_A;     /* Computed Parameter: A
                                        * '<S2>/Alpha-sensor Low-pass Filter'
                                        */
  real_T AlphasensorLowpassFilt_C;     /* Computed Parameter: C
                                        * '<S2>/Alpha-sensor Low-pass Filter'
                                        */
  real_T StickPrefilter_A;             /* Computed Parameter: A
                                        * '<S2>/Stick Prefilter'
                                        */
  real_T StickPrefilter_C;             /* Computed Parameter: C
                                        * '<S2>/Stick Prefilter'
                                        */
  real_T PitchRateLeadFilter_A;        /* Computed Parameter: A
                                        * '<S2>/Pitch Rate Lead Filter'
                                        */
  real_T PitchRateLeadFilter_C;        /* Computed Parameter: C
                                        * '<S2>/Pitch Rate Lead Filter'
                                        */
  real_T PitchRateLeadFilter_D;        /* Computed Parameter: D
                                        * '<S2>/Pitch Rate Lead Filter'
                                        */
  real_T Gain2_Gain_n;                 /* Expression: Kq
                                        * '<S2>/Gain2'
                                        */
  real_T Gain3_Gain_k;                 /* Expression: Ka
                                        * '<S2>/Gain3'
                                        */
  real_T Gain_Gain_a;                  /* Expression: Kf
                                        * '<S2>/Gain'
                                        */
  real_T Proportionalplusintegral_A;   /* Computed Parameter: A
                                        * '<S2>/Proportional plus integral compensator'
                                        */
  real_T Proportionalplusintegral_C;   /* Computed Parameter: C
                                        * '<S2>/Proportional plus integral compensator'
                                        */
  real_T WhiteNoise_Mean;              /* Expression: 0
                                        * '<S5>/White Noise'
                                        */
  real_T WhiteNoise_StdDev;            /* Computed Parameter: StdDev
                                        * '<S5>/White Noise'
                                        */
  real_T WhiteNoise_Seed;              /* Expression: seed
                                        * '<S5>/White Noise'
                                        */
  real_T Output_Gain;                  /* Expression: [sqrt(Cov)]/[sqrt(Ts)]
                                        * '<S5>/Output'
                                        */
};

/* Real-time Model Data Structure */
struct RT_MODEL_f14 {
  const char_T *path;
  const char_T *modelName;
  struct SimStruct_tag * *childSfunctions;
  const char_T *errorStatus;
  SS_SimMode simMode;
  RTWLogInfo *rtwLogInfo;
  RTWExtModeInfo *extModeInfo;
  RTWSolverInfo solverInfo;
  RTWSolverInfo *solverInfoPtr;
  void *sfcnInfo;

  /*
   * ModelData:
   * The following substructure contains information regarding
   * the data used in the model.
   */
  struct {
    void *blockIO;
    const void *constBlockIO;
    real_T *defaultParam;
    ZCSigState *prevZCSigState;
    real_T *contStates;
    real_T *derivs;
    real_T *nonsampledZCs;
    void *inputs;
    void *outputs;
    boolean_T *contStateDisabled;
    boolean_T zCCacheNeedsReset;
    boolean_T derivCacheNeedsReset;
    boolean_T blkStateChange;
    real_T odeY[10];
    real_T odeF[6][10];
    ODE5_IntgData intgData;
  } ModelData;

  /*
   * Sizes:
   * The following substructure contains sizes information
   * for many of the model attributes such as inputs, outputs,
   * dwork, sample times, etc.
   */
  struct {
    uint32_T checksums[4];
    uint32_T options;
    int_T numContStates;
    int_T numU;
    int_T numY;
    int_T numSampTimes;
    int_T numBlocks;
    int_T numBlockIO;
    int_T numBlockPrms;
    int_T numDwork;
    int_T numSFcnPrms;
    int_T numSFcns;
    int_T numIports;
    int_T numOports;
    int_T numNonSampZCs;
    int_T sysDirFeedThru;
    int_T rtwGenSfcn;
  } Sizes;

  /*
   * SpecialInfo:
   * The following substructure contains special information
   * related to other components that are dependent on RTW.
   */
  struct {
    const void *mappingInfo;
    void *xpcData;
  } SpecialInfo;

  /*
   * Timing:
   * The following substructure contains information regarding
   * the timing information for the model.
   */
  struct {
    time_T stepSize;
    uint32_T clockTick0;
    uint32_T clockTickH0;
    time_T stepSize0;
    uint32_T clockTick1;
    uint32_T clockTickH1;
    time_T stepSize1;
    uint32_T clockTick2;
    uint32_T clockTickH2;
    time_T stepSize2;
    struct {
      uint8_T TID[3];
    } TaskCounters;

    time_T tStart;
    time_T tFinal;
    time_T timeOfLastOutput;
    void *timingData;
    real_T *varNextHitTimesList;
    SimTimeStep simTimeStep;
    boolean_T stopRequestedFlag;
    time_T *sampleTimes;
    time_T *offsetTimes;
    int_T *sampleTimeTaskIDPtr;
    int_T *sampleHits;
    int_T *perTaskSampleHits;
    time_T *t;
    time_T sampleTimesArray[3];
    time_T offsetTimesArray[3];
    int_T sampleTimeTaskIDArray[3];
    int_T sampleHitArray[3];
    int_T perTaskSampleHitsArray[9];
    time_T tArray[3];
  } Timing;

  /*
   * Work:
   * The following substructure contains information regarding
   * the work vectors in the model.
   */
  struct {
    void *dwork;
  } Work;
};

/* Block parameters (auto storage) */
extern Parameters_f14 f14_P;

/* Block signals (auto storage) */
extern BlockIO_f14 f14_B;

/* Continuous states (auto storage) */
extern ContinuousStates_f14 f14_X;

/* Block states (auto storage) */
extern D_Work_f14 f14_DWork;

/* External inputs (root inport signals with auto storage) */
extern ExternalInputs_f14 f14_U;

/* External outputs (root outports fed by signals with auto storage) */
extern ExternalOutputs_f14 f14_Y;

/* Model entry point functions */
extern void f14_initialize(boolean_T firstTime);
extern void f14_output(int_T tid);
extern void f14_update(int_T tid);
extern void f14_terminate(void);

/* Real-time Model object */
extern RT_MODEL_f14 *f14_M;

/*
 * The generated code includes comments that allow you to trace directly
 * back to the appropriate location in the model.  The basic format
 * is <system>/block_name, where system is the system number (uniquely
 * assigned by Simulink) and block_name is the name of the block.
 *
 * Use the MATLAB hilite_system command to trace the generated code back
 * to the model.  For example,
 *
 * hilite_system('<S3>')    - opens system 3
 * hilite_system('<S3>/Kp') - opens and selects block Kp which resides in S3
 *
 * Here is the system hierarchy for this model
 *
 * '<Root>' : f14
 * '<S1>'   : f14/Aircraft Dynamics Model
 * '<S2>'   : f14/Controller
 * '<S3>'   : f14/Dryden Wind Gust Models
 * '<S4>'   : f14/Nz pilot calculation
 * '<S5>'   : f14/Dryden Wind Gust Models/Band-Limited White Noise
 */
#endif                                 /* _RTW_HEADER_f14_h_ */