#include "IbcObjects.h"
//Water Alarm Constructor And Destructor
IbcWaterAlarms::IbcWaterAlarms(const char *prefix, Word appType)
{
  _appType = appType;
  _dm = new WaterAlarmsDm(prefix);
}

IbcWaterAlarms::~IbcWaterAlarms()
{
  delete _dm;
}

// Methods to Access Ibc Water Alarm Stuff
STATUS IbcWaterAlarms::getAlarms(sio32Chan *IBC_SerialChan, Word *waterAlarmStatus)
{
 //Send Command To MicroController
   return( microCommand(IBC_SerialChan,
           _appType | GET_WATER_ALARM, waterAlarmStatus) );
}//getAlarms

STATUS IbcWaterAlarms::getThresh(sio32Chan *IBC_SerialChan, Int16 *waterAlarmThresh)
{
  //Send Command To MicroController
  return( microCommand(IBC_SerialChan,
          _appType | GET_WATER_ALARM_THRESH, waterAlarmThresh));

}//getThresh

STATUS IbcWaterAlarms::initThreshDm(sio32Chan *IBC_SerialChan)
{
  Int16 waterAlarmThresh;       //WaterAlarm Thresh from IBC

  //Get Water Alarm Thresh Form Micro
  if (getThresh( IBC_SerialChan, &waterAlarmThresh ) != OK)
     return(ERROR);
  //Urgent Write here because another task is normal provider
  return (urgentWriteDmItem(_dm->waterAlarmThresh->getHandle(), &waterAlarmThresh,
                            sizeof(waterAlarmThresh)) );
}//initThreshDm

STATUS IbcWaterAlarms::writeThresh(sio32Chan *sio32DataChan)
{
  Errno status;                //Result of dm_read
  Int16 waterAlarmThresh;      // Water Alarm Threshold

  //Read Water Alarm Thresh From DataManager
  status = _dm->waterAlarmThresh->read(&waterAlarmThresh, (DM_Time *) NULL);
  //Check Status
  if ((status == SUCCESS) || (status == EDM_NOPROVIDER))
     //Send Command To Microcontroller
     if(sendMicroCommand(sio32DataChan, &status, sizeof(status), 2,
        _appType | SET_WATER_ALARM_THRESH, waterAlarmThresh)
        != ERROR )

         return(wordFromBuf(&status, 0) == CMD_OK ? OK : ERROR);
      return(ERROR);
}//writeThresh

STATUS IbcWaterAlarms::updateAlarmDm( sio32Chan *sio32DataChan )
{
  Word waterAlarmStatus;        // MicroController Water Alarm Status
  MBool status;                 // Boolean state of Water Alarm

  //Read Water Alarm Status
  if (getAlarms(sio32DataChan, &waterAlarmStatus)!= OK)
      return(ERROR);
  //Write Water Alarm Status to Datamanager
  status = ( (waterAlarmStatus & HOUSING_WATER_ALARM_BIT) ? TRUE : FALSE);
  writeDmItem(_dm->camWaterAlarm->getHandle(), &status, sizeof(status));

  status = ( (waterAlarmStatus & JBOX_WATER_ALARM_BIT) ? TRUE : FALSE)
  return(writeDmItem(_dm->camWaterAlarm->getHandle(), &status, sizeof(status)) );
}//updateAlarms

//Humidity Sensor Objects
IbcHumidityAlarm::IbcHumidityAlarm(const char *prefix)
{
  _dm = new HumidityAlarmDm(prefix);
}
IbcHumidityAlarm::~IbcHumidityAlarm()
{
  delete _dm;
}

/****************************************************************************/
/* Function    : initThreshDm                                               */
/* Purpose     : Read Humidity Threshold and update data manager item       */
/* Inputs      : Sio32 channel                                              */
/* Outputs     : Returns OK or ERROR                                        */
/****************************************************************************/
STATUS IbcHumidityAlarm::initThreshDm( sio32Chan *sio32DataChan )
{
    Int16   warnThresh, alarmThresh;    /* Humidity Alarm Thresholds        */

                                        /* Get Humidity Alarm Thresh        */
    if (ibcCpuGetHumidityThresh(sio32DataChan, &warnThresh, &alarmThresh) != OK)
        return (ERROR);
                                        /* We MUST use urgent open here as  */
                                        /* another task is normal provider  */

    urgentWriteDmItem( _dm->humidityAlarmDm->getHandle(), &alarmThresh,
                       sizeof(alarmThresh));
    return (urgentWriteDmItem(_dm->humidityWarnDm->getHandle(), &warnThresh,
                               sizeof(warnThresh)));
} /* initThreshDm() */

/****************************************************************************/
/* Function    : writeThresh                                                */
/* Purpose     : Get humidity alarm threshold value from dm and send to IBC */
/* Inputs      : Sio32 channel                                              */
/* Outputs     : Returns OK or ERROR                                        */
/****************************************************************************/
STATUS IbcHumidityAlarm::writeThresh( sio32Chan *sio32DataChan )
{
    Errno   status;                     /* Result of dm_read                */
    Int16   warnThresh, alarmThresh;    /* Humidity Alarm Threshold         */

                                        /* Read Humidity Thresh from dmgr   */
    status = _dm->humidityWarnDm->read((char *) &warnThresh, (DM_Time *) NULL);

    status = _dm->humidityAlarmDm->read((char *) &alarmThresh, (DM_Time *) NULL);

                                        /* Check for successful dm_read     */
    if ((status == SUCCESS) || (status == EDM_NOPROVIDER))
                                        /* Send value to motor micro        */
        if (ibcCpuSetHumidityThresh( sio32DataChan, warnThresh, alarmThresh)
           == OK) return (OK);

    return(ERROR);
} /* writeThresh() */

/****************************************************************************/
/* Function    : updateDm                                                   */
/* Purpose     : Reads IBC CPU humidity sensor value & updates dmgr item    */
/* Inputs      : Sio32 chan                                                 */
/* Outputs     : Returns OK or ERROR                                        */
/****************************************************************************/
STATUS IbcHumidityAlarm::updateDm( sio32Chan *sio32DataChan )
{
    Int16 humidity;                 /* IBC CPU Humidity Sensor Value        */
                                    /* Read humidity sensor status          */
    if (ibcCpuGetHumidity(sio32DataChan, &humidity) != OK)
        return(ERROR);
                                    /* Write humidity sensor to Data Manager*/
    return (writeDmItem(_dm->microHumidityDm->getHandle(),
                        &humidity, sizeof(humidity) ));
} /* updateDm() */

/****************************************************************************/
/* Function    : updateAlarmDm                                              */
/* Purpose     : Reads IBC CPU humidity alarm value & updates dmgr item     */
/* Inputs      : Sio32 chan                                                 */
/* Outputs     : Returns OK or ERROR                                        */
/****************************************************************************/
STATUS IbcHumidityAlarm::updateAlarmDm( sio32Chan *sio32DataChan )
{
    microAlarm humidityAlarm;       /* IBC CPU Humidity Alarm Value         */
    Word alarmStatus;               /* Humidity alarm status                */

                                    /* Read humidity alarm status           */
    if (ibcCpuGetHumidityAlarm(sio32DataChan, &alarmStatus) != OK)
        return(ERROR);

    humidityAlarm = (microAlarm) alarmStatus;

                                    /* Write humidity alarm to Data Manager */
    return(writeDmItem(_dm->humidityAlarmDm_>getHandle(),
           &humidityAlarm, sizeof(humidityAlarm)));
} /* updateAlarmDm() */


#if 0
//Ground Fault 5 Volt Board Access Methods
Gf5v::Gf5v(const Char *prefix)
{
  _gf5vDm = new Gf5vDm( prefix );
}

~Gf5v()
{
  delete _gf5vDm;
}
#endif