//=========================================================================
// Summary  :
// Filename : MMThalesBattery.h
// Author   : Gil Jones
// Project  :
// Revision : 1
// Created  : 2002/03/13
// Modified : 2002/03/13
//=========================================================================
// Description :  Thales Battery messages
//=========================================================================

#ifndef _MMTHALESBATTERY_H
#define _MMTHALESBATTERY_H

#include "ModemMessage.h"
#include "MMUtils.h"

#define BatteryMessageTimeOut 60

/////////////////////////////////////////////
class MMThalesBatteryInfo : public MMConvertible
{
 public:
    MMThalesBatteryInfo(const ModemMessage *pMM);
    MMThalesBatteryInfo(int num, short ser, double volts, double amps, double capacity, 
			double minV, double maxV, double temperature,
			char state, char errorState, short commsFailures,
			short getBatteryErrorLevels);
    
    virtual ModemMessage::Type tGetMessageType() const
	{ return ModemMessage::tMMThalesBatteryInfo; };
    virtual int iGetDefaultTimeout() const
	{ return BatteryMessageTimeOut; };
    virtual const char* pcRead(const char* sourceBuffer);
    virtual char* pcWrite(char* destBuffer) const;

    void setNum(int num)
	{ m_num = MMUtil::int2char(num); };
    void setVolts(double volts)
	{ m_volts = MMUtil::double2short(volts, MIN_VOLTAGE, MAX_VOLTAGE); };
    void setAmps(double amps)
	{ m_amps = MMUtil::double2short(amps, MIN_CURRENT,MAX_CURRENT); };
    void setTemp(double temp)
	{ m_temp = MMUtil::double2short(temp, MIN_TEMP, MAX_TEMP); };
    void setMinVolts(double volts)
	{ m_minV = MMUtil::double2short(volts, MIN_CELL_VOLTAGE, MAX_CELL_VOLTAGE); };
    void setMaxVolts(double volts)
	{ m_maxV = MMUtil::double2short(volts, MIN_CELL_VOLTAGE, MAX_CELL_VOLTAGE); };
    //not set for now
    void setCapacity(double capacity)
	{ m_capacity = MMUtil::double2short(capacity, 0, 10); };
    void setState(char state)
	{ m_state = state; };
    void setErrorState(char estate)
	{ m_errorState = estate; };
    void setCommsFailures(short cF)
	{ m_commsFailures = MMUtil::int2char(cF); };
    void setErrorLevel(short eL)
	{ m_errorLevel = MMUtil::int2char(eL); };
    void setBatterySerial(short ser)
	{ m_batterySerial = MMUtil::int2char(ser); };

    int getNum()
	{ return MMUtil::char2int(m_num); };
    double getVolts()
	{ return MMUtil::short2double(m_volts, MIN_VOLTAGE, MAX_VOLTAGE); };
    double getAmps()
	{ return MMUtil::short2double(m_amps, MIN_CURRENT, MAX_CURRENT); };
    double getTemp()
	{ return MMUtil::short2double(m_temp, MIN_TEMP, MAX_TEMP); };
    double getMinVolts()
	{ return MMUtil::short2double(m_minV, MIN_CELL_VOLTAGE, MAX_CELL_VOLTAGE); };
    double getMaxVolts()
	{ return MMUtil::short2double(m_maxV, MIN_CELL_VOLTAGE, MAX_CELL_VOLTAGE); };
    //totally making up the limits for now
    double getCapacity()
	{ return MMUtil::short2double(m_capacity, 0, 10); };
    char getState()
	{ return m_state; };
    char getErrorState()
	{ return m_errorState; };
    short getCommsFailures()
	{ return MMUtil::char2int(m_commsFailures); };
    short getErrorLevel()
	{ return MMUtil::char2int(m_errorLevel); };
    short getBatterySerial() 
	{ return MMUtil::char2int(m_batterySerial); };

 protected:
    
    uchar m_num;
    uchar m_batterySerial;
    ushort m_volts;
    ushort m_amps;
    ushort m_temp;
    ushort m_minV;
    ushort m_maxV;
    ushort m_capacity;
    uchar m_state;
    uchar m_errorState;
    uchar m_commsFailures;
    uchar m_errorLevel;
         
};

class MMThalesBatteryGlobal : public MMConvertible
{
 public:
    MMThalesBatteryGlobal(const ModemMessage *pMM);
    MMThalesBatteryGlobal(short numBat, short numOn, short numAlive, double volts, 
			  double amps, double capacity, short errorLevel);
    
    virtual ModemMessage::Type tGetMessageType() const
	{ return ModemMessage::tMMThalesBatteryGlobal; };
    virtual int iGetDefaultTimeout() const
	{ return BatteryMessageTimeOut; };
    virtual const char* pcRead(const char* sourceBuffer);
    virtual char* pcWrite(char* destBuffer) const;

    void setNumBat(short numBat)
	{ m_numBat = MMUtil::int2char(numBat); };
    void setNumOn(short numOn)
	{ m_numOn = MMUtil::int2char(numOn); };
    void setNumAlive(short numAlive) 
	{ m_numAlive = MMUtil::int2char(numAlive); };
    void setVolts(double volts)
	{ m_volts = MMUtil::double2short(volts, MIN_VOLTAGE, MAX_VOLTAGE); };
    void setAmps(double amps)
	{ m_amps = MMUtil::double2short(amps, MIN_CURRENT,MAX_CURRENT); };
    void setCapacity(double capacity)
	{ m_capacity = MMUtil::double2short(capacity, 0, 10); };
    void setErrorLevel(short eL)
	{ m_errorLevel = MMUtil::int2char(eL); };
    
    short getNumBat()
	{ return MMUtil::char2int(m_numBat); };
    short getNumOn()
	{ return MMUtil::char2int(m_numOn); };
    short getNumAlive()
	{ return MMUtil::char2int(m_numAlive); };
    double getVolts()
	{ return MMUtil::short2double(m_volts, MIN_VOLTAGE, MAX_VOLTAGE); };
    double getAmps()
	{ return MMUtil::short2double(m_amps, MIN_CURRENT, MAX_CURRENT); };
    double getCapacity()
	{ return MMUtil::short2double(m_capacity, 0, 10); };
    short getErrorLevel()
	{ return m_errorLevel = MMUtil::char2int(m_errorLevel); };

 protected:

    uchar m_numBat;
    uchar m_numOn;
    uchar m_numAlive;
    ushort m_volts;
    ushort m_amps;
    ushort m_capacity;
    uchar m_errorLevel;

};
#endif