CTD_NeilBrown.h

Go to the documentation of this file.

#ifndef CTD_NEILBROWN_H_
#define CTD_NEILBROWN_H_

#include <vector>       // std::vector

#include "component/AsyncComponent.h"
#include "io/LoadControl.h"
#include "io/UartStream.h"
#include "logger/Logger.h"

class UniversalDataReader;
class UniversalDataWriter;

class CTD_NeilBrown: public AsyncComponent
{
public:
    CTD_NeilBrown( const Module* module );
    virtual ~CTD_NeilBrown();

    virtual void run();

    virtual RunState start();

    virtual RunState starting();

    virtual RunState pause();

    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();

    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.
    CTD_NeilBrown( const CTD_NeilBrown& old ); // disallow copy constructor

    void readConfig();

    bool parseResponse( char *data );

    unsigned int bufferOffset_;

    UniversalDataReader* latitudeReader_;

    DataReader* gfScanActiveReader_;

    UniversalDataWriter* densityWriter_;
    UniversalDataWriter* depthWriter_;
    UniversalDataWriter* pressureWriter_;
    UniversalDataWriter* salinityWriter_;
    UniversalDataWriter* temperatureWriter_;
    UniversalDataWriter* conductivityWriter_;

    DataWriter* binMedianConductivityWriter_;
    DataWriter* binMeanConductivityWriter_;
    DataWriter* binStandardDeviationConductivityWriter_;
    DataWriter* binMedianTemperatureWriter_;
    DataWriter* binMeanTemperatureWriter_;
    DataWriter* binStandardDeviationTemperatureWriter_;
    DataWriter* binMedianSalinityWriter_;
    DataWriter* binMeanSalinityWriter_;
    DataWriter* binStandardDeviationSalinityWriter_;

    ConfigReader* maxPressBoundCfgReader_;
    ConfigReader* minPressBoundCfgReader_;
    ConfigReader* offsetCfgReader_;
    ConfigReader* maxSalinityBoundCfgReader_;
    ConfigReader* minSalinityBoundCfgReader_;


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

    // Debugging outputs
    bool debug_;

    // Instance of load controller
    LoadControl loadControl_;

    // the pressure reading is out of bounds. We only want to report the error once
    bool pressBoundingError_;

    Timespan ctdTimeout_;
    Timespan uartTimeout_;
    Timespan pausePeriod_;
    Timestamp startTime_;

    // Stores the current response from the device
    char deviceResponse_[512];

    // Holds the communications device
    UartStream uart_;

    float latitude_;
    float conductivity_, temperature_, pressureDB_, depth_, salinity_, density_;
    bool badConductivity_, badTemperature_, badPressure_, badSalinity_;
    float pressureOffset_;
    float maxPressBound_;
    float minPressBound_;
    float maxSalinityBound_;
    float minSalinityBound_;

    // container for history to use in temporal binning
    size_t temporal_bin_count_;
    std::vector<float> temporal_bin_conductivity_;
    std::vector<float> temporal_bin_temperature_;
    std::vector<float> temporal_bin_salinity_;
    Timestamp binTime_;

    // If true, ignore next line
    bool nextLineQuestionable_;

    void go();  // What we do if we are halted.

    bool receive(); // Try receiving the data from the UART
    bool getSimulatedData(); // Try reading data from the SimSlate
    void preprocessData(); // Perform onboard processing and quality checks
    void writeData(); // write data out to the slate
    void update_temporal_bin(); // update the onboard binning
    void calculate_and_report_temporal_bin_statistics(); // calculate statistics when bin is full

    // Calculates a NMEA checksum
    static int CalcChecksum( const char* response );

};

#endif /* CTD_NEILBROWN_H_ */