BPC1.h

Go to the documentation of this file.

#ifndef BPC1_H
#define BPC1_H

#include "component/SyncComponent.h"
#include "io/LoadControl.h"
#include "io/UartStream.h"
#include "logger/Logger.h"
#include "BPC1IF.h"
#define NUMBATTSA BPC1IF::NUMBATTSA
#define NUMBATTSB BPC1IF::NUMBATTSB

#define SHORT_MSG_MIN_SIZE 199  // bytes. For the mux that has only 7 sticks
#define SHORT_MSG_MAX_SIZE 216  // bytes. For the other 3 mux that have 8 sticks
#define FULL_MSG_MIN_SIZE 1676  // bytes. Includes echoed "X" and spaces
#define FULL_MSG_MAX_SIZE 1904  // bytes. Includes echoed "X" and spaces

#define MESSAGE_OFFSET 77  // bytes. Length of system and controller data
#define SMBUS_MSG_LEN 228  // bytes. Includes the $B1n and checksum that IBPS adds

#define MAX_STICKS 8       // There can only be up to 8 sticks connected. 

class UniversalDataReader;
class UniversalDataWriter;

class BPC1 : public SyncSensorComponent
{
public:

    BPC1( const Module* module );

    virtual ~BPC1();

    virtual void run();

    virtual RunState start();

    virtual RunState starting();

    virtual RunState pause();

    virtual RunState pausing();

    virtual RunState paused();

    virtual RunState resume();

    virtual RunState resuming();

    virtual RunState runnable();

    virtual RunState resetting()
    {
        return stop();
    }

    virtual RunState stop();

    virtual RunState stopping();

    virtual RunState stopped();

    virtual void uninitialize();

    virtual ConfigURI getConfigURI( ConfigOption configOption ) const;

private:

    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    BPC1( const BPC1& old ); // disallow copy constructor

    // scan configuraiton settings
    bool readConfig();

    static BPC1* Instance_;

    // returns true if data is requested from one of the readers
    bool isDataRequested();

    // Debugging outputs
    bool debug_;

    Timespan battTimeout_, muxTimeout_, poTimeout_;
    Timestamp startTimeA_, startTimeB_;
    Timestamp startTime_, muxTime_;

    // The status returned from the battery controller
    typedef enum
    {
        // ALARM BITS
        OVER_CHARGED_ALARM = 0x8000,
        TERMINATE_CHARGE_ALARM = 0x4000,
        OVER_TEMP_ALARM = 0x1000,
        TERMINATE_DISCHARGE_ALARM = 0x0800,
        REMAINING_CAPACITY_ALARM = 0x0200,
        REMAINING_TIME_ALARM = 0x0100,
        // STATUS BITS
        INITIALIZED = 0x0080,
        DISCHARGING = 0x0040,
        FULLY_CHARGED = 0x0020,
        FULLY_DISCHARGED = 0x0010
    } SMBStatus;


    // Stores the current response from the battery server
    char deviceResponseA_[2120];
    char deviceResponseB_[2120];

    // Holds the communications device
    UartStream uartA_;
    UartStream uartB_;

    // Stores the totals
    float totalCapacity_;
    float totalVoltage_;
    float totalCapacityA_;
    float totalVoltageA_;
    float totalCapacityB_;
    float totalVoltageB_;

    // Threshold values from config
    float batteryCapacityThreshold_;
    float batteryVoltageThreshold_;

    struct BattStick
    {
        // Constructor
        BattStick();

        // The battery temp
        float temp_;
        DataWriter *battTempWriter_;

        // The battery voltage
        float voltage_;
        DataWriter *battVoltageWriter_;

        // The battery current
        float current_;
        DataWriter *battCurrentWriter_;

        // The battery capacity
        float capacity_;
        DataWriter *battCapacityWriter_;

        // The battery status
        int status_;
        // And its writer
        DataWriter *battStatusWriter_;

        // The battery serial number
        unsigned int serialNumber_;
        DataWriter *battSerialWriter_;
    };

    // Array to store the battery packs and their associated writers
    BattStick battSticks_[NUMBATTSA + NUMBATTSB];

    UniversalDataWriter* batteryChargeWriter_;
    UniversalDataWriter* batteryVoltageWriter_;
    UniversalDataWriter* batteryDischargingWriter_;
    UniversalDataWriter* batteryFullyChargedWriter_;

    // Configuration Readers
    ConfigReader* batteryCapacityThresholdCfgReader_; // Amount of charge left at which we return to the surface
    ConfigReader* batteryVoltageThresholdCfgReader_;  // Amount of voltage left at which we return to the surface

    // Reads in the SMBus data from the Ocean Server cards and writes to the slate
    bool parseWriteDataA( int size, int offset );
    bool parseWriteDataB( int size, int offset );

    // Checks all battery sticks to see if their voltage has been logged
    // A return value of true indicates that data for a given stick has been recorded.
    // Relies on setVoltagesNull to clear them again for further checking
    bool voltagesPopulated();

    // Sets the voltage for each battery stick to null as a
    // flag to indicate that recent data has not been obtained
    // for a given stick
    void setVoltagesNull( void );

    // Sets the writer's validity to invalid for true or valid for false
    void setWritersInvalid( bool invalid );

    // Once all battery sticks have been freshly populated with
    // data, this function will add up all the grand totals
    void calculateTotals( void );

    // Checks to see that our current capacity is above the threshold
    void checkBatt( const float capacity, const float voltage );

    // Returns a non-zero number of bytes that are valid or 0 if not valid.
    // Sets the message offset based on the number of bytes received.
    int validData( int dataToCheck, int &msgOffset );

    // Sends the break (space) character to the Intelligent Battery and Power System
    void sendIBPSBreak( void );

    // Returns true if both ports are initialized to the banner menu offering hex output
    bool menusInitialized();

    // indicates whether things are ok to run
    bool ok_;

    // indicates that A or B banks have been sucessfully parsed
    bool aParsed_, bParsed_;

    // True if we have detected an under threshold value for capacity or voltage
    bool capacityFailed_;
    bool voltageFailed_;


};

#endif /*BPC1_H*/