oceanserversystem.h

/*
 * GearBox Project: Peer-Reviewed Open-Source Libraries for Robotics
 *               http://gearbox.sf.net/
 * Copyright (c) 2004-2010 Tobias Kaupp
 *
 * This distribution is licensed to you under the terms described in
 * the LICENSE file included in this distribution.
 *
 */

#ifndef GBX_OCEANSERVER_SYSTEM_H
#define GBX_OCEANSERVER_SYSTEM_H

#include <map>
#include <gbxsmartbatteryacfr/smartbattery.h>

namespace gbxsmartbatteryacfr
{

class OceanServerSystem
{
    public:

        OceanServerSystem();

        bool isEmpty() const { return isEmpty_; };
        
        const std::map<int,SmartBattery>& batteries() const;
        
        SmartBattery& battery( unsigned int batteryNumber );   
        
        const SmartBattery& battery( unsigned int batteryNumber ) const;
        
        void eraseBattery( unsigned int batteryNumber );
        
        void setPercentCharge(int percentCharge) { isEmpty_=false; percentCharge_ = percentCharge; };
        int percentCharge() const { return percentCharge_; };
        void setMinToEmpty(int minToEmpty) { isEmpty_=false; minToEmpty_ = minToEmpty; };
        int minToEmpty() const { return minToEmpty_; };
        void setMessageToSystem(const std::string &messageToSystem) { isEmpty_=false; messageToSystem_ = messageToSystem; };
        std::string messageToSystem() const { return messageToSystem_; };
        
        const std::vector<bool> &availableBatteries() const { return availableBatteries_; };
        std::vector<bool> &availableBatteries() { isEmpty_=false; return availableBatteries_; };
        const std::vector<bool> &chargingStates() const { return chargingStates_; };
        std::vector<bool> &chargingStates() { isEmpty_=false; return chargingStates_; };
        const std::vector<bool> &supplyingPowerStates() const { return supplyingPowerStates_; };
        std::vector<bool> &supplyingPowerStates() { isEmpty_=false; return supplyingPowerStates_; };
        const std::vector<bool> &chargePowerPresentStates() const { return chargePowerPresentStates_; };
        std::vector<bool> &chargePowerPresentStates() { isEmpty_=false; return chargePowerPresentStates_; };
        const std::vector<bool> &powerNoGoodStates() const { return powerNoGoodStates_; };
        std::vector<bool> &powerNoGoodStates() { isEmpty_=false; return powerNoGoodStates_; };
        const std::vector<bool> &chargeInhibitedStates() const { return chargeInhibitedStates_; }
        std::vector<bool> &chargeInhibitedStates() { isEmpty_=false; return chargeInhibitedStates_; }
        
        const std::vector<std::string> &rawRecord() const { return rawRecord_; };
        std::vector<std::string> &rawRecord() { isEmpty_=false; return rawRecord_; };
 
    private:

        bool isEmpty_;
    
        // Average battery values
        int percentCharge_;
        int minToEmpty_;
        std::string messageToSystem_;

        // Battery module states. Each vector is always of size 8 because OceanServer's Battery
        // Management Modules have a maximum of 8 slots (either 2, 4, or 8 dependent on the model)
        std::vector<bool> availableBatteries_;
        std::vector<bool> chargingStates_;
        std::vector<bool> supplyingPowerStates_;
        std::vector<bool> chargePowerPresentStates_;
        std::vector<bool> powerNoGoodStates_;
        std::vector<bool> chargeInhibitedStates_;

        // the latest raw record, useful for debugging
        std::vector<std::string> rawRecord_;
        
        // key: slot number, data: a single smart battery module
        std::map<int,SmartBattery> batteries_;
};

std::string toString( const OceanServerSystem &system );

std::string toLogString( const OceanServerSystem &system );
    
void updateWithNewData( const OceanServerSystem &from, 
                        OceanServerSystem       &to );

bool isChargePowerPresent( const OceanServerSystem &batterySystem );
                        
} // namespace

#endif