Subsystems.h

Go to the documentation of this file.

/*
 * Subsystems.h
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 Chris Wallace
 *
 * Fly! Legacy is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifndef SUBSYSTEMS_H
#define SUBSYSTEMS_H


#include "FlyLegacy.h"
#include <vector>
#include <map>


//
// Miscellaneous subsystems
//
#define SUBSYSTEM_BASE            ('subs')    // CSubsystem
#define SUBSYSTEM_DEPENDENT         ('dpnd')    // CDependent
#define SUBSYSTEM_ANNOUNCEMENT        ('annc')    // CAnnouncement
#define SUBSYSTEM_GENERIC_MONITOR     ('genM')    // CGenericMonitor
#define SUBSYSTEM_GENERIC_INDICATOR     ('genI')    // CGenericIndicator
#define SUBSYSTEM_HISTORY         ('hist')    // CHistory
#define SUBSYSTEM_PNEUMATIC_PUMP      ('pnup')    // CPneumaticPump
#define SUBSYSTEM_EMERGENCY_LOCATOR     ('elts')    // CEmergencyLocator
#define SUBSYSTEM_EXTERIOR_LIGHT      ('bulb')    // CExteriorLight
#define SUBSYSTEM_PITOT_STATIC_SWITCH   ('pssw')    // CPitotStaticSwitch
#define SUBSYSTEM_PITOT_HEAT_SWITCH     ('phsw')    // CPitotHeatSwitch
#define SUBSYSTEM_STATIC_SOURCE_SWITCH    ('sssw')    // CStaticSourceSwitch
#define SUBSYSTEM_ANNUNCIATOR_LIGHT     ('anlt')    // CAnnunciatorLight
#define SUBSYSTEM_STALL_WARNING       ('stal')    // CStallWarning
#define SUBSYSTEM_LIGHT_SETTING_STATE   ('lsst')    // CLightSettingState
#define SUBSYSTEM_SWITCH_SET        ('swst')    // CSwitchSet
#define SUBSYSTEM_ROTARY_IGNITION_SWITCH  ('rign')    // CRotaryIgnitionSwitch
#define SUBSYSTEM_BATTERY         ('batt')    // CBattery
#define SUBSYSTEM_ALTERNATOR        ('natr')    // CAlternator

//
// Gauge subsystems
//
#define SUBSYSTEM_PITOT_STATIC_SUBS     ('psss')    // CPitotStaticSubsystem
#define SUBSYSTEM_ALTIMETER         ('ALTI')    // CAltimeter
#define SUBSYSTEM_VERTICAL_SPEED      ('VSI_')    // CVerticalSpeedIndicator
#define SUBSYSTEM_AIRSPEED          ('SPED')    // CAirspeedIndicator
#define SUBSYSTEM_PNEUMATIC         ('pnus')    // CPneumaticSubsystem
#define SUBSYSTEM_ATTITUDE          ('ATTI')    // CAttitudeIndicator
#define SUBSYSTEM_DIRECTIONAL_GYRO      ('GYRO')    // CDirectionalGyro
#define SUBSYSTEM_VACUUM_INDICATOR      ('vaci')    // CVacuumIndicator
#define SUBSYSTEM_TURN_COORDINATOR      ('TURN')    // CTurnCoordinator
#define SUBSYSTEM_MAGNETIC_COMPASS      ('mcmp')    // CMagneticCompass
#define SUBSYSTEM_NAVIGATION        ('navg')    // CNavigation
#define SUBSYSTEM_DIGITAL_CLOCK_OAT     ('doat')    // CDigitalClockOAT
#define SUBSYSTEM_KAP140_PANEL        ('K140')    // CBKKAP140Panel
#define SUBSYSTEM_MARKER_PANEL        ('mark')    // CMarkerPanel
#define SUBSYSTEM_AMMETER         ('amps')    // CAmmeter

//
// Engine gauge subsystems
//
#define SUBSYSTEM_ENGINE_SUBSYSTEM      ('esub')    // CEngineSubsystem
#define SUBSYSTEM_TACHOMETER        ('TACH')    // CTachometer
#define SUBSYSTEM_OIL_TEMPERATURE     ('oilT')    // COilTemperature
#define SUBSYSTEM_OIL_PRESSURE        ('oilP')    // COilPressure
#define SUBSYSTEM_EXHAUST_GAS_TEMPERATURE ('eEGT')    // CExhaustGasTemperature
#define SUBSYSTEM_MANIFOLD_PRESSURE     ('eMAP')    // CManifoldPressure
#define SUBSYSTEM_HOBBS_METER       ('hobs')    // CHobbsMeter
#define SUBSYSTEM_TACHOMETER_TIMER      ('takt')    // CTachometerTimer

//
// Aircraft control subsystems
//
#define SUBSYSTEM_BASE_CONTROL        ('CONT')    // CBaseControl
#define SUBSYSTEM_THROTTLE_CONTROL      ('THRO')    // CThrottleControl
#define SUBSYSTEM_MIXTURE_CONTROL     ('MIXT')    // CMixtureControl
#define SUBSYSTEM_STEERING_CONTROL      ('ster')    // CSteeringControl
#define SUBSYSTEM_FLAP_CONTROL        ('flap')    // CFlapControl
#define SUBSYSTEM_ELEVATOR_CONTROL      ('elvr')    // CElevatorControl
#define SUBSYSTEM_AILERON_CONTROL     ('ailr')    // CAileronControl
#define SUBSYSTEM_RUDDER_CONTROL      ('rudr')    // CRudderControl
#define SUBSYSTEM_ELEVATOR_TRIM_CONTROL   ('etrm')    // CElevatorTrimControl
#define SUBSYSTEM_AILERON_TRIM_CONTROL    ('atrm')    // CAileronTrimControl
#define SUBSYSTEM_RUDDER_TRIM_CONTROL   ('rtrm')    // CRudderTrimControl
#define SUBSYSTEM_BRAKE_CONTROL       ('brak')    // CBrakeControl

//
// Radio subsystems
//
#define SUBSYSTEM_RADIO               ('rado')    // CRadio
#define SUBSYSTEM_NAV_RADIO           ('navi')    // CNavRadio
#define SUBSYSTEM_RNAV_RADIO          ('rnav')    // CRnavRadio
#define SUBSYSTEM_COMM_RADIO          ('comm')    // CCommRadio
#define SUBSYSTEM_HF_COMM_RADIO       ('hifr')    // CHFCommRadio
#define SUBSYSTEM_TRANSPONDER_RADIO   ('xpdr')    // CTransponderRadio
#define SUBSYSTEM_ADF_RADIO           ('adfr')    // CADFRadio
#define SUBSYSTEM_KLN89_GPS_RADIO     ('gpsr')    // CBKKLN89GPSRadio
#define SUBSYSTEM_KX155_RADIO         ('kx15')    // CBKKX155Radio
#define SUBSYSTEM_KT76_RADIO          ('kt76')    // CBKKT76Radio
#define SUBSYSTEM_AUDIO_PANEL_RADIO   ('adio')    // CAudioPanelRadio
#define SUBSYSTEM_KAP140_RADIO        ('ka14')    // CBKKAP140Radio

//
// Fuel subsystems specified in the GAS file
//
#define SUBSYSTEM_FUEL_SUBSYSTEM    ('fSub')    // CFuelSubsystem
#define SUBSYSTEM_FUEL_TAP          ('fTap')    // CFuelTap
#define SUBSYSTEM_FUEL_CELL         ('fCel')    // CFuelCell
#define SUBSYSTEM_FUEL_HEATER       ('fHtr')    // CFuelHeater
#define SUBSYSTEM_FUEL_MATH         ('fMat')    // CFuelMath
#define SUBSYSTEM_FUEL_PUMP         ('fPmp')    // CFuelPump
#define SUBSYSTEM_FUEL_SOURCE       ('fsrc')    // CFuelSource
#define SUBSYSTEM_FUEL_TANK         ('ftnk')    // CFuelTank


// *** Implemented subsystem types above this line

#define SUBSYSTEM_ENGINE_GAUGE        ('egag')    // CEngineGauge
#define SUBSYSTEM_ON_GROUND_MONITOR     ('ognd')    // COnGroundMonitor
#define SUBSYSTEM_ALTITUDE_MONITOR      ('altm')    // CAltitudeMonitor
#define SUBSYSTEM_SPEED_MONITOR       ('spdm')    // CSpeedMonitor
#define SUBSYSTEM_ENGINE_STATUS       ('ests')    // CEngineStatus
#define SUBSYSTEM_TIME_DELAY        ('tdla')    // CTimeDelay
#define SUBSYSTEM_KEYED_SYSTEM        ('keyd')    // CKeyedSystem
#define SUBSYSTEM_TACHOMETER_V1       ('tach')    // CTachometerV1
#define SUBSYSTEM_THROTTLE_CONTROL_V1   ('thro')    // CThrottleV1
#define SUBSYSTEM_MIXTURE_CONTROL_V1    ('mixt')    // CMixtureControlV1
#define SUBSYSTEM_PROPELLER_CONTROL_V1    ('blad')    // CPropellerControlV1
#define SUBSYSTEM_PRIME_CONTROL_V1      ('prim')    // CPrimeControlV1
#define SUBSYSTEM_ENGINE_ANTI_ICE_V1    ('carb')    // CEngineAntiIceV1
#define SUBSYSTEM_IDLE_CONTROL_V1     ('idle')    // CIdleControlV1
#define SUBSYSTEM_ALTIMETER_V1        ('alti')    // CAltimeterV1
#define SUBSYSTEM_VERTICAL_SPEED_V1     ('vsi_')    // CVerticalSpeedIndicatorV1
#define SUBSYSTEM_AIRSPEED_V1       ('sped')    // CAirspeedIndicatorV1
#define SUBSYSTEM_ATTITUDE_V1       ('atti')    // CAttitudeIndicatorV1
#define SUBSYSTEM_DIRECTIONAL_GYRO_V1   ('gyro')    // CDirectionalGyroV1
#define SUBSYSTEM_TURN_COORDINATOR_V1   ('turn')    // CTurnCoordinatorV1
#define SUBSYSTEM_AUDIO_PANEL_V1      ('audp')    // CAudioPanelV1
#define SUBSYSTEM_STARTER_CONTROL     ('strt')    // CStarterControl
#define SUBSYSTEM_MAGNETO_CONTROL     ('neto')    // CMagnetoControl
#define SUBSYSTEM_VOLTMETER         ('volt')    // CVoltmeter
#define SUBSYSTEM_GENERATOR         ('genr')    // CGenerator
#define SUBSYSTEM_FREQUENCY_METER     ('freq')    // CFrequencyMEter
#define SUBSYSTEM_INVERTER          ('nvrt')    // CInverter
#define SUBSYSTEM_FUEL_GAUGE        ('fgag')    // CFuelGauge
#define SUBSYSTEM_GEAR_CONTROL        ('gear')    // CGearControl
#define SUBSYSTEM_PROPELLER_CONTROL     ('BLAD')    // CPropellerControl
#define SUBSYSTEM_PRIME_CONTROL       ('PRIM')    // CPrimeControl
#define SUBSYSTEM_AUDIO_PANEL       ('AUDP')    // CAudioPanel
#define SUBSYSTEM_ENGINE_ANTI_ICE     ('CARB')    // CEngineAntiIce
#define SUBSYSTEM_IDLE_CONTROL        ('IDLE')    // CIdleControl
#define SUBSYSTEM_HIGH_LIFT_CONTROL     ('hild')    // CHighLiftControl
#define SUBSYSTEM_FUEL_FLOW_GAUGE     ('fflw')    // CFuelFlowGauge
#define SUBSYSTEM_FUEL_PRESSURE_GAUGE   ('fprs')    // CFuelPressureGauge
#define SUBSYSTEM_SUCTION_GAUGE       ('suct')    // CSuctionGauge
#define SUBSYSTEM_FLAP_GAUGE        ('flpg')    // CFlapGauge
#define SUBSYSTEM_ANNUNCIATOR       ('annr')    // CAnnunciator
#define SUBSYSTEM_PRESSURIZATION      ('pzat')    // CPressurization
#define SUBSYSTEM_N1_TACHOMETER       ('_N1_')    // CN1Tachometer
#define SUBSYSTEM_N2_TACHOMETER       ('_N2_')    // CN2Tachometer
#define SUBSYSTEM_TORQUE_METER        ('torq')    // CTorqueMEter
#define SUBSYSTEM_DME_PANEL         ('dmep')    // CDMEPanel
#define SUBSYSTEM_DME_PANEL_1       ('dme2')    // CDMEPanel2
#define SUBSYSTEM_WEATHER_RADAR       ('wrdr')    // CWeatherRadar
#define SUBSYSTEM_INDICATOR_SET       ('inds')    // CIndicatorSet
#define SUBSYSTEM_CONTACTOR         ('cntr')    // CContactor
#define SUBSYSTEM_FLASHER         ('flsh')    // CFlasher
#define SUBSYSTEM_FAST_SLOW_METER     ('fosm')    // CFastSlowMEter
#define SUBSYSTEM_CYLINDER_HEAD_TEMP_GAUGE  ('eCHT')    // CCylinderHeadTempGauge
#define SUBSYSTEM_ITT_GAUGE         ('eITT')    // CInterturbineTempGauge
#define SUBSYSTEM_ACCELEROMETER       ('acel')    // CAccelerometer
#define SUBSYSTEM_TCAS_PANEL        ('tcas')    // CTCASPanel
#define SUBSYSTEM_GEAR_LIGHT        ('grlt')    // CGearLight
#define SUBSYSTEM_FUEL_PUMP_CONTROL     ('fpsw')    // CFuelPumpControl
#define SUBSYSTEM_GEAR_WARNING        ('grwn')    // CGearWarning
#define SUBSYSTEM_SYNCHROPHASER       ('sync')    // CSynchrophaser
#define SUBSYSTEM_SURFACE_DEICE       ('sdic')    // CSurfaceDeice
#define SUBSYSTEM_PROPELLER_DEICE     ('pdic')    // CPropellerDeice
#define SUBSYSTEM_CROSSFEED_CONTROL     ('xfed')    // CCrossfeedControl
#define SUBSYSTEM_OXYGEN          ('oxyg')    // COxygen
#define SUBSYSTEM_STARTER_IGNITER     ('StIg')    // CStarterIgniter
#define SUBSYSTEM_ENGINE_MONITOR      ('eMnr')    // CEngineMonitor
#define SUBSYSTEM_FIRE_SYSTEM       ('fire')    // CFireSystem
#define SUBSYSTEM_FUEL_IMBALANCE      ('fimb')    // CFuelImbalance
#define SUBSYSTEM_COWL_FLAP         ('cowl')    // CCowlFlap
#define SUBSYSTEM_TEMP_CONTROL        ('temp')    // CTempControl
#define SUBSYSTEM_WIPER_CONTROL       ('wipe')    // CWiperControl
#define SUBSYSTEM_AIR_BRAKE_CONTROL     ('abrk')    // CAirbrakeControl
#define SUBSYSTEM_THRUST_REVERSE_CONTROL  ('trev')    // CThrustReverseControl
#define SUBSYSTEM_PERFORMANCE_RESERVE   ('aprs')    // CPerformanceReserve
#define SUBSYSTEM_RUDDER_BIAS       ('rbia')    // CRudderBias
#define SUBSYSTEM_STALL_IDENT       ('stlI')    // CStallIdent
#define SUBSYSTEM_IGNITER_CONTROL     ('ignc')    // CIgniterControl
#define SUBSYSTEM_WING_DEICE        ('wdic')    // CWingDeice
#define SUBSYSTEM_TEMP_AIRSPEED_DISPLAY   ('tasd')    // CTemperatureAirspeedDisplay
#define SUBSYSTEM_COLLINS_PFD       ('cpfd')    // CCollinsPFD
#define SUBSYSTEM_COLLINS_ND        ('cnvd')    // CCollinsND
#define SUBSYSTEM_COLLINS_AD        ('cadd')    // CCollinsAD
#define SUBSYSTEM_COLLINS_MND       ('cmnd')    // CCollinsMND
#define SUBSYSTEM_COLLINS_RTU       ('crtu')    // CCollinsRTU
#define SUBSYSTEM_PILATUS_PFD       ('ppfd')    // CPilatusPFD
#define SUBSYSTEM_VIRTUAL_GPS       ('vgps')    // CVirtualGPS
#define SUBSYSTEM_ROTOR           ('rtrs')    // CRotorSubsystem
#define SUBSYSTEM_407_DIGITAL_INDICATORS  ('x407')    // C407DigitalIndicators
#define SUBSYSTEM_HOOK            ('hook')    // CHookControl
#define SUBSYSTEM_THRUST_PITCH_CONTROL    ('tvpc')    // CThrustPitchControl
#define SUBSYSTEM_LON_CYCLIC_CONTROL    ('zCyc')    // CLonCyclicControl
#define SUBSYSTEM_LAT_CYCLIC_CONTROL    ('xCyc')    // CLatCyclicControl
#define SUBSYSTEM_TAIL_ROTOR_CONTROL    ('tRtr')    // CTailRotorControl
#define SUBSYSTEM_COLLECTIVE_CONTROL    ('coll')    // CCollectiveControl
#define SUBSYSTEM_LON_CYCLIC_TRIM_CONTROL ('zCyt')    // CLonCyclicTrimControl
#define SUBSYSTEM_LAT_CYCLIC_TRIM_CONTROL ('xCyt')    // CLatCyclicTrimControl
#define SUBSYSTEM_TAIL_ROTOR_TRIM_CONTROL ('tRtt')    // CTailRotorTrimControl
#define SUBSYSTEM_COLLECTIVE_TRIM_CONTROL ('tCol')    // CCollectiveTrimControl
#define SUBSYSTEM_AIR_MODEL         ('airS')    // CAirModel
#define SUBSYSTEM_MIXER_MODEL       ('mixr')    // CMixerModel
#define SUBSYSTEM_WHEEL_MODEL       ('whls')    // CWheelModel
#define SUBSYSTEM_ENGINE_MODEL        ('ngns')    // CEngineModel
#define SUBSYSTEM_WING_MODEL        ('wngs')    // CWingModel
#define SUBSYSTEM_AUTOPILOT_MASTER_PANEL  ('MrAp')    // CAutopilotMasterPanel
#define SUBSYSTEM_AUTOPILOT_PANEL     ('appl')    // CAutopilotPanel
#define SUBSYSTEM_K150_PANEL        ('K150')    // CKAP150Panel
#define SUBSYSTEM_K200_PANEL        ('K200')    // CKAP200Panel
#define SUBSYSTEM_AFCS65_PANEL        ('C065')    // CAFCS65Panel
#define SUBSYSTEM_AFCS85_PANEL        ('C085')    // CAFCS85Panel
#define SUBSYSTEM_UNIVERSAL_FMS       ('ufms')    // CFMSys
#define SUBSYSTEM_ENGINE_FUEL_PUMP      ('edfp')    // CEngineFuelPump
#define SUBSYSTEM_FUEL_MANAGEMENT     ('fmnt')    // CFuelManagement
#define SUBSYSTEM_APU_FUEL_SOURCE     ('fAPU')    // CAPUFuelSource


//
// CSubsystem is the top-level abstract parent for all electrical subsystem
//   classes.  Every CSubsystem has an "indication" attribute stored in the 'indn'
//   member.  The interpretation of the indication is completely arbitrary based
//   on the specific CSubsystem subclass.  For example, the indn for a CVoltmeter
//   object would be the voltage level of the circuit it was connected to; the indn
//   value for a CAltimeter object would represent the vehicle barometric altitude.
//
// Every CSubsystem instance MUST have a unique Tag identifier assigned to it in
//   the object specification.
//
// All CSubsystem objects can be configured to have the indication value lag behind
//   the current setting through the 'timK' and 'ratK' values.
//

typedef enum {
  INDN_NONE,
  INDN_LINEAR,
  INDN_EXPONENTIAL
} EIndicationMode;

typedef enum {
  EVAL_UNKNOWN,
  EVAL_INPROGRESS,
  EVAL_COMPLETE
} EEvalState;


class CSubsystem : public CStreamObject {
public:
  CSubsystem (void);
  virtual ~CSubsystem (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
  void  TypeIs (Tag t);
  bool  IsType (Tag t);
  void  Alias (Tag tag, Tag alias);
  bool  MsgForMe (SMessage *msg);

  virtual EMessageResult  ReceiveMessage (SMessage *msg);
  virtual void  SetGroup (int group) { gNum = group; }
//  virtual void  StartSituation (void);
//  virtual void  EndSituation (void);
  virtual void  Prepare (void);
  virtual void  TimeSlice (float dT);

  virtual void  Print (FILE *f);

protected:
  // Subsystem type, used for debugging
  Tag   type;
  char  type_string[8];

  // Unique ID.  Mandatory for all subsystem instances
  Tag   unId;
  char  unId_string[8];

  std::map<Tag,Tag>   aliasList;    // Mapping of aliased datatags

  // These parameters control the indication value of the subsystem
  float     timK;   // Time constant
  float     ratK;   // Rate constant
  float     indn;   // Current indication value
  float     indnTarget; // Target indication value
  EIndicationMode indnMode; // Indication mode

  // Sound effect name; no direct use in CSubsystem implementation, but included
  //   as part of the base object for use by derived classes.
  char  fWAV[64];

  // DEPRECATED messaging fields
  unsigned int    uNum;
  unsigned int    gNum;
  EMessageHWType  hwId;
};


typedef enum {
  DEPENDENCY_AND,
  DEPENDENCY_OR
} EDependentFunction;

typedef enum {
  POLL_NEVER,
  POLL_CHANGED,
  POLL_ALWAYS,
} EDependentPolling;

//
// CDependent introduces the concept of an on/off activity state to the CSubsystem.
//   The on/off state of a CDependency is derived from the on/off states of other
//   CDependency instances, in a hierarchical tree that can represent various
//   electrical circuits in a user vehicle.
//
// On each simulation cycle, the CDependent polls the 'stat' datatag of each of
//   its dependencies, combines them with either an AND or OR function, and
//   sets its own 'stat' member accordingly.  (Note, 'actv' and 'st8t' are
//   synonym datatags for 'stat').
//
// Since CDependent objects are typically used to represent components of
//   electrical circuits such as switches, fuses, busses, etc., additional
//   members are present to represent circuit voltage and current load
//   as well as AC frequency (if the object is dependent upon an AC current source)
//   and maximum voltage.
//
// Proxy messaging is a feature whereby the CDependent can send additional
//   messages to other subsystems when the state of the CDependent changes.
//
class CDependent: public CSubsystem {
public:
  CDependent (void);
  virtual ~CDependent (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);
  virtual void            TimeSlice (float dT);
  virtual void            Print (FILE *f);

  // CDependent methods
  void                    SetEvaluated (EEvalState eval);
  int                     NumDependencies (void);

public:
  // Whether the dependency activity status has been evaluated for this timeslice
  EEvalState  evaluated;

  // State dependencies
  std::vector<SMessage> dpnd; // Messages used to determine our state
  EDependentFunction    mode; // How to combine multiple dependent states

  // Electrical ciruit parameters (read datatags)
  bool          stat; // Default activity state
  int           st8t; // Default state controller state
  float         volt; // Subsystem voltage
  float         offV; // Voltage when state is off
  float         mVlt; // Maximum voltage
  float         load; // Subsystem load (amps)
  float         freQ; // AC frequency

  // Real-time state
  bool          active;   // Activity state (true=active, false=inactive)
  int           state;    // State controller value

  // Real-time electrical values
  float         voltage;
  float         current;
  float         frequency;

  // Proxy messages
  SMessage        pxy1; // Rising edge proxy message
  SMessage        pxy0; // Falling edge proxy message
  float         rise; // Threshold for rising edge proxy
  float         fall; // Threshold for falling edge proxy

  // Polling messages
  SMessage        mPol; // Polling message
  bool          mAll; // Create all three polling messages
  EDependentPolling   poll; // Polling behaviour
};


//
// CAnnouncement
//
class CAnnouncement : public CSubsystem {
public:
  CAnnouncement (void);

  // CStreamObject methods
//  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);
//  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};


// 
// CGenericMonitor
//
typedef enum {
  MONITOR_LT,
  MONITOR_GT,
  MONITOR_LE,
  MONITOR_GE
} EMonitorMode;


//
// CGenericMonitor
//
class CGenericMonitor : public CDependent {
public:
  CGenericMonitor (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);
  virtual void      TimeSlice (float dT);

protected:
  SMessage    mVal;   // Message to get value for comparison
  EMonitorMode  mode;   // How to compare value to reference value
  float     comp;   // Reference value for comparison
};


//
// CGenericIndicator
//
class CGenericIndicator : public CDependent {
public:
  CGenericIndicator (void);

  // CStreamObject methods
  virtual int       Read (SStream *stream, Tag tag);
  virtual void      ReadFinished (void);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
  SMessage    mVal;   // Message to get value for comparison
  Tag       alia;   // Alias datatag
};


//
// CHistory
//
class CHistory : public CDependent {
public:
  CHistory (void);

  // CStreamObject methods

  // CSubsystem methods
};



//
// CPneumaticPump
//
class CPneumaticPump : public CDependent {
public:
  CPneumaticPump (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
  float   suct;     // Pump suction (psi)
};


//
// CEmergencyLocator
//
class CEmergencyLocator : public CDependent {
public:
  CEmergencyLocator (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  float   gLim;     // G-load activation limit
};


//
// CExteriorLight
//
class CExteriorLight : public CDependent {
public:
  CExteriorLight (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  Tag     LMid;     // Light model ID
};


//
// CPitotStaticSwitch
//
class CPitotStaticSwitch : public CDependent {
public:
  CPitotStaticSwitch (void);
  virtual ~CPitotStaticSwitch (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  int   nSystems;       // Number of pitot/static systems
  int   *system;        // Array of pitot/static system group numbers
};


//
// CPitotHeatSwitch
//
class CPitotHeatSwitch : public CPitotStaticSwitch {
public:
  CPitotHeatSwitch (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CStaticSourceSwitch
//
class CStaticSourceSwitch : public CPitotStaticSwitch {
public:
  CStaticSourceSwitch (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CAnnunciatorLight
//
class CAnnunciatorLight : public CDependent {
public:
  CAnnunciatorLight (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  float   blnk;       // Blink period (sec)
  float   blpp;       // Blink rate (on duty cycle in sec)
};


//
// CStallWarning
//
class CStallWarning : public CDependent {
public:
  CStallWarning (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  char    wing[64];     // Wing section name
};


//
// CLightSettingState
//
class CLightSettingState : public CDependent {
public:
  CLightSettingState (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  float   levl;       // Light level
};


//
// CSwitchSet
//
class CSwitchSet : public CDependent {
public:
  CSwitchSet (void);
  virtual ~CSwitchSet (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  std::vector<SMessage>    smsg;     // Switch messages

  bool    sync;      // Sync all switches
  bool    LAND;     // Controlled by LAND key mapping
  bool    TAXI;     // Controlled by TAXI key mapping
  bool    NAVI;     // Controlled by NAVI key mapping
};


//
// CRotaryIgnitionSwitch
//
class CRotaryIgnitionSwitch : public CDependent {
public:
  CRotaryIgnitionSwitch (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CBattery
//
class CBattery : public CDependent {
public:
  CBattery (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  float   life;       // Capacity (amp-hours)
};


//
// CAlternator
//
class CAlternator : public CDependent {
public:
  CAlternator (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods
  EMessageResult ReceiveMessage (SMessage *msg);

protected:
  float   mxld;       // Maximum load (amps)
  float   loRg;       // Minimum RPM regulatable
};


// *
// * Gauge subsystems
// *

//
// CPitotStaticSubsystem
//
// This subystem is an abstract base class for any subsystems which have a 
//   dependency on a pitot/static subsystem.
//
class CPitotStaticSubsystem : public CDependent {
public:
  CPitotStaticSubsystem (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);

  // CSubsystem methods
//  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
  int       gNum;   // Port group number
};


//
// CAltimeter
//
class CAltimeter : public CPitotStaticSubsystem {
public:
  CAltimeter (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
};


//
// CVerticalSpeedIndicator
//
class CVerticalSpeedIndicator : public CPitotStaticSubsystem {
public:
  CVerticalSpeedIndicator (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
};


//
// CAirspeedIndicator
//
class CAirspeedIndicator : public CPitotStaticSubsystem {
public:
  CAirspeedIndicator (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
};


//
// CPneumaticSubsystem
//
// This subystem is an abstract base class for any subsystems which have a 
//   dependency on a pneumatic pump subsystem
//
class CPneumaticSubsystem : public CDependent {
public:
  CPneumaticSubsystem (void);
  virtual ~CPneumaticSubsystem (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);

  // CSubsystem methods
//  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
  std::vector<SMessage>   mPmp;   // Dependent pump messages
};


//
// CAttitudeIndicator
//
class CAttitudeIndicator : public CPneumaticSubsystem {
public:
  CAttitudeIndicator (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
  float     prat;   // Precession rate
};


//
// CDirectionalGyro
//
class CDirectionalGyro : public CPneumaticSubsystem {
public:
  CDirectionalGyro (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
  float     step;
};


//
// CVacuumIndicator
//
class CVacuumIndicator : public CPneumaticSubsystem {
public:
  CVacuumIndicator (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);

  // CSubsystem methods
//  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
};


//
// CTurnCoordinator
//
class CTurnCoordinator : public CDependent {
public:
  CTurnCoordinator (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);

  // CSubsystem methods
//  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
  float     tilt;   // Tilt??
};


//
// CMagneticCompass
//
class CMagneticCompass : public CDependent {
public:
  CMagneticCompass (void);

  // CStreamObject methods

  // CSubsystem methods
};


//
// CNavigation
//
class CNavigation : public CDependent {
public:
  CNavigation (void);

  // CStreamObject methods

  // CSubsystem methods
};


//
// CDigitalClockOAT
//
class CDigitalClockOAT : public CDependent {
public:
  CDigitalClockOAT (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CBKKAP140Panel
//
class CBKKAP140Panel : public CDependent {
public:
  CBKKAP140Panel (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
//  CAutopilotSpec  atop;   // Autopilot specification object
  SMessage    gyro;   // Directional gyro (heading) message
  SMessage    nav1;   // NAV gauge message
};


//
// CMarkerPanel
//
class CMarkerPanel : public CDependent {
public:
  CMarkerPanel (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CAmmeter
//
class CAmmeter : public CDependent {
public:
  CAmmeter (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  bool    chrg;     // Charge meter
  SMessage  mMon;     // Monitor message
};


// *
// * Engine gauge subsystems
// *

//
// CSteeringControl
//
class CSteeringControl : public CDependent {
public:
  CSteeringControl (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CEngineSubsystem
//
// This subsystem is an abstract base class for any subsystems which have a 
//   dependency on an engine
//
class CEngineSubsystem : public CDependent {
public:
  CEngineSubsystem (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  unsigned int  eNum;   // Engine number
};


//
// CTachometer
//
class CTachometer : public CEngineSubsystem {
public:
  CTachometer (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// COilTemperature
//
class COilTemperature : public CEngineSubsystem {
public:
  COilTemperature (void);

  // CStreamObject methods

  // CSubsystem methods
};


//
// COilPressure
//
class COilPressure : public CEngineSubsystem {
public:
  COilPressure (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  float lowP;     // Low pressure threshold
};


//
// CExhaustGasTemperature
//
class CExhaustGasTemperature : public CEngineSubsystem {
public:
  CExhaustGasTemperature (void);

  // CStreamObject methods

  // CSubsystem methods
};


//
// CManifoldPressure
//
class CManifoldPressure : public CEngineSubsystem {
public:
  CManifoldPressure (void);

  // CStreamObject methods

  // CSubsystem methods
};


//
// CHobbsMeter
//
class CHobbsMeter : public CEngineSubsystem {
public:
  CHobbsMeter (void);

  // CStreamObject methods

  // CSubsystem methods
};


//
// CTachometerTimer
//
class CTachometerTimer : public CEngineSubsystem {
public:
  CTachometerTimer (void);

  // CStreamObject methods

  // CSubsystem methods
};


// *
// * Aircraft control subsystems
// *

//
// CBaseControl
//
class CBaseControl : public CDependent {
public:
  CBaseControl (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

  // CBaseControl methods
  void    Incr (void);
  void    Decr (void);

protected:
  float   scal;   // Scaling factor
  float   step;   // Step size
  float   bend;   // Exponential value
  float   posn;   // Default position
};


//
// CThrottleControl
//
class CThrottleControl : public CBaseControl {
public:
  CThrottleControl (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CMixtureControl
//
class CMixtureControl : public CBaseControl {
public:
  CMixtureControl (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  bool  autoControl;    // Under automatic or user control?
  bool  injd;       // Fuel injected system (vs carbeurated)
  float prmr;       // Priming rate
  float prff;       // Priming fuel flow
  float plim;       // Priming pump limit
};


//
// CFlapControl
//
class CFlapControl : public CBaseControl {
public:
  CFlapControl (void);
  virtual ~CFlapControl (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

  // CSubsystem methods

protected:
  int   nPos;       // Number of flap positions
  float *pos;       // Array of flap positions
  int   nSpeed;       // Number of damage speeds
  float *speed;       // Array of damage speeds
};


//
// CElevatorControl
//
class CElevatorControl : public CBaseControl {
public:
  CElevatorControl (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CAileronControl
//
class CAileronControl : public CBaseControl {
public:
  CAileronControl (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CRudderControl
//
class CRudderControl : public CBaseControl {
public:
  CRudderControl (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CElevatorTrimControl
//
class CElevatorTrimControl : public CBaseControl {
public:
  CElevatorTrimControl (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CAileronTrimControl
//
class CAileronTrimControl : public CBaseControl {
public:
  CAileronTrimControl (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CRudderTrimControl
//
class CRudderTrimControl : public CBaseControl {
public:
  CRudderTrimControl (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


//
// CBrakeControl
//
class CBrakeControl : public CBaseControl {
public:
  CBrakeControl (void);

  // CStreamObject methods

  // CSubsystem methods

protected:
};


// *
// *  Radio subsystems
// *

//
// CRadio
//
// This subsytem is the base for all radio subsystems
//
class CRadio : public CDependent {
public:
  CRadio (void);

  // CStreamObject methods
  virtual int       Read (SStream *stream, Tag tag);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
  float     tune;         // Frequency
  float     lfrq;         // Minimum frequency
  float     hfrq;         // Maximum frequency
  float     sinc;         // Seek increment
  bool      test;         // Test mode active
};

//
// CNavRadio
//
class CNavRadio : public CRadio {
public:
  CNavRadio (void);
  virtual ~CNavRadio (void);

  // CStreamObject methods
  virtual int       Read (SStream *stream, Tag tag);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);
  virtual void            TimeSlice (float dT);

  // CNavRadio methods
  virtual void            RescanNavaids (void);

protected:
  float     stby;           // Standby frequency

  SNavaid   *navaidList;    // List of local navaids
  float     navaidTimer;    // Timer for querying local navaids periodically
  int       navaidFilter;   // Navaid type to filter
  SNavaid   *navaidTuned;   // Pointer to tuned navaid
  
  // Navaid pointer
  float     navd;           // Navaid pointer (degrees)
  float     navdTarget;     // Navaid value to track to
  float     navdTimK;       // Exponential tracking time constant
  float     navdRatK;       // Linear tracking time constant
};


//
// CRnavRadio
//
class CRnavRadio : public CRadio {
public:
  CRnavRadio (void);

  // CStreamObject methods

  // CSubsystem methods
//  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
};


//
// CCommRadio
//
class CCommRadio : public CRadio {
public:
  CCommRadio (void);

  // CStreamObject methods

  // CSubsystem methods
//  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
  float       stby;           // Standby frequency
};


//
// CHFCommRadio
//
class CHFCommRadio : public CCommRadio {
public:
  CHFCommRadio (void);

  // CStreamObject methods

  // CSubsystem methods
//  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
};


//
// CTransponderRadio
//
typedef enum {
  XPDR_OFF        = 0,
  XPDR_STARTUPA1  = 1,
  XPDR_STARTUPA2  = 2,
  XPDR_STANDBY    = 3,
  XPDR_TEST       = 4,
  XPDR_ON         = 5,
  XPDR_ALT        = 6
} ETransponderMode;

typedef enum {
  XPDR_SWITCH_OFF     = 0,
  XPDR_SWITCH_STANDBY = 3,
  XPDR_SWITCH_TEST    = 4,
  XPDR_SWITCH_ON      = 5,
  XPDR_SWITCH_ALT     = 6
} ETransponderSwitchMode;

class CTransponderRadio : public CRadio {
public:
  CTransponderRadio (void);

  // CStreamObject methods
  virtual int       Read (SStream *stream, Tag tag);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);
  virtual void            TimeSlice (float dT);

protected:
  ETransponderMode         mode;       // Operating mode
  ETransponderSwitchMode   smod;       // Switch mode
  char                     airc[16];   // Aircraft tail number
  int                      lspd;       // Minumum safe operating speed in kias
  int                      uspd;       // Maximum safe operating speed in kias
  SMessage                 mAlt;       // Altimeter message

  bool                     prevActive; // Used to detect power-on transition
  float                    startupTimer;

  int                      code;        // Transponder code
  bool                     reply;
  float                    replyTimer;
};


//
// CADFRadio
//
class CADFRadio : public CNavRadio {
public:
  CADFRadio (void);

  // CStreamObject methods
  virtual int       Read (SStream *stream, Tag tag);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);
  virtual void            TimeSlice (float dT);

  // CADFRadio methods
  void    ChangeADFFrequency (float &freq, int digit, int change);

protected:
  // Display mode flags indicate the state of the display
  bool        adf;        // ADF active flag
  bool        frq;        // FRQ active flag
  bool        bfo;        // BFO active flag
  bool        flt;        // Flight timer active flag
  bool        et;         // Elapsed timer active flag

  // Elapsed and flight timers
  bool        etst;       // Elapsed timer started flag
  bool        fltStored;  // Stored state of FLT when FRQ active
  bool        etStored;   // Stored state of ET when FRQ active
  float       ftime;      // Flight timer in seconds
  float       etime;      // Elapsed timer in seconds

  // ??? Unknown purpose
  bool        frct;       // Fractional tuning enable flag
  bool        tone;       // Tone enable flag
  float       volu;       // Tone volume
};


//
// CBKKX155Radio
//
typedef enum {
  COM_MODE_NORMAL,
  COM_MODE_SELECT,
  COM_MODE_PROGRAM
} EBKKX155ComMode;

typedef enum {
  NAV_MODE_STANDBY,
  NAV_MODE_CDI,
  NAV_MODE_BEARING,
  NAV_MODE_RADIAL,
  NAV_MODE_TIMER
} EBKKX155NavMode;

class CBKKX155Radio : public CRadio {
public:
  CBKKX155Radio (void);
  virtual ~CBKKX155Radio (void);

  // CStreamObject methods

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);
  virtual void  TimeSlice (float dT);

  // CBKKX155Radio methods
  void          RescanNavaids (void);

protected:
  // Radio frequencies are in KHz
  float     comA, comS;
  float     navA, navS;
  float     temp;

  // Frequency step size
  float     comfractstep;

  // OBS setting (degrees)
  float     obs;

  // Navaid pointer (degrees)
  float     navd;

  // COM and NAV modes
  EBKKX155ComMode   comMode;
  EBKKX155NavMode   navMode;

  SNavaid   *navaidList;    // List of local navaids
  float     navaidTimer;    // Timer for querying local navaids periodically
  SNavaid   *navaidTuned;   // Pointer to tuned navaid
};


//
// CBKKT76Radio
//
class CBKKT76Radio : public CTransponderRadio {
public:
  CBKKT76Radio (void);

  // CStreamObject methods
  virtual int       Read (SStream *stream, Tag tag);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);
  virtual void            TimeSlice (float dT);

protected:
  char              tempCode[5];
  int               entryDigit;
  bool              entryMode;
  float             entryTimer;
};


//
// CBKKLN89GPSRadio
//
class CBKKLN89GPSRadio : public CRadio {
public:
  CBKKLN89GPSRadio (void);

  // CStreamObject methods
  virtual int       Read (SStream *stream, Tag tag);
  virtual void      ReadFinished (void);

  // CSubsystem methods
//  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
  SMessage    mFMS;   // Flight Management System message
  SMessage    mSpd;   // Airspeed indicator message
};


//
// CAudioPanelRadio
//
class CAudioPanelRadio : public CDependent {
public:
  CAudioPanelRadio (void);

  // CStreamObject methods

  // CSubsystem methods
//  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
};


//
// CBKKAP140Radio
//
class CBKKAP140Radio : public CDependent {
public:
  CBKKAP140Radio (void);

  // CStreamObject methods
//  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);

  // CSubsystem methods
//  virtual EMessageResult  ReceiveMessage (SMessage *msg);

protected:
};


// *
// * Fuel subsystems defined in GAS file
// *

//
// CFuelSubsystem
//
// This class is the base for all subsystems found in the GAS (fuel system)
//   stream file
//
class CFuelSubsystem : public CDependent {
public:
  // Constructor
  CFuelSubsystem (void);
  virtual ~CFuelSubsystem (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

// Data members
protected:
  char              name[64];   // UI readable name
  std::vector<Tag>  pipe;       // Fuel subsystem dependencies
};

//
// CFuelTap
//
class CFuelTap : public CFuelSubsystem {
public:
  // Constructor
  CFuelTap (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);

// Data members
protected:
  float     stff; // Startup fuel flow
  unsigned int  eNum; // Engine number

  float     gph;  // Fuel flow through tap (gallons per hour)
};

//
// CFuelCell
//
class CFuelCell : public CFuelSubsystem {
public:
  // Constructor
  CFuelCell (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);

  // CSubsystem methods
  virtual EMessageResult  ReceiveMessage (SMessage *msg);

// Data members
protected:
  float cap;    // Capacity (gallons)
  float qty;    // Default quantity (gallons)
  SVector bPos;   // Position
  float basP;   // Base pressure (psi)

  float gals;   // Fuel quantity in gallons
};


//
// CFuelHeater
//
class CFuelHeater : public CFuelSubsystem {
public:
  // Constructor
  CFuelHeater (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

// Data members
protected:
};


//
// CFuelMath
//
class CFuelMath : public CFuelSubsystem {
public:
  // Constructor
  CFuelMath (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

// Data members
protected:
};


//
// CFuelPump
//
class CFuelPump : public CFuelSubsystem {
public:
  // Constructor
  CFuelPump (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

// Data members
protected:
  float setP;   // Pump pressure
  bool  pass;   // Allow fuel passthrough when system is off
};


//
// CFuelSource
//
class CFuelSource : public CFuelSubsystem {
public:
  // Constructor
  CFuelSource (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

// Data members
protected:
};


//
// CFuelTank
//
class CFuelTank : public CFuelSubsystem {
public:
  // Constructor
  CFuelTank (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

// Data members
protected:
};


//
// CEngineFuelPump
//
class CEngineFuelPump : public CFuelSubsystem {
public:
  // Constructor
  CEngineFuelPump (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

// Data members
protected:
};


//
// CFuelManagement
//
class CFuelManagement : public CFuelSubsystem {
public:
  // Constructor
  CFuelManagement (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

// Data members
protected:
};


//
// CAPUFuelSource
//
class CAPUFuelSource : public CFuelSubsystem {
public:
  // Constructor
  CAPUFuelSource (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);

// Data members
protected:
};


/*
 * Actively implemented subsystems above here
 */

/*
//
// COnGroundMonitor
//
// This subystem monitors whether the user vehicle is sitting on the ground
//
class COnGroundMonitor : public CDependent {
public:
  COnGroundMonitor (void);

  // CStreamObject methods
//  virtual int   Read (SStream *stream, Tag tag);
//  virtual void  ReadFinished (void);
//  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};

//
// CAltitudeMonitor
//
// This subsystem monitors the user vehicle altitude and compares it to a preset
//   altitude threshold.  The subsystem state reflects whether the user vehicle
//   is above or below the threshold altitude.
//
class CAltitudeMonitor : public CDependent {
public:
  CAltitudeMonitor (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};

//
// CSpeedMonitor
//
// This subsystem monitors the user vehicle airspeed and compares it to a preset
//   threshold value.  The subsystem state reflects whether the user vehicle
//   is travelling faster or slower than the threshold airspeed.
//
class CSpeedMonitor : public CDependent {
public:
  CSpeedMonitor (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};

//
// CEngineStatus
//
// This subsystem monitors the status of a single engine, and sets its
//   indication value based on whether the engine is stopped, starting or
//   running
//
class CEngineStatus : public CDependent {
public:
  CEngineStatus (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};


//
// CTimeDelay
//
// This monitor subsystem can be configured to (do something) at periodic
//   time intervals
//
class CTimeDelay : public CDependent {
public:
  CTimeDelay (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};

//
// CKeyedSystem
//
class CKeyedSystem : public CSubsystem {
public:
  CKeyedSystem (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};



//
// CTachometerBase
//
class CTachometerBase : public CEngineSubsystem {
public:
  CTachometerBase (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};


//
// CTachometerV1
//
class CTachometerV1 : public CTachometerBase {
public:
  CTachometerV1 (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};


//
// CThrottleControlBase
//
class CThrottleControlBase : public CEngineControl {
public:
  CThrottleControlBase (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};

//
// CThrottleControlV1
//
class CThrottleControlV1 : public CEngineControl {
public:
  CThrottleControlV1 (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};

//
// CMixtureControlBase
//
class CMixtureControlBase : public CEngineControl {
public:
  CMixtureControlBase (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};

//
// CMixtureControlV1
//
class CMixtureControlV1 : public CMixtureControlBase {
public:
  CMixtureControlV1 (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};

//
// CPropellerControlV1
//
// This monitor subsystem can be configured to (do something) at periodic
//   time intervals
//
class CPropellerControlV1 : public CSubsystem {
public:
  CPropellerControlV1 (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};


//
// CPrimeControlV1
//
class CPrimeControlV1 : public CSubsystem {
public:
  CPrimeControlV1 (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};

//
// CEngineAntiIceV1
//
class CEngineAntiIceV1 : public CSubsystem {
public:
  CEngineAntiIceV1 (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};

//
// CIdleControlV1
//
class CIdleControlV1 : public CSubsystem {
public:
  CIdleControlV1 (void);

  // CStreamObject methods
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

  // CSubsystem methods
//  virtual void  ReceiveMessage (SMessage *msg);
//  virtual void  Update (float dT);
};


*/



//
// Pitot-Static Port
//
// This object represents a single port in the pitot-static (PSS) system
//
class CPitotStaticPort : public CDependent {
public:
  CPitotStaticPort (void);

  // CStreamObject members
  virtual int   Read (SStream *stream, Tag tag);
  virtual void  ReadFinished (void);
  virtual void  Write (SStream *stream);

protected:
  EPortType type;   // PITOT or STATIC port type
  SVector   bPos;   // Location relative to aircraft center of gravity
  int     grup;   // Group number
  EPortFace face;   // LEFT or RIGHT facing
  bool    inie;   // Interior port?
  bool    wont;   // Port won't ice up
};

#endif // SUBSYSTEMS_H

Documentation generated by