CBIT.h

Go to the documentation of this file.

#ifndef CBIT_H_
#define CBIT_H_

#include "component/ComponentRegistry.h"
#include "component/SyncComponent.h"
#include "io/LPC3Reg.h"
#include "io/AnalogToDigital.h"
#include "sensorModule/Batt_Ocean_ServerIF.h"
#include "controlModule/VerticalControlIF.h"

#define NUM_BATTSA Batt_Ocean_ServerIF::NUM_BATTSA
#define NUM_BATTSB Batt_Ocean_ServerIF::NUM_BATTSB

class UniversalDataReader;
class UniversalDataWriter;

class CBIT : public SyncTestComponent
{
public:

    CBIT( const Module* module );

    virtual ~CBIT();

    void initialize( void );

    void run();

    void uninitialize( void );

    virtual ConfigURI getConfigURI( ConfigOption configOption ) const;

protected:

    // Slate input setting variables

    DataReader *clearFaultCmdReader_;

    DataReader *clearLeakFaultCmdReader_;

    // For Onboard pressure/humidity and other components
    DataReader* pressureReader_;
    DataReader* humidityReader_;
    DataReader* temperatureReader_;
    DataReader* speedCmdReader_;
    DataReader* verticalModeReader_;
    DataReader* empiricalFaultElevOffsetReader_;

    UniversalDataReader* depthReader_;
    UniversalDataReader *depthRateReader_;
    UniversalDataReader *elevatorAngleReader_;
    UniversalDataReader* latitudeReader_;
    UniversalDataReader* longitudeReader_;
    UniversalDataReader* pitchReader_;


    // Slate output variables

    UniversalDataWriter *faultWriter_;

    UniversalDataWriter *leakFaultWriter_;

    // State of shore power - True == ON False == OFF
    DataWriter* shorepowerWriter_;

    DataWriter* gfScanActiveWriter_;

    // Ground fault current
    DataWriter* gfChan0CurrentWriter_;
    DataWriter* gfChan1CurrentWriter_;
    DataWriter* gfChan2CurrentWriter_;
    DataWriter* gfChan4CurrentWriter_;
    DataWriter* gfChan5CurrentWriter_;
    DataWriter* gfChanOpenCurrentWriter_;

    // Emperical Fault Classifier writers
    DataWriter* empericalFaultDetectedWriter_;
    DataWriter* binnedDepthRateWriter_;
    DataWriter* empiricalFaultElevOffsetWriter_;

    // Configuration Readers
    ConfigReader* abortDepthCfgReader_;        // Depth at which we drop the weight. Should be greater than all depth envelopes
    ConfigReader* stopDepthCfgReader_;         // Depth at which we stop the mission. Should be greater than all depth envelopes and less than abort depth
    ConfigReader* humidityThresholdCfgReader_; // relative humidity
    ConfigReader* pressureThresholdCfgReader_; // Onboard pressure must measure greater than this offset from 1 ATM
    ConfigReader* tempThresholdCfgReader_;     // Only need to use kelvin for temperature deltas
    ConfigReader* vehicleOpenCfgReader_;
    ConfigReader* abortDepthTimeoutCfgReader_; // If this time has elapsed and we're still below abort depth, drop the weight, end the mission.
    ConfigReader* battFailReportCfgReader_;    // Report main battery failover at this multiple
    ConfigReader* envTimeoutCfgReader_;        // If this time has elapsed and pressure or humidity are still above threshold, end the mission.
    ConfigReader* faultClassifierCfgReader_;   // Runs the empirical fault classifier as part of CBIT if true
    ConfigReader* elevOffsetCalcCfgReader_;    // Runs the empirical fault classifier's elevator offset calculator as part of CBIT if true
    ConfigReader* battTempThresholdCfgReader_; // The allowable threshold for battery temperature
    ConfigReader* gfChan0ThresholdCfgReader_;  // Current above baseline that triggers a ground fault
    ConfigReader* gfChan1ThresholdCfgReader_;  // Current above baseline that triggers a ground fault
    ConfigReader* gfChan2ThresholdCfgReader_;  // Current above baseline that triggers a ground fault
    ConfigReader* gfChan4ThresholdCfgReader_;  // Current above baseline that triggers a ground fault
    ConfigReader* gfChan5ThresholdCfgReader_;  // Current above baseline that triggers a ground fault
    ConfigReader* gfScanTimeoutCfgReader_;     // How often to scan for ground faults

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

    friend class IBIT;
    friend class SBIT;

    // Is the WDT initialized properly?
    bool wdtInitialized_;

    // Runs the empirical fault classifier to detect anomolies
    // in vertical control
    void empiricalFaultClassification( void );

    // initialize vehicle config variables
    bool readConfig( void );

    // WDT and heartbeat
    void assertVitals( void );

    void checkBackplanePower( void );
    void checkCriticals( void );
    void checkDepth( void );

    void checkLeak( void );
    // Makes sure location is real
    void checkLocation( void );
    void checkMainBattery( void );
    void handleComponentFaults( void );
    void monitorBatteryTemps( void );
    void monitorCFCard( void );
    void monitorEnvironmentals( void );
    void monitorShorePower( void );

    // initiate GF scanning
    void scanGFChan( void );

    // Makes the appropriate log entry
    void reportGFFault( Str faultTxt );

    // Allows access to set timeout
    static void SetGFScanForce( bool forceVal );


    // Holds the time of when abort/stop depth was reached
    Timestamp abortStartTime_;
    Timestamp stopDepthStartTime_;
    Timespan abortDepthTimeout_;

    // Holds the time of when environmental (pressure, humidity) failure was detected
    Timestamp envFailStartTime_;
    Timespan envFailTimeout_;

    // Holds the time of when battery threshold failure was detected
    Timestamp battThresholdFailStartTime_;
    Timespan battThresholdFailTimeout_;

    // Holds the time of when GF scanning was started
    Timestamp gfStartTime_;
    Timespan gfScanTimeout_;
    Timespan gfChanSetupTimeout_;
    static bool GFScanForce_; // Used to force a scan immediately

    // Holds the time of when location was last checked to exist
    Timestamp locationCheckStartTime_;
    Timespan locationCheckTimeout_;
    bool nanLocationActive_; // True if location has been detected as nan
    bool nanLocationReported_;

    // Are we using hardware?
    bool useHardware_;

    // True if we have reached abort depth and are taking action
    bool abortDepthActive_;
    bool previouslyBelowAbort_;

    // True if we have reached stop depth and are taking action
    bool stopDepthActive_;
    bool previouslyBelowStop_;


    // True if we have detected water and have taken action
    bool waterDetectedCriticalSet_;

    // Variable is incremented each time water is detected, and decremented until 0 each time there isn't water detected.
    int waterDetectionCount_;

    // True if we have detected a main battery failure and are taking action
    bool batteryFailed_;

    // True if we have detected a load control backplane power loss and can't restore power.
    bool backplaneFailed_;

    // Number of times battery fail signal has been detected not-asserted->asserted
    int battFailCounts_;

    // Multiple of failures at which to report the battery failures to the user (e.g. 10 reports the first and every multiple of 10x after).
    int battFailReport_;

    // True if we have detected an over threshold value for humidity or pressure
    bool envFailed_;
    bool envExcursionFault_;

    // True if we have detected an over threshold value for battery data
    bool battThresholdFailed_;

    // For storing "baseline" environmental data
    float avgHumidity_;
    float samples_;

    // True if the CF card is missing and we are taking action
    bool cfMissing_;

    // indicates a GF scan is ongoing
    bool gfScanInProgress_;

    // indicates a GF fault has already been reported
    bool gfReported_;


    typedef enum
    {
        CHAN_5_SCAN,    // Activate and read chan 5 - 0
        CHAN_4_SCAN,
        CHAN_3_SCAN,
        CHAN_2_SCAN,
        CHAN_1_SCAN,
        CHAN_0_SCAN,
        OPEN_SCAN,
        CALCULATE,    // Determine GF and write values
    } GFSequence;

    GFSequence gfScan_;

    LPC3Reg::GFChan gfChan_;

    // Channel to read GF value
    AnalogToDigital adGFCurrent_;

    // Holds the time of when last fault classifier debug messege was published
    Timestamp debugEFCTimestamp_;
    Timespan debugEFCTimeout_;
    bool runFaultClassifier_;
    bool runElevOffsetCalc_;

    // EFC
    int   empiricalFaultCounter_;
    float empiricalFaultBinSum_;
    float empiricalFaultEleTmp_;
    float empiricalFaultPitchTmp_;
    double empiricalFaultDepth_;
    int empiricalFaultPositiveFlagCount_;
    Timestamp empiricalFaultTimestamp_;

    // EOM
    int   elevOffsetCounter_;
    bool  clearCounterEOM_;
    float elevOffsetEleTmp_;



    float gfCurrent5_, gfCurrent4_, gfCurrent3_, gfCurrent2_, gfCurrent1_, gfCurrent0_, gfCurrentOpen_;

    struct BattPack
    {
        // Constructor
        BattPack();

        // The battery voltage
        float voltage_;
        DataReader *battVoltageReader_;

        // The battery current
        float current_;
        DataReader *battCurrentReader_;

        // The battery temp
        float temp_;
        DataReader *battTempReader_;
    };

    DataReader *tmpTempReader_;
    // Array to store the battery packs and their associated writers
    BattPack battPacks_[NUM_BATTSA + NUM_BATTSB];


    float abortDepth_;
    float stopDepth_;
    double bitHumidityThreshold_;
    double bitPressureThreshold_;
    double bitTempThreshold_;
    double battTempThreshold_;
    bool cbitVehicleOpen_;
    float gfChan0Threshold_, gfChan1Threshold_, gfChan2Threshold_, gfChan4Threshold_, gfChan5Threshold_;

};

#endif /*CBIT_H_*/