Subsystems.cpp

Go to the documentation of this file.

/*
 * Subsystems.cpp
 *
 * 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
 *
 */

#include "../Include/Subsystems.h"
#include "../Include/Utility.h"
#include "../Include/Database.h"
#include "../Include/Ui.h"
#include "../Include/Globals.h"

using namespace std;


//
// CSubsystem
//

CSubsystem::CSubsystem (void)
{
  TypeIs (SUBSYSTEM_BASE);
  unId = 0;
  timK = 1.0f;
  ratK = 1.0f;
  indn = 0;
  indnTarget = 0;
  indnMode = INDN_NONE;
  strcpy (fWAV, "");

  uNum = 1;
  gNum = 1;
  hwId = HW_STATE;
}

CSubsystem::~CSubsystem (void)
{
}

int CSubsystem::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'unId':
    // Unique ID
    ReadTag (&unId, stream);
    TagToString (unId_string, unId);
    rc = TAG_READ;
    break;

  case 'timK':
    // Exponential time constant
    ReadFloat (&timK, stream);
    indnMode = INDN_LINEAR;
    rc = TAG_READ;
    break;

  case 'ratK':
    // Linear time constant
    ReadFloat (&ratK, stream);
    indnMode = INDN_EXPONENTIAL;
    rc = TAG_READ;
    break;

  case 'indn':
    // Initial indication value
    ReadFloat (&indn, stream);
    rc = TAG_READ;
    break;

  case 'fWAV':
    // Triggered sound effect filename
    ReadString (fWAV, 64, stream);
    rc = TAG_READ;
    break;

  case 'uNum':
    // DEPRECATED = Unit number
    ReadUInt (&uNum, stream);
    rc = TAG_READ;
    break;

  case 'hwId':
    // DEPRECATED - Hardware type
    {
      char s[64];
      ReadString (s, 64, stream);
      if (stricmp (s, "UNKNOWN") == 0) {
        hwId = HW_UNKNOWN;
      } else if (stricmp (s, "BUS") == 0) {
        hwId = HW_BUS;
      } else if (stricmp (s, "SWITCH") == 0) {
        hwId = HW_SWITCH;
      } else if (stricmp (s, "LIGHT") == 0) {
        hwId = HW_LIGHT;
      } else if (stricmp (s, "FUSE") == 0) {
        hwId = HW_FUSE;
      } else if (stricmp (s, "STATE") == 0) {
        hwId = HW_STATE;
      } else if (stricmp (s, "GAUGE") == 0) {
        hwId = HW_GAUGE;
      } else if (stricmp (s, "CIRCUIT") == 0) {
        hwId = HW_CIRCUIT;
      } else if (stricmp (s, "RADIO") == 0) {
        hwId = HW_RADIO;
      } else if (stricmp (s, "FLAP") == 0) {
        hwId = HW_FLAP;
      } else if (stricmp (s, "HILIFT") == 0) {
        hwId = HW_HILIFT;
      } else if (stricmp (s, "GEAR") == 0) {
        hwId = HW_GEAR;
      } else if (stricmp (s, "BATTERY") == 0) {
        hwId = HW_BATTERY;
      } else if (stricmp (s, "ALTERNATOR") == 0) {
        hwId = HW_ALTERNATOR;
      } else if (stricmp (s, "ANNUNCIATOR") == 0) {
        hwId = HW_ANNUNCIATOR;
      } else if (stricmp (s, "GENERATOR") == 0) {
        hwId = HW_GENERATOR;
      } else if (stricmp (s, "CONTACTOR") == 0) {
        hwId = HW_CONTACTOR;
      } else if (stricmp (s, "SOUNDFX") == 0) {
        hwId = HW_SOUNDFX;
      } else if (stricmp (s, "FLASHER") == 0) {
        hwId = HW_FLASHER;
      } else if (stricmp (s, "INVERTER") == 0) {
        hwId = HW_INVERTER;
      } else if (stricmp (s, "UNITLESS") == 0) {
        hwId = HW_UNITLESS;
      } else if (stricmp (s, "UNBENT") == 0) {
        hwId = HW_UNBENT;
      } else if (stricmp (s, "SCALE") == 0) {
        hwId = HW_SCALE;
      } else {
        globals->logWarning->Write ("CDependent::Read : Unknown HW type %s", s);
      }
    }   
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("Subsystem '%s' : Unknown READ tag <%s>", type_string, s);
  }

  return rc;
}


void CSubsystem::ReadFinished (void)
{
}


void CSubsystem::Write (SStream *stream)
{

}

void CSubsystem::Prepare (void)
{

}

void CSubsystem::TypeIs (Tag t)
{
  // Set subsystem type and convert to string (useful when debugging)
  type = t;
  TagToString (type_string, type);

  // Initialize unique subsystem ID to subsystem type
  // This should be overridden with a <unid> tag in the subsystem definition
  unId = type;
  TagToString (unId_string, unId);
}

bool CSubsystem::IsType (Tag t)
{
  return (type == t);
}


void CSubsystem::Alias (Tag tag, Tag alias)
{
  aliasList[alias] = tag;
}


bool CSubsystem::MsgForMe (SMessage *msg)
{
  bool rc = false;

  if (msg) {
    bool matchGroup = (msg->group == unId);
    bool hwNull     = (msg->user.u.hw == HW_UNKNOWN);
    bool hwMatch    = (msg->user.u.hw == (unsigned int) hwId);
    bool unitNull   = (msg->user.u.unit == 0);
    bool unitMatch  = (msg->user.u.unit == uNum);

    rc = matchGroup && (hwNull || hwMatch) && (unitNull || unitMatch);
  }

  return rc;
}


//
// CSubsystem supports the following messages:
//
// GETDATA:
//  indn - Indication value (float)
//
// SETDATA:
//  indn - Indication value (float)
//
EMessageResult CSubsystem::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  Tag dtag = msg->user.u.datatag;

  // Check to see if the requested tag is an alias
  map<Tag,Tag>::iterator i = aliasList.find(dtag);
  if (i != aliasList.end()) {
    // Replace aliased datatag with original tag
    dtag = i->second;
  }

  if (msg) {
    // Verify that message is for this object
    if (msg->group == unId) {
      switch (msg->id) {
      case MSG_GETDATA:
        switch (dtag) {
        case 0:
        case 'indn':
          msg->dataType = TYPE_REAL;
          msg->realData = indn;
          msg->result = rc = MSG_PROCESSED;
          break;
        }
        break;

      case MSG_SETDATA:
        switch (dtag) {
        case 0:
        case 'indn':
          if (msg->dataType == TYPE_REAL) {
            indnTarget = msg->realData;
            msg->result = rc = MSG_PROCESSED;
          }
          break;
        }
        break;
      }
    }
  }

  return rc;
}

void CSubsystem::TimeSlice (float dT)
{
  // Update actual indication
  switch (indnMode) {
  case INDN_NONE:
    // Actual value tracks target value with no time lag
    indn = indnTarget;
    break;

  case INDN_LINEAR:
    // Use ratK (in seconds) as linear coefficient
    indn += (indnTarget - indn) * (dT / ratK);
    break;

  case INDN_EXPONENTIAL:
    // Use timK (in seconds) as exponential coeffiecient
    indn += (indnTarget - indn) * (1.0f - exp(-dT / timK));
    break;
  }
}

void CSubsystem::Print (FILE *f)
{
  fprintf (f, "CSubsystem:\n");
  fprintf (f, "  type=%s\tunId=%s\thw=", type_string, unId_string);
  switch (hwId) {
  case HW_UNKNOWN:
    fprintf (f, "UNKNOWN\n");
    break;

  case HW_BUS:
    fprintf (f, "BUS\n");
    break;

  case HW_SWITCH:
    fprintf (f, "SWITCH\n");
    break;

  case HW_LIGHT:
    fprintf (f, "LIGHT\n");
    break;

  case HW_FUSE:
    fprintf (f, "FUSE\n");
    break;

  case HW_STATE:
    fprintf (f, "STATE\n");
    break;

  case HW_GAUGE:
    fprintf (f, "GAUGE\n");
    break;

  case HW_OTHER:
    fprintf (f, "OTHER\n");
    break;

  case HW_CIRCUIT:
    fprintf (f, "CIRCUIT\n");
    break;

  case HW_FLAP:
    fprintf (f, "FLAP\n");
    break;

  case HW_HILIFT:
    fprintf (f, "HILIFT\n");
    break;

  case HW_GEAR:
    fprintf (f, "GEAR\n");
    break;

  case HW_BATTERY:
    fprintf (f, "BATTERY\n");
    break;

  case HW_ALTERNATOR:
    fprintf (f, "ALTERNATOR\n");
    break;

  case HW_GENERATOR:
    fprintf (f, "GENERATOR\n");
    break;

  case HW_CONTACTOR:
    fprintf (f, "CONTACTOR\n");
    break;

  case HW_SOUNDFX:
    fprintf (f, "SOUNDFX\n");
    break;

  case HW_FLASHER:
    fprintf (f, "FLASHER\n");
    break;

  case HW_INVERTER:
    fprintf (f, "INVERTER\n");
    break;

  case HW_UNITLESS:
    fprintf (f, "UNITLESS\n");
    break;

  case HW_UNBENT:
    fprintf (f, "UNBENT\n");
    break;

  case HW_SCALE:
    fprintf (f, "SCALE\n");
    break;

  case HW_RADIO:
    fprintf (f, "RADIO\n");
    break;

  case HW_ANNUNCIATOR:
    fprintf (f, "ANNUNCIATOR\n");
    break;
  }
  fprintf (f, "  unit=%d\tgNum=%d\n", uNum, gNum);
  fprintf (f, "  timK = %f\tratK=%f\n", timK, ratK);
  fprintf (f, "  indn = %f\tindnTarget=%f\n", indn, indnTarget);
}

//
// CDependent
//

CDependent::CDependent (void)
{
  // Initialize read datatags
  st8t = -1;              // Invalid state
  stat = false;
  offV = 0;
  mode = DEPENDENCY_OR;
  volt = 0;
  load = 0;
  mVlt = 0;
  freQ = 0;

  // Initialize real-time electrical states
  state = 0;
  active = false;
  voltage = 0;
  current = 0;
  frequency = 0;

  // Proxy messaging
  memset (&pxy1, 0, sizeof(SMessage));
  memset (&pxy0, 0, sizeof(SMessage));
  rise = 1.0f;
  fall = 0.0f;
  memset (&mPol, 0, sizeof(SMessage));
  mAll = false;
  poll = POLL_NEVER;
}

CDependent::~CDependent (void)
{
}

int CDependent::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;
  SMessage msg;
  memset (&msg, 0, sizeof(SMessage));

  switch (tag) {
  case 'volt':
    // Circuit voltage
    ReadFloat (&volt, stream);
    rc = TAG_READ;
    break;

  case 'mVlt':
    // Circuit maximum voltage
    ReadFloat (&mVlt, stream);
    rc = TAG_READ;
    break;

  case 'load':
    // Circuit load
    ReadFloat (&load, stream);
    rc = TAG_READ;
    break;

  case 'freQ':
    // AC current frequency
    ReadFloat (&freQ, stream);
    rc = TAG_READ;
    break;

  case 'eBus':
    // Logical connection to dependency with HW type BUS
    {
      ReadTag ((unsigned long*)(&msg.group), stream);
      msg.id = MSG_GETDATA;
      msg.user.u.datatag = 'st8t';
      msg.user.u.hw = HW_BUS;
      dpnd.push_back (msg);
    }
    rc = TAG_READ;
    break;

  case 'fuse':
    // Logical connection to dependency with HW type FUSE
    {
      ReadTag ((unsigned long*)(&msg.group), stream);
      msg.id = MSG_GETDATA;
      msg.user.u.datatag = 'st8t';
      msg.user.u.hw = HW_FUSE;
      dpnd.push_back (msg);
    }
    rc = TAG_READ;
    break;

  case 'swch':
    // Logical connection to dependency with HW type SWITCH
    {
      ReadTag ((unsigned long*)(&msg.group), stream);
      msg.id = MSG_GETDATA;
      msg.user.u.datatag = 'st8t';
      msg.user.u.hw = HW_SWITCH;
      dpnd.push_back (msg);
    }
    rc = TAG_READ;
    break;

  case 'lite':
    // Logical connection to dependency with HW type LIGHT
    {
      ReadTag ((unsigned long*)(&msg.group), stream);
      msg.id = MSG_GETDATA;
      msg.user.u.datatag = 'st8t';
      msg.user.u.hw = HW_LIGHT;
      dpnd.push_back (msg);
    }
    rc = TAG_READ;
    break;

  case 'annr':
    // Logical connection to dependency with HW type ANNOUNCER
    {
      ReadTag ((unsigned long*)(&msg.group), stream);
      msg.id = MSG_GETDATA;
      msg.user.u.datatag = 'st8t';
      msg.user.u.hw = HW_ANNUNCIATOR;
      dpnd.push_back (msg);
    }
    rc = TAG_READ;
    break;

  case 'bool':
    // Logical connection to dependency with HW type STATE
    {
      ReadTag ((unsigned long*)(&msg.group), stream);
      msg.id = MSG_GETDATA;
      msg.user.u.datatag = 'st8t';
      msg.user.u.hw = HW_STATE;
      dpnd.push_back (msg);
    }
    rc = TAG_READ;
    break;

  case 'cntr':
    // Logical connection to dependency with HW type CONTACTOR
    {
      ReadTag ((unsigned long*)(&msg.group), stream);
      msg.id = MSG_GETDATA;
      msg.user.u.datatag = 'st8t';
      msg.user.u.hw = HW_CONTACTOR;
      dpnd.push_back (msg);
    }
    rc = TAG_READ;
    break;

  case 'flsh':
    // Logical connection to dependency with HW type FLASHER
    {
      ReadTag ((unsigned long*)(&msg.group), stream);
      msg.id = MSG_GETDATA;
      msg.user.u.datatag = 'st8t';
      msg.user.u.hw = HW_FLASHER;
      dpnd.push_back (msg);
    }
    rc = TAG_READ;
    break;

  case 'batt':
    // Logical connection to dependency with HW type BATTERY
    rc = TAG_READ;
    {
      ReadTag ((unsigned long*)(&msg.group), stream);
      msg.id = MSG_GETDATA;
      msg.user.u.datatag = 'st8t';
      msg.user.u.hw = HW_BATTERY;
      dpnd.push_back (msg);
    }
    break;

  case 'altr':
    // Logical connection to dependency with HW type ALTERNATOR
    {
      ReadTag ((unsigned long*)(&msg.group), stream);
      msg.id = MSG_GETDATA;
      msg.user.u.datatag = 'st8t';
      msg.user.u.hw = HW_ALTERNATOR;
      dpnd.push_back (msg);
    }
    rc = TAG_READ;
    break;

  case 'nvrt':
    // Logical connection to dependency with HW type INVERTER
    {
      ReadTag ((unsigned long*)(&msg.group), stream);
      msg.id = MSG_GETDATA;
      msg.user.u.datatag = 'st8t';
      msg.user.u.hw = HW_INVERTER;
      dpnd.push_back (msg);
    }
    rc = TAG_READ;
    break;

  case 'st8t':
    // Default state
    ReadInt (&st8t, stream);
    rc = TAG_READ;
    break;

  case 'stat':
    // Default activity state is ON
    stat = true;
    rc = TAG_READ;
    break;

  case '_AND':
    // Combine dependencies in AND function
    mode = DEPENDENCY_AND;
    rc = TAG_READ;
    break;

  case '_OR_':
    // Combine dependencies in an OR function
    mode = DEPENDENCY_OR;
    rc = TAG_READ;
    break;

  case 'pxy1':
    // Rising edge proxy message
    ReadMessage (&pxy1, stream);
    rc = TAG_READ;
    break;

  case 'rise':
    // Rising edge proxy value
    ReadFloat (&rise, stream);
    rc = TAG_READ;
    break;

  case 'pxy0':
    // Falling edge proxy message
    ReadMessage (&pxy0, stream);
    rc = TAG_READ;
    break;

  case 'fall':
    // Falling edge proxy value
    ReadFloat (&fall, stream);
    rc = TAG_READ;
    break;

  case 'mPol':
    // Polling message
    ReadMessage (&mPol, stream);
    rc = TAG_READ;
    break;

  case 'mAll':
    // Create all three proxy messages
    mAll = true;
    rc = TAG_READ;
    break;

  case 'tPol':
    // Polling method
    {
      char s[64];
      ReadString (s, 64, stream);
      globals->logWarning->Write ("CDependent::Read : Unknown polling method %s", s);
    }
    rc = TAG_READ;
    break;

  case 'offV':
    // Indication value when inactive
    ReadFloat (&offV, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  return rc;
}


void CDependent::ReadFinished (void)
{
  CSubsystem::ReadFinished ();

  // Determine initial state controller state for this dependent.
  // For most dependents, the state controller defaults to always ON such
  //   that the activity state is determined solely by dependencies.  The
  //   exception is if the hardware type is SWITCH.  These default to off,
  //   under the assumption that the associated gauge will set the correct
  //   state through messaging.
  int init_state = 1;
  if (hwId == HW_SWITCH) {
    init_state = 0;
  }

  // Override initial state if the READ tag was specified
  if (st8t != -1) {
    init_state = st8t;
  }

  // Assign initial state
  state = init_state;
}


void CDependent::Write (SStream *stream)
{
}


int CDependent::NumDependencies (void)
{
  return dpnd.size();
}

//
// CDependent supports the following messages:
//
// GETDATA:
//  stat - State (int)
//
// SETDATA:
//  stat - State (int)
//
EMessageResult CDependent::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 0:
      case 'st8t':
      case 'stat':
        msg->dataType = TYPE_INT;
        msg->intData = state;
        msg->result = rc = MSG_PROCESSED;
        break;

      case 'actv':
        msg->dataType = TYPE_INT;
        msg->intData = (int)active;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;

    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 0:
      case 'st8t':
      case 'stat':
        if (msg->dataType == TYPE_INT) {
          state = msg->intData;
          msg->result = rc = MSG_PROCESSED;
        }
        break;
      }
      break;
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CSubsystem::ReceiveMessage (msg);
    }
  }

  return rc;
}

void CDependent::SetEvaluated (EEvalState eval)
{
  evaluated = eval;
}

void CDependent::TimeSlice (float dT)
{
  /*
   * First check our state controller, if the state is off (zero) then there is
   *   no need to check dependencies
   */
  active = (state != 0);

  // Return immediately if the subsytem state controller indicates it is off, or
  //  if there are no dependencies to check
  if (!active || (NumDependencies() == 0)) return;

  /*
   *  Before polling dependencies, ensure that they have all been updated
   *    for this timeslice.
   */
  switch (evaluated) {
  case EVAL_UNKNOWN:
    // This is the first call to TimeSlice for this dependent subsystem
    {
      // Set our evaluation status to in-progress prior to timeslicing our
      //   dependencies.  If our own method gets called again then this
      //   will indicate a dependency loop
      evaluated = EVAL_INPROGRESS;

      vector<SMessage>::iterator i;
      for (i=dpnd.begin(); i!=dpnd.end(); i++) {
        if (i->receiver == 0) {
          SendMessage (&(*i));
          if (i->receiver != 0) {
            // Receiver is valid
            CDependent *d = (CDependent *)(i->receiver);
            d->TimeSlice (dT);
          }
        }
      }

      // All dependents have been timesliced, set our state to complete
      evaluated = EVAL_COMPLETE;
    }
    break;

  case EVAL_INPROGRESS:
    // This indicates a dependency loop...I would have considered this a fatal
    //   error, but there are default aircraft (e.g. Flyhawk) with dependency
    //   loops.  For now, just return and allow the calls to unwind back to
    //   the dependency.
    return;
//    gtfo ("CDependent : Dependency loop, type='%4s' unId='%4s'", type_string, unId_string);
    break;

  case EVAL_COMPLETE:
    // This dependency has already been completely evaluated, return to avoid
    //   multiple timeslicing
    return;
    break;
  }

  /*
   * Get the aggregated activity state from all dependencies
   */
  // Initialize activity
  active = false;
  switch (mode) {
  case DEPENDENCY_AND:
    // Default state is on; if any dependencies are off then state will be off
    active = true;
    break;

  case DEPENDENCY_OR:
    // Default is off; if any dependencies are on then state will be on
    active = false;
    break;
  }

  // Update new state based on dependencies
  vector<SMessage>::iterator i;
  for (i=dpnd.begin(); i!=dpnd.end(); i++) {
    i->user.u.datatag = 'actv';
    bool pollActive = true;
    if (SendMessage (&(*i)) == MSG_PROCESSED) {
      // Message was processed
      pollActive = (i->intData != 0);
    }

    // Update new activity state
    switch (mode) {
    case DEPENDENCY_AND:
      active &= pollActive;
      break;

    case DEPENDENCY_OR:
      active |= pollActive;
      break;
    }
  }

  // Update electrical parameters
  if (active) {
    // Voltage is highest voltage of all dependents, clamped to maximum mVlt
    float v = volt;
    if (v > mVlt) v = mVlt;
    voltage = v;

    // Current is sum of current from all dependents
    current = load;

    // Frequency is highest frequency of all dependents
    frequency = freQ;
  } else {
    // Dependent is inactive
    voltage = offV;
    current = 0;
    frequency = 0;
  }

  // If state has changed, send any proxy messages

  // Call parent class timeslice method
  CSubsystem::TimeSlice (dT);
}

void CDependent::Print (FILE *f)
{
  CSubsystem::Print (f);

  fprintf (f, "CDependent:\n");
  fprintf (f, "  Read tags:\n");
  fprintf (f, "    st8t=%d\tstat=%s\n", st8t, (stat ? "true" : "false"));
  fprintf (f, "    volt=%f\tload=%f\tfreq=%f\n", volt, load, freQ);
  fprintf (f, "    offV=%f\tmVlt=%f\n", offV, mVlt);
  fprintf (f, "  Realtime:\n");
  fprintf (f, "    volt=%f\tload=%f\tfreq=%f\n", voltage, current, frequency);
  fprintf (f, "    active=%s\tstate=%d\n", (active ? "true" : "false"), state);
  fprintf (f, "  Dependencies (%d):\n", dpnd.size());
}


//
// CAnnouncement
//

CAnnouncement::CAnnouncement (void)
{
  type = SUBSYSTEM_ANNOUNCEMENT;
  TagToString (type_string, type);
}


//
// CGenericMonitor
//

CGenericMonitor::CGenericMonitor (void)
{
  type = SUBSYSTEM_GENERIC_MONITOR;
  TagToString (type_string, type);

  memset (&mVal, 0, sizeof(SMessage));
  mode = MONITOR_LT;
  comp = 0;
}


int CGenericMonitor::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'mVal':
    // Value message
    ReadMessage (&mVal, stream);
    rc = TAG_READ;
    break;

  case '.LT.':
    // Monitor for less than the comparison value
    mode = MONITOR_LT;
    rc = TAG_READ;
    break;

  case '.GT.':
    // Monitor for greater than the comparison value
    mode = MONITOR_GT;
    rc = TAG_READ;
    break;

  case '.GE.':
    // Monitor for greater than or equal to the comparison value
    mode = MONITOR_GE;
    rc = TAG_READ;
    break;

  case '.LE.':
    // Monitor for less than or equal to the comparison value
    mode = MONITOR_LE;
    rc = TAG_READ;
    break;

  case 'comp':
    // Comparison value
    ReadFloat (&comp, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CGenericMonitor::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CGenericMonitor messages:
//
// GETDATA:
//  comp - Comparison value       REAL
//  mode - Comparison mode        INT
//  mVal - Poll message for comparison  VOID (SMessage*)
//
// SETDATA:
//  comp - Comparison value
//
EMessageResult CGenericMonitor::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'comp':
        msg->dataType = TYPE_REAL;
        msg->realData = comp;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'mode':
        msg->dataType = TYPE_INT;
        msg->intData = mode;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'mVal':
        msg->dataType = TYPE_VOID;
        msg->voidData = (void*)(&mVal);
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;

    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'comp':
        if (msg->dataType == TYPE_REAL) {
          comp = msg->realData;
          msg->result = rc = MSG_PROCESSED;
        }
        break;
      }
      break;

    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CDependent::ReceiveMessage (msg);
    }
  }

  return rc;
}


void CGenericMonitor::TimeSlice (float dT)
{
  // Initialized state to 'off' in case poll message is not processed
  stat = false;

  // Get value for comparison
  float poll = 0.0f;
  mVal.id = MSG_GETDATA;
  SendMessage (&mVal);
  if (mVal.result == MSG_PROCESSED) {
    // Poll message was successfully processed
    switch (mVal.dataType) {
    case TYPE_INT:
      poll = (float)mVal.intData;
      break;
    case TYPE_REAL:
      poll = mVal.realData;
      break;
    default:
      // Invalid poll data type
      gtfo ("CGenericMonitor : Invalid data type from polled subsystem : %d",
        mVal.dataType);
    }

    // Set state based on comparison
    switch (mode) {
    case MONITOR_LT:
      stat = (poll < comp);
      break;

    case MONITOR_GT:
      stat = (poll > comp);
      break;

    case MONITOR_LE:
      stat = (poll <= comp);
      break;

    case MONITOR_GE:
      stat = (poll >= comp);
      break;
    }
  }
}


//
// CGenericIndicator
//

CGenericIndicator::CGenericIndicator (void)
{
  type = SUBSYSTEM_GENERIC_INDICATOR;
  TagToString (type_string, type);

  memset (&mVal, 0, sizeof(SMessage));
  alia = 0;
}


int CGenericIndicator::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'mVal':
    // Value message
    ReadMessage (&mVal, stream);
    rc = TAG_READ;
    break;

  case 'alia':
    // Alias value datatag
    ReadTag (&alia, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CGenericIndicator::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CGenericIndicator::ReadFinished (void)
{
  // Fill in common fields of monitor message
  mVal.id = MSG_GETDATA;

  CDependent::ReadFinished ();
}


EMessageResult CGenericIndicator::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      // Get indication value from monitored subsystem
      SendMessage (&mVal);
      switch (mVal.dataType) {
      case TYPE_INT:
        msg->dataType = TYPE_INT;
        msg->intData = mVal.intData;
        rc = MSG_PROCESSED;
        break;
      case TYPE_REAL:
        msg->dataType = TYPE_REAL;
        msg->realData = mVal.realData;
        rc = MSG_PROCESSED;
        break;
      default:
        // Invalid message data type
        gtfo ("CGenericIndicator : Invalid data type from monitored subsystem : %d", msg->dataType);
      }
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CDependent::ReceiveMessage (msg);
    }
  }

  return rc;
}


//
// CHistory
//

CHistory::CHistory (void)
{
  TypeIs (SUBSYSTEM_HISTORY);
}


//
// CPneumaticPump
//
CPneumaticPump::CPneumaticPump (void)
{
  TypeIs (SUBSYSTEM_PNEUMATIC_PUMP);

  suct = 0.0;
};


int CPneumaticPump::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'suct':
    // Suction value
    ReadFloat (&suct, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CPneumaticPump::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


EMessageResult CPneumaticPump::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'inop':
        msg->dataType = TYPE_INT;
        msg->intData = (stat == 0);
        msg->result = rc = MSG_PROCESSED;
        break;
      }
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CDependent::ReceiveMessage (msg);
    }
  }

  return rc;
}


//
// CEmergencyLocator
//
CEmergencyLocator::CEmergencyLocator (void)
{
  TypeIs (SUBSYSTEM_EMERGENCY_LOCATOR);

  gLim = 1.0;
}

int CEmergencyLocator::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'gLim':
    // G-load activation
    ReadFloat (&gLim, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CEmergencyLocator::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CExteriorLight
//
CExteriorLight::CExteriorLight (void)
{
  TypeIs (SUBSYSTEM_EXTERIOR_LIGHT);

  LMid = 0;
}


int CExteriorLight::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'LMid':
    // Light model ID (part name in external model that displays this light)
    ReadTag (&LMid, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CExteriorLight::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CPitotStaticSwitch
//
CPitotStaticSwitch::CPitotStaticSwitch (void)
{
  TypeIs (SUBSYSTEM_PITOT_STATIC_SWITCH);

  nSystems = 0;
  system = NULL;
}

CPitotStaticSwitch::~CPitotStaticSwitch (void)
{
  delete[] system;
}

int CPitotStaticSwitch::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'aray':
    {
      // Array of systems
      ReadInt (&nSystems, stream);
      system = new int[nSystems];
      for (int i=0; i<nSystems; i++) {
        ReadInt (&system[i], stream);
      }
    }
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CPitotStaticSwitch::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CPitotHeatSwitch
//
CPitotHeatSwitch::CPitotHeatSwitch (void)
{
  TypeIs (SUBSYSTEM_PITOT_HEAT_SWITCH);
}


//
// CStaticSourceSwitch
//
CStaticSourceSwitch::CStaticSourceSwitch (void)
{
  TypeIs (SUBSYSTEM_STATIC_SOURCE_SWITCH);

  // Special case if the unique ID is not specified
  unId = SUBSYSTEM_STATIC_SOURCE_SWITCH;
  TagToString (unId_string, unId);

  // Default hardware type for this subsystem is SWITCH
  hwId = HW_SWITCH;
}


//
// CAnnunciatorLight
//
CAnnunciatorLight::CAnnunciatorLight (void)
{
  TypeIs (SUBSYSTEM_ANNUNCIATOR_LIGHT);

  blnk = 0;
  blpp = 0;
}

int CAnnunciatorLight::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'blnk':
    // Blink period (sec);
    ReadFloat (&blnk, stream);
    rc = TAG_READ;
    break;

  case 'blpp':
    // Blink period
    ReadFloat (&blnk, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CAnnunciatorLight::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CStallWarning
//
CStallWarning::CStallWarning (void)
{
  TypeIs (SUBSYSTEM_STALL_WARNING);

  strcpy (wing, "");
}


int CStallWarning::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'wing':
    // Wing section name
    ReadString (wing, 64, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CAnnunciatorLight::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CLightSettingState
//
CLightSettingState::CLightSettingState (void)
{
  TypeIs (SUBSYSTEM_LIGHT_SETTING_STATE);

  levl = 1.0f;
}


int CLightSettingState::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'levl':
    // Default light level
    ReadFloat (&levl, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CLightSettingState::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CSwitchSet
//
CSwitchSet::CSwitchSet (void)
{
  TypeIs (SUBSYSTEM_SWITCH_SET);

  sync = false;
  LAND = false;
  TAXI = false;
  NAVI = false;
}

CSwitchSet::~CSwitchSet (void)
{
}

int CSwitchSet::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;
  SMessage msg;
  memset (&msg, 0, sizeof(SMessage));

  switch (tag) {
  case 'smsg':
    {
      // Switch message
      ReadMessage (&msg, stream);
      smsg.push_back (msg);
    }
    rc = TAG_READ;
    break;

  case 'sync':
    sync = true;
    rc = TAG_READ;
    break;

  case 'LAND':
    LAND = true;
    rc = TAG_READ;
    break;

  case 'TAXI':
    TAXI = true;
    rc = TAG_READ;
    break;

  case 'NAVI':
    NAVI = true;
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CSwitchSet::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CRotaryIgnitionSwitch
//
CRotaryIgnitionSwitch::CRotaryIgnitionSwitch (void)
{
  TypeIs (SUBSYSTEM_ROTARY_IGNITION_SWITCH);
}


//
// CBattery
//
CBattery::CBattery (void)
{
  TypeIs (SUBSYSTEM_BATTERY);
  hwId = HW_BATTERY;

  life = 0;
}


int CBattery::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'life':
    // Battery capacity (amp-hours);
    ReadFloat (&life, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CBattery::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

//
// CAlternator
//
CAlternator::CAlternator (void)
{
  TypeIs (SUBSYSTEM_ALTERNATOR);
  hwId = HW_ALTERNATOR;

  mxld = 0;
  loRg = 0;
}


int CAlternator::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'mxld':
    // Maximum load (amps)
    ReadFloat (&mxld, stream);
    rc = TAG_READ;
    break;

  case 'loRg':
    // Minimum RPM regulatable
    ReadFloat (&loRg, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CAlternator::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

EMessageResult CAlternator::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (rc == MSG_IGNORED) {
    // See if the message can be processed by the parent class
    rc = CDependent::ReceiveMessage (msg);
  }

  return rc;
}



// *
// * Gauge subsystems
// *

//
// CPitotStaticSubsystem
//
CPitotStaticSubsystem::CPitotStaticSubsystem (void)
{
  TypeIs (SUBSYSTEM_PITOT_STATIC_SUBS);

  gNum = 0;
}


int CPitotStaticSubsystem::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'gNum':
    // Port group number
    ReadInt (&gNum, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CPitotStaticSubsystem::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}




//
// CAltimeter
//
CAltimeter::CAltimeter (void)
{
  TypeIs (SUBSYSTEM_ALTIMETER);
}


int CAltimeter::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CPitotStaticSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CAltimeter::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


EMessageResult CAltimeter::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'alti':
        msg->dataType = TYPE_REAL;
        msg->realData = indn;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;

    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'alti':
        if (msg->dataType == TYPE_REAL) {
          indnTarget = msg->realData;
          msg->result = rc = MSG_PROCESSED;
        }
        break;
      }
      break;
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CPitotStaticSubsystem::ReceiveMessage (msg);
    }
  }

  return rc;
}



//
// CVerticalSpeedIndicator
//
CVerticalSpeedIndicator::CVerticalSpeedIndicator (void)
{
  char *mark1 = new char[32];
  strcpy (mark1, "vsiconst start");
  TypeIs (SUBSYSTEM_VERTICAL_SPEED);
  char *mark2 = new char[32];
  strcpy (mark2, "vsiconst end");
}


int CVerticalSpeedIndicator::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CPitotStaticSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CVerticalSpeedIndicator::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


EMessageResult CVerticalSpeedIndicator::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'vsi_':
        msg->dataType = TYPE_REAL;
        msg->realData = indn;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;

    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'vsi_':
        if (msg->dataType == TYPE_REAL) {
          indnTarget = msg->realData;
          msg->result = rc = MSG_PROCESSED;
        }
        break;
      }
      break;
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CPitotStaticSubsystem::ReceiveMessage (msg);
    }
  }

  return rc;
}



//
// CAirspeedIndicator
//
CAirspeedIndicator::CAirspeedIndicator (void)
{
  TypeIs (SUBSYSTEM_AIRSPEED);
}


int CAirspeedIndicator::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CPitotStaticSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CAirspeedIndicator::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


EMessageResult CAirspeedIndicator::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'sped':
        msg->dataType = TYPE_REAL;
        msg->realData = indn;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;

    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'sped':
        if (msg->dataType == TYPE_REAL) {
          indnTarget = msg->realData;
          msg->result = rc = MSG_PROCESSED;
        }
        break;
      }
      break;
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CPitotStaticSubsystem::ReceiveMessage (msg);
    }
  }

  return rc;
}


//
// CPneumaticSubsystem
//
CPneumaticSubsystem::CPneumaticSubsystem (void)
{
  TypeIs (SUBSYSTEM_PNEUMATIC);
}

CPneumaticSubsystem::~CPneumaticSubsystem (void)
{
}

int CPneumaticSubsystem::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;
  SMessage msg;
  memset (&msg, 0, sizeof(SMessage));

  switch (tag) {
  case 'mPmp':
    {
      // Pneumatic pump message
      ReadMessage (&msg, stream);
      mPmp.push_back (msg);
    }
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CPitotStaticSubsystem::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CAttitudeIndicator
//
CAttitudeIndicator::CAttitudeIndicator (void)
{
  TypeIs (SUBSYSTEM_ATTITUDE);

  prat = 1.0;
}


int CAttitudeIndicator::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'prat':
    // Precession rate
    ReadFloat (&prat, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CPneumaticSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CAttitudeIndicator::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}



EMessageResult CAttitudeIndicator::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'atti':
        msg->dataType = TYPE_REAL;
        msg->realData = indn;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;

    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'atti':
        if (msg->dataType == TYPE_REAL) {
          indnTarget = msg->realData;
          msg->result = rc = MSG_PROCESSED;
        }
        break;
      }
      break;
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CPneumaticSubsystem::ReceiveMessage (msg);
    }
  }

  return rc;
}

//
// CDirectionalGyro
//
CDirectionalGyro::CDirectionalGyro (void)
{
  TypeIs (SUBSYSTEM_DIRECTIONAL_GYRO);

  step = 1.0f;
}


int CDirectionalGyro::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'step':
    // Autopilot bug step size
    ReadFloat (&step, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CPneumaticSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CDirectionalGyro::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


EMessageResult CDirectionalGyro::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'yaw_':
        msg->dataType = TYPE_REAL;
        msg->realData = indn;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;

    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'yaw_':
        if (msg->dataType == TYPE_REAL) {
          indnTarget = msg->realData;
          msg->result = rc = MSG_PROCESSED;
        }
        break;
      }
      break;
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CPneumaticSubsystem::ReceiveMessage (msg);
    }
  }

  return rc;
}


//
// CVacuumIndicator
//
CVacuumIndicator::CVacuumIndicator (void)
{
  TypeIs (SUBSYSTEM_VACUUM_INDICATOR);
}


int CVacuumIndicator::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CPneumaticSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CVacuumIndicator::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CTurnCoordinator
//
CTurnCoordinator::CTurnCoordinator (void)
{
  TypeIs (SUBSYSTEM_TURN_COORDINATOR);

  tilt = 0;
}


int CTurnCoordinator::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'tilt':
    // Tilt ??
    ReadFloat (&tilt, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CTurnCoordinator::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CMagneticCompass
//
CMagneticCompass::CMagneticCompass (void)
{
  TypeIs (SUBSYSTEM_MAGNETIC_COMPASS);
}


//
// CNavigation
//
CNavigation::CNavigation (void)
{
  TypeIs (SUBSYSTEM_NAVIGATION);
}


//
// CDigitalClockOAT
//
CDigitalClockOAT::CDigitalClockOAT (void)
{
  TypeIs (SUBSYSTEM_DIGITAL_CLOCK_OAT);
}


//
// CBKKAP140Panel
//
CBKKAP140Panel::CBKKAP140Panel (void)
{
  TypeIs (SUBSYSTEM_KAP140_PANEL);

  memset (&gyro, 0, sizeof(SMessage));
  memset (&nav1, 0, sizeof(SMessage));
}

int CBKKAP140Panel::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'atop':
    // Autopilot specification
    SkipObject (stream);
    rc = TAG_READ;
    break;

  case 'mDG_':
    // Directional gyro (heading) message
    ReadMessage (&gyro, stream);
    rc = TAG_READ;
    break;

  case 'nav1':
    // NAV radio message
    ReadMessage (&nav1, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CBKKAP140Radio::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CMarkerPanel
//
CMarkerPanel::CMarkerPanel (void)
{
  TypeIs (SUBSYSTEM_MARKER_PANEL);
}


//
// CAmmeter
//
CAmmeter::CAmmeter (void)
{
  TypeIs (SUBSYSTEM_AMMETER);

  chrg = false;
  memset (&mMon, 0, sizeof(SMessage));
}


int CAmmeter::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'chrg':
    // Charge meter
    chrg = true;
    rc = TAG_READ;
    break;

  case 'mMon':
    // Monitor message
    ReadMessage (&mMon, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CAmmeter::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


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

//
// CEngineSubsystem
//
CEngineSubsystem::CEngineSubsystem (void)
{
  TypeIs (SUBSYSTEM_ENGINE_SUBSYSTEM);

  eNum = 1;
}


int CEngineSubsystem::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'eNum':
    // Engine number
    ReadUInt (&eNum, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CEngineSubsystem::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CTachometer
//
CTachometer::CTachometer (void)
{
  TypeIs (SUBSYSTEM_TACHOMETER);
  Alias ('indn', 'rpmn');
}


//
// COilTemperature
//
COilTemperature::COilTemperature (void)
{
  TypeIs (SUBSYSTEM_OIL_TEMPERATURE);
  Alias ('indn', 'oilT');
}


//
// COilPressure
//
COilPressure::COilPressure (void)
{
  TypeIs (SUBSYSTEM_OIL_PRESSURE);
  Alias ('indn', 'oilP');

  lowP = 0;
}


int COilPressure::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'lowP':
    // Low pressure threshold
    ReadFloat (&lowP, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CEngineSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("COilPressure::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CExhaustGasTemperature
//
CExhaustGasTemperature::CExhaustGasTemperature (void)
{
  TypeIs (SUBSYSTEM_EXHAUST_GAS_TEMPERATURE);
}


//
// CManifoldPressure
//
CManifoldPressure::CManifoldPressure (void)
{
  TypeIs (SUBSYSTEM_MANIFOLD_PRESSURE);
}


//
// CHobbsMeter
//
CHobbsMeter::CHobbsMeter (void)
{
  TypeIs (SUBSYSTEM_HOBBS_METER);
}


//
// CTachometerTimer
//
CTachometerTimer::CTachometerTimer (void)
{
  TypeIs (SUBSYSTEM_TACHOMETER_TIMER);
}


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

//
// CSteeringControl
//
CSteeringControl::CSteeringControl (void)
{
  TypeIs (SUBSYSTEM_STEERING_CONTROL);
}

//
// CBaseControl
//
CBaseControl::CBaseControl (void)
{
  TypeIs (SUBSYSTEM_BASE_CONTROL);

  scal = 1.0f;
  step = 0.01f;
  bend = 0.0f;
  posn = 0.0f;

  indn = 0.0f;
}

int CBaseControl::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'scal':
    // Scaling factor
    ReadFloat (&scal, stream);
    rc = TAG_READ;
    break;

  case 'step':
    // Control increment step
    ReadFloat (&step, stream);
    rc = TAG_READ;
    break;

  case 'bend':
    // Exponential
    ReadFloat (&bend, stream);
    rc = TAG_READ;
    break;

  case 'posn':
    // Default position
    ReadFloat (&posn, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CBaseControl::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// Increment the control by the step value
//
void CBaseControl::Incr (void)
{
  indn += step;

  DrawNoticeToUser ("Control increment", 1);
}


//
// Decrement the control by the step value
//
void CBaseControl::Decr (void)
{
  indn -= step;

  DrawNoticeToUser ("Control decrement", 1);
}


//
// CThrottleControl
//
CThrottleControl::CThrottleControl (void)
{
  TypeIs (SUBSYSTEM_THROTTLE_CONTROL);
  Alias ('indn', 'thro');
}


//
// CMixtureControl
//
CMixtureControl::CMixtureControl (void)
{
  TypeIs (SUBSYSTEM_MIXTURE_CONTROL);
  Alias ('indn', 'mixt');

  autoControl = false;
  injd = false;
  prmr = 1.0f;
  prff = 0.0f;
  plim = 0.0f;
}

int CMixtureControl::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'auto':
    // Control is capable of automatic control
    autoControl = true;
    rc = TAG_READ;
    break;

  case 'injd':
    // Engine is fuel injected (no carbeurator)
    injd = true;
    rc = TAG_READ;
    break;

  case 'prmr':
    // Priming rate
    ReadFloat (&prmr, stream);
    rc = TAG_READ;
    break;

  case 'prff':
    // Priming fuel flow (pph)
    ReadFloat (&prff, stream);
    rc = TAG_READ;
    break;

  case 'plim':
    // Priming pump limit
    ReadFloat (&plim, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CBaseControl::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CMixtureControl::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CFlapControl
//
CFlapControl::CFlapControl (void)
{
  TypeIs (SUBSYSTEM_FLAP_CONTROL);

  pos = NULL;
  speed = NULL;
}

CFlapControl::~CFlapControl (void)
{
  delete[] pos;
  delete[] speed;
}

int CFlapControl::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'flpP':
    {
      // Flap position array
      ReadInt (&nPos, stream);
      pos = new float[nPos];
      for (int i=0; i < nPos; i++) {
        ReadFloat (&pos[i], stream);
      }
    }
    rc = TAG_READ;
    break;

  case 'flpS':
    {
      // Flap speed array
      ReadInt (&nSpeed, stream);
      speed = new float[nSpeed];
      for (int i=0; i < nSpeed; i++) {
        ReadFloat (&speed[i], stream);
      }
    }
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CBaseControl::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFlapControl::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CElevatorControl
//
CElevatorControl::CElevatorControl (void)
{
  TypeIs (SUBSYSTEM_ELEVATOR_CONTROL);
}


//
// CAileronControl
//
CAileronControl::CAileronControl (void)
{
  TypeIs (SUBSYSTEM_AILERON_CONTROL);
}


//
// CRudderControl
//
CRudderControl::CRudderControl (void)
{
  TypeIs (SUBSYSTEM_RUDDER_CONTROL);
}


//
// CElevatorTrimControl
//
CElevatorTrimControl::CElevatorTrimControl (void)
{
  TypeIs (SUBSYSTEM_ELEVATOR_TRIM_CONTROL);
}


//
// CAileronTrimControl
//
CAileronTrimControl::CAileronTrimControl (void)
{
  TypeIs (SUBSYSTEM_AILERON_TRIM_CONTROL);
}


//
// CRudderTrimControl
//
CRudderTrimControl::CRudderTrimControl (void)
{
  TypeIs (SUBSYSTEM_RUDDER_TRIM_CONTROL);
}


//
// CBrakeControl
//
CBrakeControl::CBrakeControl (void)
{
  TypeIs (SUBSYSTEM_BRAKE_CONTROL);
}


// *
// *  Radio subsystems
// *

//
// CRadio
//
CRadio::CRadio (void)
{
  TypeIs (SUBSYSTEM_RADIO);

  tune = lfrq = hfrq = sinc = 0;
  test = false;
}

int CRadio::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'tune':
    ReadFloat (&tune, stream);
    rc = TAG_READ;
    break;
  case 'lowf':
    ReadFloat (&lfrq, stream);
    rc = TAG_READ;
    break;
  case 'high':
    ReadFloat (&hfrq, stream);
    rc = TAG_READ;
    break;
  case 'seek':
    ReadFloat (&sinc, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CRadio::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

EMessageResult CRadio::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'tune':
        msg->dataType = TYPE_REAL;
        msg->realData = tune;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'hfrq':
        msg->dataType = TYPE_REAL;
        msg->realData = hfrq;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'lfrq':
        msg->dataType = TYPE_REAL;
        msg->realData = lfrq;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'sinc':
        msg->dataType = TYPE_REAL;
        msg->realData = sinc;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'test':
        msg->dataType = TYPE_INT;
        msg->realData = test ? 1 : 0;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;

    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'tune':
        tune = msg->realData;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'hfrq':
        hfrq = msg->realData;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'lfrq':
        lfrq = msg->realData;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'sinc':
        sinc = msg->realData;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'test':
        test = true;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CDependent::ReceiveMessage (msg);
    }
  }

  return rc;
}


//
// CNavRadio
//
CNavRadio::CNavRadio (void)
{
  TypeIs (SUBSYSTEM_NAV_RADIO);

  tune = 108.000;
  lfrq = 108.000;
  hfrq = 117.950;
  sinc =   0.050;
  test = false;

  stby = 108.000;

  navaidList = NULL;
  navaidTimer = 0;
  navaidTuned = NULL;
  navaidFilter = NAVAID_TYPE_VOR;

  // Initialize exponential tracking for navaid pointer
  navdTarget = 0;
  navd = 0;
  navdTimK = 0.5f;
  navdRatK = 0.5f;
}

CNavRadio::~CNavRadio (void)
{
  if (navaidList != NULL) {
    FreeNavaid (navaidList);
  }
}

int CNavRadio::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'stby':
    ReadFloat (&stby, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CRadio::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CNavRadio::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

EMessageResult CNavRadio::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'stby':
        msg->dataType = TYPE_REAL;
        msg->realData = stby;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '50Kz':
        msg->dataType = TYPE_INT;
        msg->intData = (sinc == 0.050f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case '25Kz':
        msg->dataType = TYPE_INT;
        msg->intData = (sinc == 0.025f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'navd':
        msg->dataType = TYPE_REAL;
        msg->realData = navd;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;

    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'stby':
        stby = msg->realData;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '50Kz':
        // Set step increment to 50 KHz
        sinc = 0.050f;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '25Kz':
        // Set step increment to 25 KHz
        sinc = 0.025f;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CRadio::ReceiveMessage (msg);
    }
  }

  return rc;
}

void CNavRadio::RescanNavaids (void)
{
  if (navaidList != NULL) {
    int count = 0;
    SNavaid *next = navaidList;
    while (next != NULL) {
      count++;
      next = next->next;
    }
    FreeNavaid (navaidList);
    navaidList = NULL;
  }
  GetLocalNavaids (&navaidList);

  // Search for tuned navaid
  navaidTuned = NULL;
  SNavaid *next = navaidList;
  while (next != NULL) {
    if ((next->freq == tune) && (next->type & navaidFilter)) {
      // Got a match
      navaidTuned = next;
      break;
    }
    next = next->next;
  }
}

void CNavRadio::TimeSlice (float dT)
{
  // Call parent TimeSlice method
  CRadio::TimeSlice (dT);

  if (active) {
    // Get list of local navaids periodically
    navaidTimer += dT;
    if (navaidTimer > 1.0f) {
      navaidTimer -= 1.0f;
      RescanNavaids ();
    }

    // Find tuned navaid
    if (navaidTuned != NULL) {
      SPosition pos = globals->sit->user->GetPosition();
      SVector v = GreatCirclePolar(&pos, &(navaidTuned->pos));
      navdTarget = Wrap360(v.h);

//      char debug[80];
//      sprintf (debug, "hdg=%f range=%f", v.h, FeetToNm(v.r));
//      DrawNoticeToUser (debug, 1);

    } else {
      // No navaid tuned, set pointer to 0
      navdTarget = 0;
    }
  } else {
    // Set navaid pointer to zero
    navdTarget = 0;
  }

  // Update navaid pointer to track target
  float delta = Wrap180(navdTarget - navd);
  // Exponential response
//  navd += delta * (1.0f - exp(-dT / navdTimK));
  // Linear response
  navd = Wrap360(navd + (delta * (dT / navdRatK)));
}


//
// CRnavRadio
//
CRnavRadio::CRnavRadio (void)
{
  TypeIs (SUBSYSTEM_RNAV_RADIO);
}


//
// CCommRadio
//
CCommRadio::CCommRadio (void)
{
  TypeIs (SUBSYSTEM_COMM_RADIO);

  tune = 118.000;
  lfrq = 118.000;
  hfrq = 137.975;
  sinc =   0.025;

  stby = 118.000;
}


//
// CRadio
//
CHFCommRadio::CHFCommRadio (void)
{
  TypeIs (SUBSYSTEM_HF_COMM_RADIO);
}


//
// CADFRadio
//
CADFRadio::CADFRadio (void)
{
  TypeIs (SUBSYSTEM_ADF_RADIO);

  // Initialize CNavRadio data
  tune = 200.0f;
  lfrq = 200.0f;
  hfrq = 2000.0f;
  sinc = 1.0f;
  test = false;

  stby = 200.0f;
  navd = 0;

  // Initialize ADF specific data
  adf = true;
  flt = true;
  bfo = frq = et = etst = false;
  ftime = 0;
  etime = 0;
  tone = false;
  volu = 1.0;

  navaidFilter = NAVAID_TYPE_NDB;
}

int CADFRadio::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'adf_':
    adf = true;
    rc = TAG_READ;
    break;
  case 'bfo_':
    bfo = true;
    rc = TAG_READ;
    break;
  case 'flt':
    flt = true;
    rc = TAG_READ;
    break;
  case 'et__':
    et = true;
    rc = TAG_READ;
    break;
  case 'etst':
    etst = true;
    rc = TAG_READ;
    break;
  case 'ftim':
    {
      int temp;
      ReadInt (&temp, stream);
      ftime = (float)temp;
      rc = TAG_READ;
    }
    break;
  case 'etim':
    {
      int temp;
      ReadInt (&temp, stream);
      etime = (float)temp;
      rc = TAG_READ;
    }
    rc = TAG_READ;
    break;
  case 'tone':
    tone = true;
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CNavRadio::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CADFRadio::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CADFRadio::ChangeADFFrequency (float &freq, int digit, int change)
{
  // Bounds check on digit to change
  if ((digit < 1) || (digit > 4)) return;

  // Convert frequency to integer
  int iFreq = (int)(floorf (freq + 0.5));

  // Subtract value that is being changed
  static const int pow10[4] = {1000, 100, 10, 1};
  int pow = pow10[digit-1];

  // Subtract value being changed out of frequency, adjust and add back in
  int value = (iFreq / pow) % 10;
  iFreq -= value * pow;
  value = (value + change);
  if (value < 0) value += 10;
  value %= 10;
  iFreq += value * pow;

  // Range check against valid ADF HF frequency band 200 - 1799 KHz
  if (iFreq < 200) iFreq = 200;
  if (iFreq > 1799) iFreq = 1799;

  // Convert back to float frequency
  freq = (float)iFreq;
}

EMessageResult CADFRadio::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'volu':
        // Set volume
        volu = msg->realData;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'ad1+':
        // Increment active frequency digit 1
        ChangeADFFrequency (tune, 1, 1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'ad1-':
        // Decrement active frequency digit 1
        ChangeADFFrequency (tune, 1, -1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'ad2+':
        // Increment active frequency digit 2
        ChangeADFFrequency (tune, 2, 1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'ad2-':
        // Decrement active frequency digit 2
        ChangeADFFrequency (tune, 2, -1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'ad3+':
        // Increment active frequency digit 3
        ChangeADFFrequency (tune, 3, 1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'ad3-':
        // Decrement active frequency digit 3
        ChangeADFFrequency (tune, 3, -1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'ad4+':
        // Increment active frequency digit 4
        ChangeADFFrequency (tune, 4, 1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'ad4-':
        // Decrement active frequency digit 4
        ChangeADFFrequency (tune, 4, -1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'sd1+':
        // Increment standby frequency digit 1
        ChangeADFFrequency (stby, 1, 1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'sd1-':
        // Decrement standby frequency digit 1
        ChangeADFFrequency (stby, 1, -1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'sd2+':
        // Increment standby frequency digit 2
        ChangeADFFrequency (stby, 2, 1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'sd2-':
        // Decrement standby frequency digit 2
        ChangeADFFrequency (stby, 2, -1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'sd3+':
        // Increment standby frequency digit 3
        ChangeADFFrequency (stby, 3, 1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'sd3-':
        // Decrement standby frequency digit 3
        ChangeADFFrequency (stby, 3, -1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'sd4+':
        // Increment standby frequency digit 4
        ChangeADFFrequency (stby, 4, 1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'sd4-':
        // Decrement standby frequency digit 4
        ChangeADFFrequency (stby, 4, -1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'adf ':
        // Set ADF state
        adf = (msg->intData != 0);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'adf_':
        // ADF button press toggles ADF state
        adf = !adf;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'bfo ':
        // Set BFO state
        bfo = (msg->intData != 0);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'bfo_':
        // BFO button press toggles BFO state
        bfo = !bfo;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'freq':
        // FRQ button press
        if (frq) {
          // Transfer standby and active
          float temp = tune;
          tune = stby;
          stby = temp;
        } else {
          // Transition back to FRQ mode
          frq = true;
          fltStored = flt;
          etStored = et;
          flt = et = false;
        }
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'flt ':
        // Set FLT state
        flt = (msg->intData != 0);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'flt_':
        // FLT button press
        if (frq) {
          // FRQ mode was active; restore previous timer state
          flt = fltStored;
          et = etStored;
          frq = false;
        } else {
          // Toggle displayed timer
          if (flt) {
            flt = false;
            et = true;
          } else {
            flt = true;
            et = false;
          }
        }
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'rset':
        // RESET button press
        etime = 0;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'volu':
        // Volume
        msg->dataType = TYPE_REAL;
        msg->realData = volu;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'adf ':
      case 'iADF':
        // Get ADF flag
        msg->dataType = TYPE_INT;
        msg->intData = adf ? 1 : 0;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'bfo ':
      case 'iBFO':
        // Get BFO flag
        msg->dataType = TYPE_INT;
        msg->intData = bfo ? 1 : 0;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'frq ':
      case 'iFRQ':
        // Set FRQ flag
        msg->dataType = TYPE_INT;
        msg->intData = frq ? 1 : 0;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'flt ':
      case 'iFLT':
        // Set FLT flag
        msg->dataType = TYPE_INT;
        msg->intData = flt ? 1 : 0;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'iET_':
        // Set ET flag
        msg->dataType = TYPE_INT;
        msg->intData = et ? 1 : 0;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'ftim':
        // Return flight time
        msg->dataType = TYPE_INT;
        msg->intData = (int)(floorf(ftime));
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'etim':
        // Return elapsed time
        msg->dataType = TYPE_INT;
        msg->intData = (int)(floorf(etime));
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CNavRadio::ReceiveMessage (msg);
    }
  }

  return rc;
}

void CADFRadio::TimeSlice (float dT)
{
  // Call parent TimeSlice method
  CNavRadio::TimeSlice (dT);

  if (active) {
    // Update elapsed and flight timers, wrap around after 100 hours
    float wrap = 6000.0f;     // seconds in 100 hours
    ftime += dT;
    if (ftime >= wrap) ftime -= wrap;
    etime += dT;
    if (etime >= wrap) etime -= wrap;
  } else {
    // Radio is off, ensure timers are reset
    ftime = 0;
    etime = 0;
  }
}


//
// CBKKX155Radio
//
CBKKX155Radio::CBKKX155Radio (void)
{
  TypeIs (SUBSYSTEM_KX155_RADIO);

  // Initialize radio frequencies
  comA = 118.000;
  comS = 118.000;
  navA = 108.000;
  navS = 108.000;

  // Initialize OBS and navaid pointers
  obs = 0;
  navd = 0;

  navaidList = NULL;
  navaidTimer = 0;
  navaidTuned = NULL;

  // Initialize frequency step value
  comfractstep = .025;

  // Mode control
  comMode = COM_MODE_NORMAL;
  navMode = NAV_MODE_STANDBY;
}

CBKKX155Radio::~CBKKX155Radio (void)
{
  if (navaidList != NULL) {
    FreeNavaid (navaidList);
  }
}

static float StepComFreq (float freq, float step)
{
  // Convert frequency and step to MHz/KHz
  int freqMHz = (int)(floorf (freq));
  int freqKHz = (int)(floorf (fmodf (freq, 1.0f) * 1000 + 0.5));

  // Step may be negative, take into account with floating point functions
  int stepMHz, stepKHz;
  if (step > 0) {
    stepMHz = (int)(floorf (step));
    stepKHz = (int)(floorf (fmodf (step, 1.0f) * 1000 + 0.5));
  } else {
    stepMHz = (int)(ceilf (step));
    stepKHz = -(int)(floorf (fmodf (fabs(step), 1.0f) * 1000 + 0.5));
  }

  // Add step to MHz and wrap to standard COM frequency band
  freqMHz += stepMHz;
  if (freqMHz < 118) freqMHz += 19;
  if (freqMHz >= 137) freqMHz -= 19;

  // Add step to KHz
  freqKHz += stepKHz;
  if (freqKHz < 0) freqKHz += 1000;
  if (freqKHz >= 1000) freqKHz -= 1000;

  // Recombine new frequency into float for return value
  return (float)freqMHz + (float)freqKHz / 1000.0f;
}

static float StepNavFreq (float freq, float step)
{
  // Convert frequency and step to MHz/KHz
  int freqMHz = (int)(floorf (freq));
  int freqKHz = (int)(floorf (fmodf (freq, 1.0f) * 1000 + 0.5));

  // Step may be negative, take into account with floating point functions
  int stepMHz, stepKHz;
  if (step > 0) {
    stepMHz = (int)(floorf (step));
    stepKHz = (int)(floorf (fmodf (step, 1.0f) * 1000 + 0.5));
  } else {
    stepMHz = (int)(ceilf (step));
    stepKHz = -(int)(floorf (fmodf (fabs(step), 1.0f) * 1000 + 0.5));
  }

  // Add step to MHz and wrap to standard COM frequency band
  freqMHz += stepMHz;
  if (freqMHz < 108) freqMHz += 10;
  if (freqMHz >= 118) freqMHz -= 10;

  // Add step to KHz
  freqKHz += stepKHz;
  if (freqKHz < 0) freqKHz += 1000;
  if (freqKHz >= 1000) freqKHz -= 1000;

  // Recombine new frequency into float for return value
  return (float)freqMHz + (float)freqKHz / 1000.0f;
}

EMessageResult CBKKX155Radio::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'cmod':
        // COM mode
        msg->dataType = TYPE_INT;
        msg->intData = comMode;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'comA':
        msg->dataType = TYPE_REAL;
        msg->realData = comA;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'comS':
        msg->dataType = TYPE_REAL;
        msg->realData = comS;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'navA':
        msg->dataType = TYPE_REAL;
        msg->realData = navA;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'navS':
        msg->dataType = TYPE_REAL;
        msg->realData = navS;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'obs_':
        msg->dataType = TYPE_REAL;
        msg->realData = obs;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'navd':
        if (navaidTuned == NULL) {
          // No navaid tuned, set data type to VOID
          msg->dataType = TYPE_VOID;
        } else {
          msg->dataType = TYPE_REAL;
          msg->realData = navd;
        }
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;

    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'cmod':
        // COM mode
        switch (comMode) {
        case COM_MODE_NORMAL:
          comMode = COM_MODE_SELECT;
          break;
        case COM_MODE_SELECT:
        case COM_MODE_PROGRAM:
          comMode = COM_MODE_NORMAL;
          break;
        }
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'incr':
        // Increment OBS setting
        obs = Wrap360 (obs + 1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'decr':
        // Decrement OBS setting
        obs = Wrap360 (obs - 1);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'comA':
        // Set COM active frequency
        comA = msg->realData;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'comS':
        // Set COM standby frequency
        comS = msg->realData;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'navA':
        // Set NAV active frequency
        navA = msg->realData;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'navS':
        // Set NAV standby frequency
        navS = msg->realData;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '25Kz':
        // Set COM fractional frequency step to 25 KHz
        comfractstep = .025;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '50Kz':
        // Set COM fractional frequency step to 50 KHz
        comfractstep = .050;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'caw+':
        // Increment COM active frequency whole MHz
        comA = StepComFreq (comA, 1.0f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'caw-':
        // Decrement COM active frequency whole MHz
        comA = StepComFreq (comA, -1.0f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'caf+':
        // Increment COM active frequency fraction MHz
        comA = StepComFreq (comA, comfractstep);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'caf-':
        // Decrement COM active frequency fraction MHz
        comA = StepComFreq (comA, -comfractstep);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'naw+':
        // Increment NAV active frequency whole MHz
        navA = StepNavFreq (navA, 1.0f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'naw-':
        // Decrement NAV active frequency whole MHz
        navA = StepNavFreq (navA, -1.0f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'naf+':
        // Increment NAV active frequency fraction MHz
        navA = StepNavFreq (navA, 0.050f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'naf-':
        // Decrement NAV active frequency fraction MHz
        navA = StepNavFreq (navA, -0.050f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'csw+':
        // Increment COM standby frequency whole MHz
        comS = StepComFreq (comS, 1.0f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'csw-':
        // Decrement COM standby frequency whole MHz
        comS = StepComFreq (comS, -1.0f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'csf+':
        // Increment COM standby frequency fraction MHz
        comS = StepComFreq (comS, comfractstep);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'csf-':
        // Decrement COM standby frequency fraction MHz
        comS = StepComFreq (comS, -comfractstep);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'nsw+':
        // Increment NAV standby frequency whole MHz
        navS = StepNavFreq (navS, 1.0f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'nsw-':
        // Decrement NAV standby frequency whole MHz
        navS = StepNavFreq (navS, -1.0f);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'nsf+':
        // Increment NAV standby frequency fraction MHz
        navS = StepNavFreq (navS, 0.050);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'nsf-':
        // Decrement NAV standby frequency fraction MHz
        navS = StepNavFreq (navS, -0.050);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'obs_':
        // Sets OBS value
        switch (msg->dataType) {
        case TYPE_REAL:
          // Set OBS to the supplied float value
          obs = msg->realData;
          msg->result = rc = MSG_PROCESSED;
          break;
        case TYPE_INT:
          // Set OBS to the supplied integer value
          obs = (float)(msg->intData);
          msg->result = rc = MSG_PROCESSED;
          break;
        default:
          // Invalid message data type
          gtfo ("CBKKX155Radio : Invalid data type for datatag 'obs_' : %d",
            msg->dataType);
        }
        break;
      }
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CRadio::ReceiveMessage (msg);
    }
  }

  return rc;
}

void CBKKX155Radio::RescanNavaids (void)
{
  if (navaidList != NULL) {
    FreeNavaid (navaidList);
    navaidList = NULL;
  }
  GetLocalNavaids (&navaidList);

  // Search for tuned navaid
  navaidTuned = NULL;
  SNavaid *next = navaidList;
  while (next != NULL) {
    if ((next->freq == navA) && (next->type & NAVAID_TYPE_VOR)) {
      // Got a match
      navaidTuned = next;
      break;
    }
    next = next->next;
  }
}

void CBKKX155Radio::TimeSlice (float dT)
{
  // Call parent TimeSlice method
  CRadio::TimeSlice (dT);

  if (active) {
    // Get list of local navaids periodically
    navaidTimer += dT;
    if (navaidTimer > 1.0f) {
      navaidTimer -= 1.0f;
      RescanNavaids ();
    }

    // Find tuned navaid
    if (navaidTuned != NULL) {
      SPosition pos = globals->sit->user->GetPosition();
      SVector v = GreatCirclePolar(&pos, &(navaidTuned->pos));
      navd = Wrap360(v.h);

//      char debug[80];
//      sprintf (debug, "hdg=%f range=%f", v.h, FeetToNm(v.r));
//      DrawNoticeToUser (debug, 1);

    } else {
      // No navaid tuned, set pointer to 0
      navd = 0;
    }
  } else {
    // Set navaid pointer to zero
    navd = 0;
  }
}


//
// CTransponderRadio
//
CTransponderRadio::CTransponderRadio (void)
{
  TypeIs (SUBSYSTEM_TRANSPONDER_RADIO);

  mode = XPDR_STANDBY;
  smod = XPDR_SWITCH_STANDBY;
  prevActive = false;
  reply = false;
  replyTimer = 0;

  code = 1200;

  strcpy (airc, "");
  lspd = uspd = 0;
  memset (&mAlt, 0, sizeof(SMessage));
}

int CTransponderRadio::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'mode':
    {
      int m = XPDR_OFF;
      ReadInt (&m, stream);
      mode = (ETransponderMode) m;
    }
    rc = TAG_READ;
    break;
  case 'smod':
    {
      int m = XPDR_SWITCH_OFF;
      ReadInt (&m, stream);
      smod = (ETransponderSwitchMode) m;
    }
    rc = TAG_READ;
    break;
  case 'airc':
    ReadString (airc, 16, stream);
    rc = TAG_READ;
    break;
  case 'lspd':
    // Lower airspeed limit
    ReadInt (&lspd, stream);
    rc = TAG_READ;
    break;
  case 'uspd':
    // Upper airspeed limit
    ReadInt (&uspd, stream);
    rc = TAG_READ;
    break;
  case 'mAlt':
    // Altitude message
    ReadMessage (&mAlt, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CRadio::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CTransponderRadio::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


EMessageResult CTransponderRadio::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'i11+':
        // Increment transponder code digit 1
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'i11-':
        // Decrement transponder code digit 1
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'i12+':
        // Increment transponder code digit 2
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'i12-':
        // Decrement transponder code digit 2
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'i13+':
        // Increment transponder code digit 3
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'i13-':
        // Decrement transponder code digit 3
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'i14+':
        // Increment transponder code digit 4
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'i14-':
        // Decrement transponder code digit 4
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'idt_':
        // Ident button
        msg->result = rc = MSG_PROCESSED;
        reply = true;
        replyTimer = 0;
        break;
      case 'mods':
        // Mode switch
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'mode':
        // Operational mode
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'mod+':
        // Increment operational mode
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'mod-':
        // Decrement operational mode
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'tune':
        // Set active frequency
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'stby':
        // Set standby frequency
        msg->result = rc = MSG_PROCESSED;
        break;
      }
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'smod':
        // Mode switch state
        msg->dataType = TYPE_INT;
        msg->intData = smod;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'mode':
        // Get operational mode
        msg->dataType = TYPE_INT;
        msg->intData = mode;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'tune':
        // Get active transponder code
        msg->dataType = TYPE_INT;
        msg->intData = code;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'alti':
        // Get altitude
        msg->dataType = TYPE_INT;
        msg->intData = 0;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'on__':
        // Get On indicator status
        msg->dataType = TYPE_INT;
        msg->intData = (mode == XPDR_ON) || (mode == XPDR_TEST);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'sby_':
        // Get Standby indicator status
        msg->dataType = TYPE_INT;
        msg->intData = (mode == XPDR_STANDBY) || (mode == XPDR_TEST);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'rply':
        // Get Reply indicator status
        msg->dataType = TYPE_INT;
        msg->intData = reply || (mode == XPDR_TEST);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'alt_':
        // Get Altitude 
        msg->dataType = TYPE_INT;
        msg->intData = (mode == XPDR_ALT) || (mode == XPDR_TEST);
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'fl__':
        // Get Flight Level indicator status
        msg->dataType = TYPE_INT;
        msg->intData = (mode == XPDR_ALT) || (mode == XPDR_TEST);
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CRadio::ReceiveMessage (msg);
    }
  }

  return rc;
}

void CTransponderRadio::TimeSlice (float dT)
{
  // Call parent TimeSlice method
  CRadio::TimeSlice (dT);

  // Active status is dependent on operating mode not being OFF
  active &= (mode != XPDR_OFF);

  // Handle transitions from off, through startup modes
  if (active) {
    if (!prevActive) {
      // Power-on transition.  Initialize mode to A1, start timer
      mode = XPDR_STARTUPA1;
      startupTimer = 0;
      reply = true;
      replyTimer = 0;
    } else {
      // Not a power-on transition.  Check for transition through startup states
      startupTimer += dT;
      switch (mode) {
      case XPDR_STARTUPA1:
        // Check for transition to mode A2
        if (startupTimer > 4.0f) {
          mode = XPDR_STARTUPA2;
        }
        break;
      case XPDR_STARTUPA2:
        // Check for transition to selected switch mode
        if (startupTimer > 8.0f) {
          mode = (ETransponderMode) smod;
          reply = false;
        }
        break;

      default:
        // No timer-related operation required
        ;
      }
    }

    // Cancel reply timer after 18 seconds
    if (reply) {
      replyTimer += dT;
      if (replyTimer > 18.0f) {
        reply = false;
      }
    }
  }

  prevActive = active;
}


//
// CBKKT76Radio
//
CBKKT76Radio::CBKKT76Radio (void)
{
  TypeIs (SUBSYSTEM_KT76_RADIO);

  entryMode = false;
  strcpy (tempCode, "    ");
}


int CBKKT76Radio::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CTransponderRadio::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CBKKT76Radio::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

EMessageResult CBKKT76Radio::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    int digit = '0';
    bool digitPressed = false;

    switch (msg->id) {
    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case '___0':
        // Zero button
        digit = '0';
        digitPressed = true;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '___1':
        // One button
        digit = '1';
        digitPressed = true;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '___2':
        // Two button
        digit = '2';
        digitPressed = true;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '___3':
        // Three button
        digit = '3';
        digitPressed = true;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '___4':
        // Four button
        digit = '4';
        digitPressed = true;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '___5':
        // Five button
        digit = '5';
        digitPressed = true;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '___6':
        // Six button
        digit = '6';
        digitPressed = true;
        msg->result = rc = MSG_PROCESSED;
        break;
      case '___7':
        // Seven button
        digit = '7';
        digitPressed = true;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'clr_':
        // Clear button
        if (entryMode) {
          entryDigit--;
          tempCode[entryDigit] = ' ';
          if (entryDigit == 0) entryMode = false;
        }
        digitPressed = false;
        msg->result = rc = MSG_PROCESSED;
        break;
      case 'vfr_':
        // VFR button
        code = 1200;
        entryMode = false;
        digitPressed = false;
        msg->result = rc = MSG_PROCESSED;
        break;
      }

      if (digitPressed) {
        if (!entryMode) {
          // Transition to entry mode
          entryMode = true;
          entryDigit = 0;
          strcpy (tempCode, "    ");
        }

        // Check if entire code has been entered
        if (entryDigit == 3) {
          // Code entry complete
          int d0 = digit - '0';
          int d1 = tempCode[2] - '0';
          int d2 = tempCode[1] - '0';
          int d3 = tempCode[0] - '0';
          code = (d3 * 1000) + (d2 * 100) + (d1 * 10) + d0;
          entryMode = false;
        } else {
          // Store digit in temporary code storage
          tempCode[entryDigit] = digit;
          entryDigit++;
        }
        
        // Reset entry mode timer on every keypress
        entryTimer = 0;
      }
      break;

    case MSG_GETDATA:
      // Override getdata message for 'tune' to send code or partial code
      switch (msg->user.u.datatag) {
      case 'tune':
        if (entryMode) {
          // Return partially entered code as CHAR* data
          msg->dataType = TYPE_CHARPTR;
          msg->charPtrData = tempCode;
          msg->result = rc = MSG_PROCESSED;
        } else {
          // Return active transponder code as INT data
          msg->dataType = TYPE_INT;
          msg->intData = code;
          msg->result = rc = MSG_PROCESSED;
        }
        break;
      }
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CTransponderRadio::ReceiveMessage (msg);
    }
  }

  return rc;
}

void CBKKT76Radio::TimeSlice (float dT)
{
  // Call parent class timeslice
  CTransponderRadio::TimeSlice (dT);

  // Transition back to idle state if four seconds have elapsed without keypress
  if (entryMode) {
    entryTimer += dT;
    if (entryTimer >= 4.0f) {
      entryMode = false;
    }
  }
}

//
// CBKKLN89GPSRadio
//
CBKKLN89GPSRadio::CBKKLN89GPSRadio (void)
{
  TypeIs (SUBSYSTEM_KLN89_GPS_RADIO);

  memset (&mFMS, 0, sizeof(SMessage));
  memset (&mSpd, 0, sizeof(SMessage));
}


int CBKKLN89GPSRadio::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'mFMS':
    // FMS message
    ReadMessage (&mFMS, stream);
    rc = TAG_READ;
    break;

  case 'mSpd':
    // Airspeed message
    ReadMessage (&mSpd, stream);
    rc = TAG_READ;
    break;
  }

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CBKKLN89GPSRadio::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CBKKLN89GPSRadio::ReadFinished (void)
{
  // Fill in common message fields
  mFMS.id = MSG_GETDATA;
  mSpd.id = MSG_GETDATA;

  CDependent::ReadFinished ();
}


//
// CAudioPanelRadio
//
CAudioPanelRadio::CAudioPanelRadio (void)
{
  TypeIs (SUBSYSTEM_AUDIO_PANEL_RADIO);
}


//
// CBKKAP140Radio
//
CBKKAP140Radio::CBKKAP140Radio (void)
{
  TypeIs (SUBSYSTEM_KAP140_RADIO);
}


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

//
// CFuelSubsystem
//
CFuelSubsystem::CFuelSubsystem (void)
{
  TypeIs (SUBSYSTEM_FUEL_SUBSYSTEM);

  strcpy (name, "");
}

CFuelSubsystem::~CFuelSubsystem (void)
{
}

int CFuelSubsystem::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'name':
    // UI descriptive name
    ReadString (name, 64, stream);
    rc = TAG_READ;
    break;

  case 'pipe':
    // Fuel dependency tag
    {
      Tag t = 0;
      ReadTag (&t, stream);
      pipe.push_back (t);
    }
    rc = TAG_READ;
    break;
  }

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelSubsystem::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CFuelTap
//

CFuelTap::CFuelTap (void)
{
  TypeIs (SUBSYSTEM_FUEL_TAP);

  stff = 0;
  eNum = 1;
  gph = 0;
}


int CFuelTap::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'stFF':
    // Initial fuel flow (gph)
    ReadFloat (&stff, stream);
    rc = TAG_READ;
    break;

  case 'eNum':
    // Engine number
    ReadUInt (&eNum, stream);
    rc = TAG_READ;
    break;
  }

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CFuelSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelTap::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CFuelTap::ReadFinished (void)
{
  gph = stff;
}


EMessageResult CFuelTap::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'gph_':
        msg->dataType = TYPE_REAL;
        msg->realData = gph;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CFuelSubsystem::ReceiveMessage (msg);
    }
  }

  return rc;
}


//
// CFuelCell
//
CFuelCell::CFuelCell (void)
{
  TypeIs (SUBSYSTEM_FUEL_CELL);

  qty = 0;
  cap = 0;
  bPos.x = bPos.y = bPos.z = 0;
  basP = 0;
  gals = 0;
}

int CFuelCell::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'cap_':
    // Capacity (gallons)
    ReadFloat (&cap, stream);
    rc = TAG_READ;
    break;

  case 'qty_':
    // Default quantity
    ReadFloat (&qty, stream);
    rc = TAG_READ;
    break;

  case 'bPos':
    // Position relative to model center of gravity
    ReadVector (&bPos, stream);
    rc = TAG_READ;
    break;

  case 'basP':
    // Base pressure
    ReadFloat (&basP, stream);
    rc = TAG_READ;
    break;
  }

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CFuelSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelCell::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CFuelCell::ReadFinished (void)
{
  // Initialize fuel quantity to specified default
  gals = qty;

  CFuelSubsystem::ReadFinished ();
}

EMessageResult CFuelCell::ReceiveMessage (SMessage *msg)
{
  EMessageResult rc = MSG_IGNORED;

  if (MsgForMe (msg)) {
    switch (msg->id) {
    case MSG_GETDATA:
      switch (msg->user.u.datatag) {
      case 'gals':
      case 'fqty':
        // Return fuel quantity in gallons
        msg->dataType = TYPE_REAL;
        msg->realData = gals;
        msg->result = rc = MSG_PROCESSED;
        break;
      }
      break;

    case MSG_SETDATA:
      switch (msg->user.u.datatag) {
      case 'gals':
      case 'fqty':
        // Set fuel quantity in gallons
        if (msg->dataType == TYPE_REAL) {
          gals = msg->realData;
          msg->result = rc = MSG_PROCESSED;
        }
        break;
      }
      break;
    }

    if (rc == MSG_IGNORED) {
      // See if the message can be processed by the parent class
      rc = CFuelSubsystem::ReceiveMessage (msg);
    }
  }

  return rc;
}


//
// CFuelHeater
//

CFuelHeater::CFuelHeater (void)
{
  TypeIs (SUBSYSTEM_FUEL_HEATER);
}


int CFuelHeater::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CFuelSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelHeater::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CFuelMath
//

CFuelMath::CFuelMath (void)
{
  TypeIs (SUBSYSTEM_FUEL_MATH);
}


int CFuelMath::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CFuelSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelMath::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CFuelPump
//

CFuelPump::CFuelPump (void)
{
  TypeIs (SUBSYSTEM_FUEL_PUMP);

  setP = 0;
  pass = false;
}


int CFuelPump::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'setP':
    // Pump pressure
    ReadFloat (&setP, stream);
    rc = TAG_READ;
    break;

  case 'pass':
    // Passthrough allowed when system is off
    pass = true;
    rc = TAG_READ;
    break;
  }

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CFuelSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelPumper::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CFuelSource
//

CFuelSource::CFuelSource (void)
{
  TypeIs (SUBSYSTEM_FUEL_SOURCE);
}


int CFuelSource::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CFuelSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelSource::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CFuelTank
//

CFuelTank::CFuelTank (void)
{
  TypeIs (SUBSYSTEM_FUEL_TANK);
}


int CFuelTank::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CFuelSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelTank::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CEngineFuelPump
//

CEngineFuelPump::CEngineFuelPump (void)
{
  TypeIs (SUBSYSTEM_ENGINE_FUEL_PUMP);
}


int CEngineFuelPump::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CFuelSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CEngineFuelPump::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CFuelManagement
//

CFuelManagement::CFuelManagement (void)
{
  TypeIs (SUBSYSTEM_FUEL_MANAGEMENT);
}


int CFuelManagement::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CFuelSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CFuelMnagement::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


//
// CAPUFuelSource
//

CAPUFuelSource::CAPUFuelSource (void)
{
  TypeIs (SUBSYSTEM_APU_FUEL_SOURCE);
}


int CAPUFuelSource::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CFuelSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CAPUFuelSource::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}



// ***
// *** End of actively developed subsystems
// ***


/*



//
// COnGroundMonitor
//

COnGroundMonitor::COnGroundMonitor (void)
{
  type = SUBSYSTEM_ON_GROUND_MONITOR;
  TagToString (type_string, type);
}



//
// CAltitudeMonitor
//

CAltitudeMonitor::CAltitudeMonitor (void)
{
}


int CAltitudeMonitor::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CAltitudeMonitor::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CAltitudeMonitor::ReadFinished (void)
{

}


void CAltitudeMonitor::Write (SStream *stream)
{

}


//
// CSpeedMonitor
//

CSpeedMonitor::CSpeedMonitor (void)
{
}


int CSpeedMonitor::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CSpeedMonitor::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CSpeedMonitor::ReadFinished (void)
{

}


void CSpeedMonitor::Write (SStream *stream)
{

}


//
// CEngineStatus
//

CEngineStatus::CEngineStatus (void)
{
}


int CEngineStatus::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CEngineStatus::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CEngineStatus::ReadFinished (void)
{

}


void CEngineStatus::Write (SStream *stream)
{

}


//
// CTimeDelay
//

CTimeDelay::CTimeDelay (void)
{
}


int CTimeDelay::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CTimeDelay::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CTimeDelay::ReadFinished (void)
{

}


void CTimeDelay::Write (SStream *stream)
{

}


//
// CKeyedSystem
//

CKeyedSystem::CKeyedSystem (void)
{
}


int CKeyedSystem::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CKeyedSystem::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CKeyedSystem::ReadFinished (void)
{

}


void CKeyedSystem::Write (SStream *stream)
{

}


//
// CEngineSubsystem
//

CEngineSubsystem::CEngineSubsystem (void)
{
}

int CEngineSubsystem::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CEngineSubystem::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CEngineSubsystem::ReadFinished (void)
{

}

void CEngineSubsystem::Write (SStream *stream)
{

}


//
// CTachometerBase
//

CTachometerBase::CTachometerBase (void)
{
}

int CTachometerBase::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CTachometerBase::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CTachometerBase::ReadFinished (void)
{

}

void CTachometerBase::Write (SStream *stream)
{

}


//
// CTachometerV1
//

CTachometerV1::CTachometerV1 (void)
{
}


int CTachometerV1::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CTachometerV1::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CTachometerV1::ReadFinished (void)
{

}


void CTachometerV1::Write (SStream *stream)
{

}


//
// CEngineControl
//

CEngineControl::CEngineControl (void)
{
}

int CEngineControl::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CEngineControl::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CEngineControl::ReadFinished (void)
{

}

void CEngineControl::Write (SStream *stream)
{

}


//
// CThrottleControlV1
//

CThrottleControlV1::CThrottleControlV1 (void)
{
}


int CThrottleControlV1::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CThrottleControlV1::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CThrottleControlV1::ReadFinished (void)
{

}


void CThrottleControlV1::Write (SStream *stream)
{

}


//
// CMixtureControlBase
//

CMixtureControlBase::CMixtureControlBase (void)
{
}

int CMixtureControlBase::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CMixtureControlBase::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}

void CMixtureControlBase::ReadFinished (void)
{

}

void CMixtureControlBase::Write (SStream *stream)
{

}


//
// CMixtureControlV1
//

CMixtureControlV1::CMixtureControlV1 (void)
{
}


int CMixtureControlV1::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CMixtureControlV1::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CMixtureControlV1::ReadFinished (void)
{

}


void CMixtureControlV1::Write (SStream *stream)
{

}


//
// CPropellerControlV1
//

CPropellerControlV1::CPropellerControlV1 (void)
{
}


int CPropellerControlV1::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CPropellerControlV1::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CPropellerControlV1::ReadFinished (void)
{

}


void CPropellerControlV1::Write (SStream *stream)
{

}


//
// CPrimeControlV1
//

CPrimeControlV1::CPrimeControlV1 (void)
{
}


int CPrimeControlV1::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CSubsystem::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag could not be processed
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CPrimeControlV1::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CPrimeControlV1::ReadFinished (void)
{

}


void CPrimeControlV1::Write (SStream *stream)
{

}


*/


//
// CPitotStaticPort
//


CPitotStaticPort::CPitotStaticPort (void)
{
  // Initialize
  type = PORT_STATIC;
  bPos.x = 0;   bPos.y = 0;   bPos.z = 0;
  grup = 1;
  face = PORT_LEFT;
  inie = false;
  wont = false;
}

int CPitotStaticPort::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'type':
    {
      // Type of port, PITOT or STATIC
      char sType[64];
      ReadString (sType, 64, stream);
      if (stricmp (sType, "PITOT") == 0) {
        type = PORT_PITOT;
      } else if (stricmp (sType, "STATIC") == 0) {
        type = PORT_STATIC;
      }
      rc = TAG_READ;
    }
    break;

  case 'bPos':
    {
      // Port position relative to aircraft external model center
      ReadVector (&bPos, stream);
      rc = TAG_READ;
    }
    break;

  case 'grup':
    {
      // Group number
      ReadInt (&grup, stream);
      rc = TAG_READ;
    }
    break;

  case 'face':
    {
      // Which side of aircraft the port is on, LEFT or RIGHT
      char sFace[64];
      ReadString (sFace, 64, stream);
      if (stricmp (sFace, "LEFT") == 0) {
        face = PORT_LEFT;
      } else if (stricmp (sFace, "RIGHT") == 0) {
        face = PORT_RIGHT;
      }
      rc = TAG_READ;
    }
    break;

  case 'inie':
    // No arguments, if this tag is present then the port is interior
    inie = true;
    rc = TAG_READ;
    break;

  case 'wont':
    // No arguments, if this tag is present then the port will not ice
    wont = true;
    rc = TAG_READ;
    break;
  }

  // If tag has not been processed, pass it to the parent
  if (rc != TAG_READ) {
    // See if the tag can be processed by the parent class type
    rc = CDependent::Read (stream, tag);
  }

  if (rc != TAG_READ) {
    // Tag was not processed by this object, it is unrecognized
    char s[16];
    TagToString (s, tag);
    globals->logWarning->Write ("CPitotStaticPort::Read : Unrecognized tag <%s>", s);
  }

  return rc;
}


void CPitotStaticPort::ReadFinished (void)
{
  CDependent::ReadFinished ();
}


void CPitotStaticPort::Write (SStream *stream)
{

}

Documentation generated by