#include "math.h"
#include "powerAlloc.h"
#include "powerDM.h"
#include "MidWaterMonitor.h"

MidWaterMonitor::MidWaterMonitor(const char *name, MicroApp *app)
  : DmMonitor(name, app)
{
  // Up-cast MicroApp pointer to MidwaterApp pointer
  _midwaterApp = (MidWaterApp *) _app;

  _autoIndexState = FALSE;

  mwsledName = name;

  duplicateIbcSwitchEntry( &mwsledDcon240VSwitch, TOOLSLED_240V_SWITCH_REQ_DM,
                         TOOLSLED_240V_SWITCH_STATUS_DM, _dmUpdateSem,
                         name, "Mid Water Toolsled Dcon 240V Switch");
  //High Power Switches
  initIbcSwitchEntry( &ssPumpPowerSwitch,
                      _midwaterApp->sio32Interface->channel(),
                     SS_PUMP_POWER,     B240,           HOTEL,
                     HIGH_POWER_SWITCH, hpsBoardAddr[0],        0,
                     SS_PUMP_POWER_SWITCH_REQ_DM,
                     SS_PUMP_POWER_SWITCH_STATUS_DM,            _dmUpdateSem,
                     SS_PUMP_POWER_PWR_REQ_DM,
                     SS_PUMP_POWER_PWR_OK_DM,                   _powerReqSem,
                     name,      "Suction Sampler Pump Power Switch");


  initIbcSwitchEntry( &tungstenLampSwitch,
                      _midwaterApp->sio32Interface->channel(),
                     TUNGSTEN_LAMP_POWER,       B240,           TOOLS,
                     HIGH_POWER_SWITCH, hpsBoardAddr[1],        0,
                     TUNGSTEN_LAMP_SWITCH_REQ_DM,
                     TUNGSTEN_LAMP_SWITCH_STATUS_DM,            _dmUpdateSem,
                     TUNGSTEN_LAMP_PWR_REQ_DM,
                     TUNGSTEN_LAMP_PWR_OK_DM,                   _powerReqSem,
                     name,      "Tungsten Lamp Power Switch");

  //Low Power Switches

  //Low Power Switch 0
  initIbcSwitchEntry( &mwsledLps0EnableSwitch,
                     _midwaterApp->sio32Interface->channel(),
                     VICOR_STANDBY_POWER,       B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[0],
                     LPS_VICOR_ENABLE,
                     MWSLED_LPS0_12V_ENABLE_SWITCH_REQ_DM,
                     MWSLED_LPS0_12V_ENABLE_SWITCH_STATUS_DM,   _dmUpdateSem,
                     MWSLED_LPS0_12V_ENABLE_PWR_REQ_DM,
                     MWSLED_LPS0_12V_ENABLE_PWR_OK_DM,          _powerReqSem,
                     name,      "LPS 0 Enable");

  initIbcSwitchEntry( &indexSwitchExcite,
                     _midwaterApp->sio32Interface->channel(),
                     SS_INDEX_EXCITE_POWER,     B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[0],
                     SS_INDEX_EXCITE_CHAN,
                     SS_INDEX_EXCITE_SWITCH_REQ_DM,
                     SS_INDEX_EXCITE_SWITCH_STATUS_DM,  _dmUpdateSem,
                     SS_INDEX_EXCITE_PWR_REQ_DM,
                     SS_INDEX_EXCITE_PWR_OK_DM,         _powerReqSem,
                     name,      "SS Index Switch Excite");

  initIbcSwitchEntry( &swingArmPotExcite,
                     _midwaterApp->sio32Interface->channel(),
                     SA_POT_EXCITE_POWER,       B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[0],
                     SA_POT_EXCITE_CHAN,
                     SA_POT_EXCITE_SWITCH_REQ_DM,
                     SA_POT_EXCITE_SWITCH_STATUS_DM,    _dmUpdateSem,
                     SA_POT_EXCITE_PWR_REQ_DM,
                     SA_POT_EXCITE_PWR_OK_DM,           _powerReqSem,
                     name,      "Swing Arm Pot Excite");

  initIbcSwitchEntry( &currentMeterSwitch,
                     _midwaterApp->sio32Interface->channel(),
                     ACM_POWER,         B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[0],
                     ACM_SWITCH_CHAN,
                     ACM_SWITCH_REQ_DM,
                     ACM_SWITCH_STATUS_DM,      _dmUpdateSem,
                     ACM_PWR_REQ_DM,
                     ACM_PWR_OK_DM,             _powerReqSem,
                     name,      "Current Meter Power Switch");

 initIbcSwitchEntry( &spare12VLPSChannel0,
                     _midwaterApp->sio32Interface->channel(),
                     LPS_12V_SPARE_POWER,       B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[0],
                     SPARE_12V_LPS_SWITCH_CHAN,
                     LPS_12V_SPARE_SWITCH_REQ_DM,
                     LPS_12V_SPARE_SWITCH_STATUS_DM,    _dmUpdateSem,
                     LPS_12V_SPARE_PWR_REQ_DM,
                     LPS_12V_SPARE_PWR_OK_DM,           _powerReqSem,
                     name,      "Spare 12V Low Power Switch Channel");

  //Low Power Switch 1
  initIbcSwitchEntry( &mwsledLps1EnableSwitch,
                     _midwaterApp->sio32Interface->channel(),
                     VICOR_STANDBY_POWER,       B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[1],
                     LPS_VICOR_ENABLE,
                     MWSLED_LPS1_24V_ENABLE_SWITCH_REQ_DM,
                     MWSLED_LPS1_24V_ENABLE_SWITCH_STATUS_DM,   _dmUpdateSem,
                     MWSLED_LPS1_24V_ENABLE_PWR_REQ_DM,
                     MWSLED_LPS1_24V_ENABLE_PWR_OK_DM,          _powerReqSem,
                     name,      "LPS 1 Enable");

  initIbcSwitchEntry( &ssIndexFwdSwitch,
                     _midwaterApp->sio32Interface->channel(),
                     SS_INDEX_POWER,    B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[1],
                     SS_INDEX_FWD_SWITCH_CHAN,
                     SS_INDEX_FWD_SWITCH_REQ_DM,
                     SS_INDEX_FWD_SWITCH_STATUS_DM,     _dmUpdateSem,
                     SS_INDEX_FWD_PWR_REQ_DM,
                     SS_INDEX_FWD_PWR_OK_DM,            _powerReqSem,
                     name,      "SS Index Fwd Switch");

  initIbcSwitchEntry( &ssIndexRevSwitch,
                     _midwaterApp->sio32Interface->channel(),
                     SS_INDEX_POWER,    B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[1],
                     SS_INDEX_REV_SWITCH_CHAN,
                     SS_INDEX_REV_SWITCH_REQ_DM,
                     SS_INDEX_REV_SWITCH_STATUS_DM,     _dmUpdateSem,
                     SS_INDEX_REV_PWR_REQ_DM,
                     SS_INDEX_REV_PWR_OK_DM,            _powerReqSem,
                     name,      "SS Index Rev Switch");

  initIbcSwitchEntry( &cameraSwitch,
                     _midwaterApp->sio32Interface->channel(),
                     CAMERA_POWER,      B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[1],
                     CAMERA_SWITCH_CHAN,
                     CAMERA_SWITCH_REQ_DM,
                     CAMERA_SWITCH_STATUS_DM,   _dmUpdateSem,
                     CAMERA_PWR_REQ_DM,
                     CAMERA_PWR_OK_DM,          _powerReqSem,
                     name,      "Camera Power Switch");

  initIbcSwitchEntry( &spare24VLPSChannel0,
                     _midwaterApp->sio32Interface->channel(),
                     LPS_24V_SPARE_POWER,       B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[1],
                     SPARE_24V_LPS_SWITCH_CHAN,
                     LPS_24V_SPARE_SWITCH_REQ_DM,
                     LPS_24V_SPARE_SWITCH_STATUS_DM,    _dmUpdateSem,
                     LPS_24V_SPARE_PWR_REQ_DM,
                     LPS_24V_SPARE_PWR_OK_DM,           _powerReqSem,
                     name,      "Spare 24V Low Power Switch Channel");

  //Low Power Switch 2
  initIbcSwitchEntry( &mwsledLps2EnableSwitch,
                     _midwaterApp->sio32Interface->channel(),
                     VICOR_STANDBY_POWER,       B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[2],
                     LPS_VICOR_ENABLE,
                     MWSLED_LPS2_28V_ENABLE_SWITCH_REQ_DM,
                     MWSLED_LPS2_28V_ENABLE_SWITCH_STATUS_DM,   _dmUpdateSem,
                     MWSLED_LPS2_28V_ENABLE_PWR_REQ_DM,
                     MWSLED_LPS2_28V_ENABLE_PWR_OK_DM,          _powerReqSem,
                     name,      "LPS 2 Enable");

  initIbcSwitchEntry( &portSwingArmDeploy,
                     _midwaterApp->sio32Interface->channel(),
                     SWING_ARM_POWER,           B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[2],
                     PORT_SA_DEPLOY_CHAN,
                     PORT_SA_DEPLOY_SWITCH_REQ_DM,
                     PORT_SA_DEPLOY_SWITCH_STATUS_DM,           _dmUpdateSem,
                     PORT_SA_DEPLOY_PWR_REQ_DM,
                     PORT_SA_DEPLOY_PWR_OK_DM,          _powerReqSem,
                     name,      "Port Swing Arm Deploy Switch Channel");

  initIbcSwitchEntry( &portSwingArmStow,
                     _midwaterApp->sio32Interface->channel(),
                     SWING_ARM_POWER,           B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[2],
                     PORT_SA_STOW_CHAN,
                     PORT_SA_STOW_SWITCH_REQ_DM,
                     PORT_SA_STOW_SWITCH_STATUS_DM,             _dmUpdateSem,
                     PORT_SA_STOW_PWR_REQ_DM,
                     PORT_SA_STOW_PWR_OK_DM,            _powerReqSem,
                     name,      "Port Swing Arm Stow Switch Channel");

  initIbcSwitchEntry( &stbdSwingArmDeploy,
                     _midwaterApp->sio32Interface->channel(),
                     SWING_ARM_POWER,           B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[2],
                     STBD_SA_DEPLOY_CHAN,
                     STBD_SA_DEPLOY_SWITCH_REQ_DM,
                     STBD_SA_DEPLOY_SWITCH_STATUS_DM,           _dmUpdateSem,
                     STBD_SA_DEPLOY_PWR_REQ_DM,
                     STBD_SA_DEPLOY_PWR_OK_DM,          _powerReqSem,
                     name,      "Stbd Swing Arm Deploy Switch Channel");

  initIbcSwitchEntry( &stbdSwingArmStow,
                     _midwaterApp->sio32Interface->channel(),
                     SWING_ARM_POWER,           B48,            TOOLS,
                     LOW_POWER_SWITCH,  lpsBoardAddr[2],
                     STBD_SA_STOW_CHAN,
                     STBD_SA_STOW_SWITCH_REQ_DM,
                     STBD_SA_STOW_SWITCH_STATUS_DM,             _dmUpdateSem,
                     STBD_SA_STOW_PWR_REQ_DM,
                     STBD_SA_STOW_PWR_OK_DM,            _powerReqSem,
                     name,      "Stbd Swing Arm Stow Switch Channel");


  initIbcSwitchEntry( &saMotorPowerSwitch,
                     _midwaterApp->sio32Interface->channel(),
                     SWING_ARM_MOTOR_POWER,     B48,            TOOLS,
                     DUAL_VICOR,        VICOR_BOARD_ADDR,
                     DUAL_VICOR_PSU0,
                     SA_MOTOR_SWITCH_REQ_DM,
                     SA_MOTOR_SWITCH_STATUS_DM,         _dmUpdateSem,
                     SA_MOTOR_PWR_REQ_DM,
                     SA_MOTOR_PWR_OK_DM,                _powerReqSem,
                     name,      "Swing Arm Motor Power Switch Channel");

  ibcAddSwitchInSeries ( &_dconSwitch, &mwsledLps0EnableSwitch);
  ibcAddSwitchInSeries ( &_dconSwitch, &mwsledLps1EnableSwitch);
  ibcAddSwitchInSeries ( &_dconSwitch, &mwsledLps2EnableSwitch);
  ibcAddSwitchInSeries ( &mwsledDcon240VSwitch, &saMotorPowerSwitch);


  ibcAddSwitchInSeries ( &mwsledLps0EnableSwitch, &indexSwitchExcite);
  ibcAddSwitchInSeries ( &mwsledLps0EnableSwitch, &swingArmPotExcite);
  ibcAddSwitchInSeries ( &mwsledLps0EnableSwitch, &currentMeterSwitch);
  ibcAddSwitchInSeries ( &mwsledLps0EnableSwitch, &spare12VLPSChannel0);

  ibcAddSwitchInSeries ( &mwsledLps1EnableSwitch, &ssIndexFwdSwitch);
  ibcAddSwitchInSeries ( &mwsledLps1EnableSwitch, &ssIndexRevSwitch);
  ibcAddSwitchInSeries ( &mwsledLps1EnableSwitch, &cameraSwitch);
  ibcAddSwitchInSeries ( &mwsledLps1EnableSwitch, &spare24VLPSChannel0);

  ibcAddSwitchInSeries ( &saMotorPowerSwitch, &portSwingArmDeploy);
  ibcAddSwitchInSeries ( &saMotorPowerSwitch, &portSwingArmStow);
  ibcAddSwitchInSeries ( &saMotorPowerSwitch, &stbdSwingArmDeploy);
  ibcAddSwitchInSeries ( &saMotorPowerSwitch, &stbdSwingArmStow);

  ibcAddSwitchInSeries ( &mwsledDcon240VSwitch, &ssPumpPowerSwitch);
  ibcAddSwitchInSeries ( &mwsledDcon240VSwitch, &tungstenLampSwitch);

  ibcConnectVicorDmItems(_midwaterApp->dmItems->vicorDm, &saMotorPowerSwitch,
       name,    "Swing Arm Motor Power Switch", DUAL_VICOR_PSU0,
       SA_MOTOR_TEMP_DM,
       SA_MOTOR_TEMP_ALARM_DM,
       SA_MOTOR_TEMP_WARN_THRESH_DM,
       SA_MOTOR_TEMP_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[0], &indexSwitchExcite,
       name,    "SS Index Switch Excite",       SS_INDEX_EXCITE_CHAN,
       SS_INDEX_EXCITE_CURRENT_DM,
       SS_INDEX_EXCITE_CURRENT_ALARM_DM,
       SS_INDEX_EXCITE_CURRENT_WARN_THRESH_DM,
       SS_INDEX_EXCITE_CURRENT_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[0], &swingArmPotExcite,
       name,    "Swing Arm Pot Excite",         SA_POT_EXCITE_CHAN,
       SA_POT_EXCITE_CURRENT_DM,
       SA_POT_EXCITE_CURRENT_ALARM_DM,
       SA_POT_EXCITE_CURRENT_WARN_THRESH_DM,
       SA_POT_EXCITE_CURRENT_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[0], &currentMeterSwitch,
       name,    "Current Meter Switch",         ACM_SWITCH_CHAN,
       ACM_SWITCH_CURRENT_DM,
       ACM_SWITCH_CURRENT_ALARM_DM,
       ACM_SWITCH_CURRENT_WARN_THRESH_DM,
       ACM_SWITCH_CURRENT_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[0], &spare12VLPSChannel0,
       name,    "Spare 12V LPS CHAN",           SPARE_12V_LPS_SWITCH_CHAN,
       SPARE_12V_LPS_CURRENT_DM,
       SPARE_12V_LPS_CURRENT_ALARM_DM,
       SPARE_12V_LPS_CURRENT_WARN_THRESH_DM,
       SPARE_12V_LPS_CURRENT_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[1], &ssIndexFwdSwitch,
       name,    "SS Index Fwd Switch",          SS_INDEX_FWD_SWITCH_CHAN,
       SS_INDEX_FWD_SWITCH_CURRENT_DM,
       SS_INDEX_FWD_SWITCH_CURRENT_ALARM_DM,
       SS_INDEX_FWD_SWITCH_CURRENT_WARN_THRESH_DM,
       SS_INDEX_FWD_SWITCH_CURRENT_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[1], &ssIndexRevSwitch,
       name,    "SS Index Rev Switch",          SS_INDEX_REV_SWITCH_CHAN,
       SS_INDEX_REV_SWITCH_CURRENT_DM,
       SS_INDEX_REV_SWITCH_CURRENT_ALARM_DM,
       SS_INDEX_REV_SWITCH_CURRENT_WARN_THRESH_DM,
       SS_INDEX_REV_SWITCH_CURRENT_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[1], &cameraSwitch,
       name,    "Camera Switch",                CAMERA_SWITCH_CHAN,
       CAMERA_SWITCH_CURRENT_DM,
       CAMERA_SWITCH_CURRENT_ALARM_DM,
       CAMERA_SWITCH_CURRENT_WARN_THRESH_DM,
       CAMERA_SWITCH_CURRENT_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[1], &spare24VLPSChannel0,
       name,    "Spare 24V LPS CHAN",           SPARE_24V_LPS_SWITCH_CHAN,
       SPARE_24V_LPS_CURRENT_DM,
       SPARE_24V_LPS_CURRENT_ALARM_DM,
       SPARE_24V_LPS_CURRENT_WARN_THRESH_DM,
       SPARE_24V_LPS_CURRENT_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[2], &portSwingArmDeploy,
       name,    "Port Swing Arm Deploy",        PORT_SA_DEPLOY_CHAN,
       PORT_SA_DEPLOY_CURRENT_DM,
       PORT_SA_DEPLOY_CURRENT_ALARM_DM,
       PORT_SA_DEPLOY_CURRENT_WARN_THRESH_DM,
       PORT_SA_DEPLOY_CURRENT_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[2], &portSwingArmStow,
       name,    "Port Swing Arm Stow Deploy",   PORT_SA_STOW_CHAN,
       PORT_SA_STOW_CURRENT_DM,
       PORT_SA_STOW_CURRENT_ALARM_DM,
       PORT_SA_STOW_CURRENT_WARN_THRESH_DM,
       PORT_SA_STOW_CURRENT_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[2], &stbdSwingArmDeploy,
       name,    "Stbd Swing Arm Deploy",        STBD_SA_DEPLOY_CHAN,
       STBD_SA_DEPLOY_CURRENT_DM,
       STBD_SA_DEPLOY_CURRENT_ALARM_DM,
       STBD_SA_DEPLOY_CURRENT_WARN_THRESH_DM,
       STBD_SA_DEPLOY_CURRENT_ALARM_THRESH_DM);

  ibcConnectLpsDmItems(&_midwaterApp->dmItems->lpsDm[2], &stbdSwingArmStow,
       name,    "Stbd Swing Arm Stow Deploy",   STBD_SA_STOW_CHAN,
       STBD_SA_STOW_CURRENT_DM,
       STBD_SA_STOW_CURRENT_ALARM_DM,
       STBD_SA_STOW_CURRENT_WARN_THRESH_DM,
       STBD_SA_STOW_CURRENT_ALARM_THRESH_DM);

  ibcConnectHpsDmItems(&_midwaterApp->dmItems->hpsDm[0], &ssPumpPowerSwitch,
       name,    "SS Pump Power Switch",
       SS_PUMP_CURRENT_DM,
       SS_PUMP_CURRENT_ALARM_DM,
       SS_PUMP_CURRENT_WARN_THRESH_DM,
       SS_PUMP_CURRENT_ALARM_THRESH_DM,
       SS_PUMP_SWITCH_TRIP_DM);

  ibcConnectHpsDmItems(&_midwaterApp->dmItems->hpsDm[1], &tungstenLampSwitch,
       name,    "Tungsten Lamp Switch",
       TUNGSTEN_LAMP_CURRENT_DM,
       TUNGSTEN_LAMP_CURRENT_ALARM_DM,
       TUNGSTEN_LAMP_CURRENT_WARN_THRESH_DM,
       TUNGSTEN_LAMP_CURRENT_ALARM_THRESH_DM,
       TUNGSTEN_LAMP_SWITCH_TRIP_DM);


  // Add all relevant dmItems to monitored group and set callback handler
  addItems();

}

MidWaterMonitor::~MidWaterMonitor()
{
}

void MidWaterMonitor::addItems()
{

  Int16 lps, hps;           /* Board Counter Indices                    */
  /*
     Create dmObject for each dmItem to be monitored
     handler.

     Note that we don't have to start consuming these items explicitly -
     that's taken care of by the DmMonitor::run() method.
  */

  // Water Alarm Threshholds
  addMonitoredItem(_midwaterApp->dmItems->waterAlarmThresh);

  addMonitoredItem(_midwaterApp->dmItems->ssPumpSpeed);
  addMonitoredItem(_midwaterApp->dmItems->ssPumpDirection);
  addMonitoredItem(_midwaterApp->dmItems->ssAutoIndex);
  addMonitoredItem(_midwaterApp->dmItems->ssIndexSense);

  //IIO 0
  addMonitoredItem(_midwaterApp->dmItems->valve1aSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve1bSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve2aSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve2bSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve3aSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve3bSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve4aSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve4bSwitch);

  //IIO 1
  addMonitoredItem(_midwaterApp->dmItems->valve5aSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve5bSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve6aSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve6bSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve7aSwitch);
  addMonitoredItem(_midwaterApp->dmItems->valve7bSwitch);
  addMonitoredItem(_midwaterApp->dmItems->contactSwitch0);
  addMonitoredItem(_midwaterApp->dmItems->contactSwitch1);

  addMonitoredItem(mwsledDcon240VSwitch.switchRequestDm);

  addMonitoredItem(mwsledLps0EnableSwitch.switchRequestDm);
  addMonitoredItem(indexSwitchExcite.switchRequestDm);
  addMonitoredItem(swingArmPotExcite.switchRequestDm);
  addMonitoredItem(currentMeterSwitch.switchRequestDm);
  addMonitoredItem(spare12VLPSChannel0.switchRequestDm);

  addMonitoredItem(mwsledLps1EnableSwitch.switchRequestDm);
  addMonitoredItem(ssIndexFwdSwitch.switchRequestDm);
  addMonitoredItem(ssIndexRevSwitch.switchRequestDm);
  addMonitoredItem(cameraSwitch.switchRequestDm);
  addMonitoredItem(spare24VLPSChannel0.switchRequestDm);

  addMonitoredItem(mwsledLps1EnableSwitch.switchRequestDm);
  addMonitoredItem(portSwingArmDeploy.switchRequestDm);
  addMonitoredItem(portSwingArmStow.switchRequestDm);
  addMonitoredItem(stbdSwingArmDeploy.switchRequestDm);
  addMonitoredItem(stbdSwingArmStow.switchRequestDm);

  addMonitoredItem(ssPumpPowerSwitch.switchRequestDm);
  addMonitoredItem(tungstenLampSwitch.switchRequestDm);

  addMonitoredItem(saMotorPowerSwitch.switchRequestDm);

  // IBC Board Items
  DmMonitorUtils::addGf5vItems(&_midwaterApp->dmItems->gf5vDm, this);

  DmMonitorUtils::addVicorItems(_midwaterApp->dmItems->vicorDm, this);

  DmMonitorUtils::addVspItems(&_midwaterApp->dmItems->vspDm, this);

  for (hps = 0; hps < HPS_BOARDS; hps++)
    DmMonitorUtils::addHpsItems(&_midwaterApp->dmItems->hpsDm[hps], this);

  for (lps = 0; lps < LPS_BOARDS; lps++)
    DmMonitorUtils::addLpsItems(&_midwaterApp->dmItems->lpsDm[lps], this);
}

int MidWaterMonitor::handleMicroReset()
{
  Int16 lps, hps;
  Int16 warnThresh = SA_LPS_CURRENT_WARN_THRESH;
  Int16 alarmThresh = SA_LPS_CURRENT_ALARM_THRESH;

  Int16 initPumpSpeed = 0;
  Int32 initPumpDir   = MidwaterDm::PumpStop;

  ibcSetSwitchState (&mwsledLps0EnableSwitch,  SWITCH_ON);
  ibcSetSwitchState (&mwsledLps1EnableSwitch,  SWITCH_ON);
  //ibcSetSwitchState (&mwsledLps2EnableSwitch,  SWITCH_ON);
  ibcSetSwitchState (&saMotorPowerSwitch,  SWITCH_OFF);

  ibcSetSwitchState (&indexSwitchExcite,   SWITCH_OFF);
  ibcSetSwitchState (&swingArmPotExcite,   SWITCH_OFF);
  ibcSetSwitchState (&currentMeterSwitch,  SWITCH_OFF);
  ibcSetSwitchState (&spare12VLPSChannel0, SWITCH_OFF);

  ibcSetSwitchState (&ssIndexFwdSwitch,    SWITCH_OFF);
  ibcSetSwitchState (&ssIndexRevSwitch,    SWITCH_OFF);
  ibcSetSwitchState (&cameraSwitch,        SWITCH_OFF);
  ibcSetSwitchState (&spare24VLPSChannel0, SWITCH_OFF);

  ibcSetSwitchState (&portSwingArmDeploy,  SWITCH_OFF);
  ibcSetSwitchState (&portSwingArmStow,    SWITCH_OFF);
  ibcSetSwitchState (&stbdSwingArmDeploy,  SWITCH_OFF);
  ibcSetSwitchState (&stbdSwingArmStow,    SWITCH_OFF);


  ibcSetSwitchState (&ssPumpPowerSwitch,   SWITCH_OFF);
  ibcSetSwitchState (&tungstenLampSwitch,  SWITCH_OFF);


  initIbcHumidityThreshDm(_midwaterApp->sio32Interface->channel(),
                          _midwaterApp->dmItems->ibcDm.humidityWarnThresh,
                          _midwaterApp->dmItems->ibcDm.humidityAlarmThresh);

  _midwaterApp->initWaterAlarmThreshDm(_midwaterApp->sio32Interface->channel(),
                       _midwaterApp->dmItems->waterAlarmThresh->getHandle());

  updateIbcGf5vDmItems(_midwaterApp->sio32Interface->channel(),
                       GF5V_BOARD_ADDR,
                       &_midwaterApp->dmItems->gf5vDm, mwsledName);

  ibcGf5vSetChargeTimes(_midwaterApp->sio32Interface->channel(),
                     GF5V_BOARD_ADDR,
                     &_midwaterApp->dmItems->gf5vDm,
                     LOW_VOLTAGE_GF_CHARGE_TIME, LOW_VOLTAGE_GF_CHARGE_TIME,
                     LOW_VOLTAGE_GF_CHARGE_TIME, LOW_VOLTAGE_GF_CHARGE_TIME);

  enableGf5vMonitoring(_midwaterApp->sio32Interface->channel(),
                       GF5V_BOARD_ADDR, &_midwaterApp->dmItems->gf5vDm,
                       FALSE );

  runGf5vBoardSelftest(_midwaterApp->sio32Interface->channel(),
                       GF5V_BOARD_ADDR, &_midwaterApp->dmItems->gf5vDm);

  updateIbcVspDmItems(_midwaterApp->sio32Interface->channel(),
                      SERIAL_BOARD_ADDR, VSP_CHAN,
                      &_midwaterApp->dmItems->vspDm, mwsledName);

  for (lps = 0; lps < LPS_BOARDS; lps++)
  updateIbcLpsDmItems(_midwaterApp->sio32Interface->channel(),
                      lpsBoardAddr[lps], &_midwaterApp->dmItems->lpsDm[lps],
                      mwsledName);


  //Set Swing Arm Current Thresh
  urgentWriteDmItem( portSwingArmDeploy.currentWarnThreshDm,
                     &warnThresh, sizeof(warnThresh));
  urgentWriteDmItem( portSwingArmDeploy.currentAlarmThreshDm,
                     &alarmThresh, sizeof(alarmThresh));

  urgentWriteDmItem( portSwingArmStow.currentWarnThreshDm,
                     &warnThresh, sizeof(warnThresh));
  urgentWriteDmItem( portSwingArmStow.currentAlarmThreshDm,
                     &alarmThresh, sizeof(alarmThresh));

  urgentWriteDmItem( stbdSwingArmDeploy.currentWarnThreshDm,
                     &warnThresh, sizeof(warnThresh));
  urgentWriteDmItem( stbdSwingArmDeploy.currentAlarmThreshDm,
                     &alarmThresh, sizeof(alarmThresh));

  urgentWriteDmItem( stbdSwingArmStow.currentWarnThreshDm,
                     &warnThresh, sizeof(warnThresh));
  urgentWriteDmItem( stbdSwingArmStow.currentAlarmThreshDm,
                     &alarmThresh, sizeof(alarmThresh));

  writeLpsCurrentThresholds(_midwaterApp->sio32Interface->channel(),
                            lpsBoardAddr[2],
                            &_midwaterApp->dmItems->lpsDm[2] );


  for (hps = 0; hps < HPS_BOARDS; hps++)
  updateIbcHpsDmItems(_midwaterApp->sio32Interface->channel(),
                      hpsBoardAddr[hps], &_midwaterApp->dmItems->hpsDm[hps],
                      mwsledName);

  updateIbcVicorDmItems(_midwaterApp->sio32Interface->channel(),
                        VICOR_BOARD_ADDR, _midwaterApp->dmItems->vicorDm,
                        mwsledName);


  urgentWriteDmItem(_midwaterApp->dmItems->ssPumpSpeed->getHandle(),
                    &initPumpSpeed,
                    sizeof(initPumpSpeed));

  urgentWriteDmItem(_midwaterApp->dmItems->ssPumpDirection->getHandle(),
                    &initPumpDir,
                    sizeof(initPumpDir));
}

int MidWaterMonitor::processDmInput()
{

  Int16 lps, hps;           /* Board Counter Indices                    */
  MBool valveState, contactSwitchState, autoIndexSense;
  Int16 pumpSpeed;
  Int32 pumpDir;

  if(_monitoredGroup->itemChanged(mwsledDcon240VSwitch.switchRequestDm))
  {
    if(ibcSwitchRequestDmState(&mwsledDcon240VSwitch)== SWITCH_OFF)
    {
      ibcSetSwitchState(&ssPumpPowerSwitch, SWITCH_OFF);
      ibcSetSwitchState(&tungstenLampSwitch, SWITCH_OFF);
    }
  }
//LPS0 items
  if (_monitoredGroup->itemChanged(mwsledLps0EnableSwitch.switchRequestDm))
     ibcProcessSwitchRequest(&mwsledLps0EnableSwitch);

  if (_monitoredGroup->itemChanged(indexSwitchExcite.switchRequestDm))
     ibcProcessSwitchRequest(&indexSwitchExcite);

  if (_monitoredGroup->itemChanged(swingArmPotExcite.switchRequestDm))
     ibcProcessSwitchRequest(&swingArmPotExcite);

  if (_monitoredGroup->itemChanged(currentMeterSwitch.switchRequestDm))
     ibcProcessSwitchRequest(&currentMeterSwitch);

  if (_monitoredGroup->itemChanged(spare12VLPSChannel0.switchRequestDm))
     ibcProcessSwitchRequest(&spare12VLPSChannel0);

//LPS1 Items
  if (_monitoredGroup->itemChanged(mwsledLps1EnableSwitch.switchRequestDm))
     ibcProcessSwitchRequest(&mwsledLps1EnableSwitch);

  if (_monitoredGroup->itemChanged(ssIndexFwdSwitch.switchRequestDm))
  {
     ibcSetSwitchStateOff(&ssIndexRevSwitch);
     ibcProcessSwitchRequest(&ssIndexFwdSwitch);
  }

  if (_monitoredGroup->itemChanged(ssIndexRevSwitch.switchRequestDm))
  {
     ibcSetSwitchStateOff(&ssIndexFwdSwitch);
     ibcProcessSwitchRequest(&ssIndexRevSwitch);
  }

  if (_monitoredGroup->itemChanged(cameraSwitch.switchRequestDm))
     ibcProcessSwitchRequest(&cameraSwitch);

  if (_monitoredGroup->itemChanged(spare24VLPSChannel0.switchRequestDm))
     ibcProcessSwitchRequest(&spare24VLPSChannel0);

//LPS2 Items
//  if (_monitoredGroup->itemChanged(mwsledLps2EnableSwitch.switchRequestDm))
//     ibcProcessSwitchRequest(&mwsledLps2EnableSwitch);

  if (_monitoredGroup->itemChanged(portSwingArmDeploy.switchRequestDm))
  {
     ibcSetSwitchStateOff(&portSwingArmStow);
     ibcProcessSwitchRequest(&portSwingArmDeploy);
  }

  if (_monitoredGroup->itemChanged(portSwingArmStow.switchRequestDm))
  {
     ibcSetSwitchStateOff(&portSwingArmDeploy);
     ibcProcessSwitchRequest(&portSwingArmStow);
  }

  if (_monitoredGroup->itemChanged(stbdSwingArmDeploy.switchRequestDm))
  {
     ibcSetSwitchStateOff(&stbdSwingArmStow);
     ibcProcessSwitchRequest(&stbdSwingArmDeploy);
  }

  if (_monitoredGroup->itemChanged(stbdSwingArmStow.switchRequestDm))
  {
     ibcSetSwitchStateOff(&stbdSwingArmDeploy);
     ibcProcessSwitchRequest(&stbdSwingArmStow);
  }

//High power Switch Items
  if (_monitoredGroup->itemChanged(ssPumpPowerSwitch.switchRequestDm))
  {
      ibcProcessSwitchRequest(&ssPumpPowerSwitch);

      pumpSpeed = SS_PUMP_STOP_VALUE;

      //Write speed Value to micro
      setMotorSpeed(_midwaterApp->sio32Interface->channel(),
                    ISOLATED_IO_BOARD_0_ADDR, MOTOR_SPEED_CHAN,
                    (Nat16) pumpSpeed);
  }


  if (_monitoredGroup->itemChanged(tungstenLampSwitch.switchRequestDm))
      ibcProcessSwitchRequest(&tungstenLampSwitch);

//Dual Vicor Item
  if (_monitoredGroup->itemChanged(saMotorPowerSwitch.switchRequestDm))
      ibcProcessSwitchRequest(&saMotorPowerSwitch);

// IIO 0 Items
  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve1aSwitch))
  {
      _midwaterApp->dmItems->valve1aSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_0_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve1bSwitch))
  {
      _midwaterApp->dmItems->valve1bSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_1_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve2aSwitch))
  {
      _midwaterApp->dmItems->valve2aSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_2_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve2bSwitch))
  {
      _midwaterApp->dmItems->valve2bSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_3_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve3aSwitch))
  {
      _midwaterApp->dmItems->valve3aSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_4_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve3bSwitch))
  {
      _midwaterApp->dmItems->valve3bSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_5_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve4aSwitch))
  {
      _midwaterApp->dmItems->valve4aSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_6_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve4bSwitch))
  {
      _midwaterApp->dmItems->valve4bSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_0_ADDR, SWITCH_7_CHAN,
                       valveState ? OFF : ON);
  }

// IIO 1 Items
  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve5aSwitch))
  {
      _midwaterApp->dmItems->valve5aSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_0_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve5bSwitch))
  {
      _midwaterApp->dmItems->valve5bSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_1_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve6aSwitch))
  {
      _midwaterApp->dmItems->valve6aSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_2_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve6bSwitch))
  {
      _midwaterApp->dmItems->valve6bSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_3_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve7aSwitch))
  {
      _midwaterApp->dmItems->valve7aSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_4_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->valve7bSwitch))
  {
      _midwaterApp->dmItems->valve7bSwitch->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_5_CHAN,
                       valveState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->contactSwitch0))
  {
      _midwaterApp->dmItems->contactSwitch0->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_6_CHAN,
                       contactSwitchState ? OFF : ON);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->contactSwitch1))
  {
      _midwaterApp->dmItems->contactSwitch1->read(&valveState, (DM_Time *) NULL);
      ibcSwitchControl(_midwaterApp->sio32Interface->channel(),
                       ISOLATED_IO, ISOLATED_IO_BOARD_1_ADDR, SWITCH_7_CHAN,
                       contactSwitchState ? OFF : ON);
  }


  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->waterAlarmThresh))
  {
    // Process change in waterAlarmThresh value
    _midwaterApp->writeWaterAlarmThresh(_midwaterApp->sio32Interface->channel(),
                          _midwaterApp->dmItems->waterAlarmThresh->getHandle());
  }
  if (_monitoredGroup->itemChanged(
           _midwaterApp->dmItems->ibcDm.humidityWarnThresh)||
           _monitoredGroup->itemChanged(
           _midwaterApp->dmItems->ibcDm.humidityAlarmThresh))
  {
    // Process change in Humidity warning or alarm thresh
    writeIbcHumidityThresh(_midwaterApp->sio32Interface->channel(),
                           _midwaterApp->dmItems->ibcDm.humidityWarnThresh,
                           _midwaterApp->dmItems->ibcDm.humidityAlarmThresh);
  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->ssPumpSpeed))
  {
      _midwaterApp->dmItems->ssPumpSpeed->read(&pumpSpeed,
                                               (DM_Time *) NULL);

      _midwaterApp->dmItems->ssPumpDirection->read(&pumpDir,
                                                   (DM_Time *) NULL);
      //Convert 0 to 100% Forward Direction to 127 - 255
      if (pumpDir == MidwaterDm::PumpForward)
                pumpSpeed = (((pumpSpeed * 127)/100) + 127);
      //Convert 0 to 100% Reverse Direction to 0 - 127
      else if (pumpDir == MidwaterDm::PumpReverse)
                pumpSpeed = abs((((pumpSpeed * 127)/100) - 127));
      //Convert 0 or Stop Value to 127
      else if (pumpDir == MidwaterDm::PumpStop)
                pumpSpeed = SS_PUMP_STOP_VALUE;

      //Write speed Value to micro 0 - 255 value D/A conversion 0 - 10V
      setMotorSpeed(_midwaterApp->sio32Interface->channel(),
                    ISOLATED_IO_BOARD_0_ADDR, MOTOR_SPEED_CHAN,
                    (Nat16) pumpSpeed);

  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->ssPumpDirection))
  {
      _midwaterApp->dmItems->ssPumpSpeed->read(&pumpSpeed,
                                               (DM_Time *) NULL);

      _midwaterApp->dmItems->ssPumpDirection->read(&pumpDir,
                                                   (DM_Time *) NULL);
      //Convert 0 to 100% Forward Direction to 127 - 255
      if (pumpDir == MidwaterDm::PumpForward)
                pumpSpeed = (((pumpSpeed * 127)/100) + 127);
      //Convert 0 to 100% Reverse Direction to 0 - 127
      else if (pumpDir == MidwaterDm::PumpReverse)
                pumpSpeed = abs((((pumpSpeed * 127)/100) - 127));
      //Convert 0 or Stop Value to 127
      else if (pumpDir == MidwaterDm::PumpStop)
                pumpSpeed = SS_PUMP_STOP_VALUE;

      //Write speed Value to micro 0 - 255 value D/A conversion 0 - 10V
      setMotorSpeed(_midwaterApp->sio32Interface->channel(),
                    ISOLATED_IO_BOARD_0_ADDR, MOTOR_SPEED_CHAN,
                    (Nat16) pumpSpeed);

  }

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->ssAutoIndex))
    _midwaterApp->dmItems->ssAutoIndex->read(&_autoIndexState,
                                             (DM_Time *) NULL);

  if (_monitoredGroup->itemChanged(_midwaterApp->dmItems->ssIndexSense))
  {
     _midwaterApp->dmItems->ssIndexSense->read(&autoIndexSense,
                                               (DM_Time *) NULL);
     if (autoIndexSense)
     {
       if(_autoIndexState)
       { //Write ss Index switches to Off
         ibcSetSwitchState(&ssIndexFwdSwitch, SWITCH_OFF);
         ibcSetSwitchState(&ssIndexRevSwitch, SWITCH_OFF);
       }
     }
  }

//Card Items
  DmMonitorUtils::processGf5vChanges(&_midwaterApp->dmItems->gf5vDm, this,
                  _midwaterApp->sio32Interface->channel(), GF5V_BOARD_ADDR);

  DmMonitorUtils::processVicorChanges(_midwaterApp->dmItems->vicorDm, this,
                  _midwaterApp->sio32Interface->channel(), VICOR_BOARD_ADDR);

  DmMonitorUtils::processVspChanges(&_midwaterApp->dmItems->vspDm, this,
                  _midwaterApp->sio32Interface->channel(), VSP_CHAN,
                  SERIAL_BOARD_ADDR);

  for (hps = 0; hps < HPS_BOARDS; hps++)
     DmMonitorUtils::processHpsChanges(&_midwaterApp->dmItems->hpsDm[hps],
                  this, _midwaterApp->sio32Interface->channel(),
                  hpsBoardAddr[hps]);

  for (lps = 0; lps < LPS_BOARDS; lps++)
     DmMonitorUtils::processLpsChanges(&_midwaterApp->dmItems->lpsDm[lps],
                  this, _midwaterApp->sio32Interface->channel(),
                  lpsBoardAddr[lps]);
}

/******************************************************************************/
/* Function    : setMotorSpeed                                                */
/* Purpose     : Sets Motor Speed                                             */
/* Inputs      : Sio32Chan, Board Addr, Dac Channel, Dac Level (0-255)        */
/* Outputs     : Returns OK or ERROR                                          */
/******************************************************************************/
   STATUS
MidWaterMonitor::setMotorSpeed(sio32Chan *serialChan, Word boardAddr,
               Nat16 channel, Nat16 level )
{   // Send Digital Level to DAC
    return (IBC_ISO_IO_SetDacLevel(serialChan,
        boardAddr, channel, level));
} // setMotorSpeed()



























































































































