WetLabsBB2FL.h

Go to the documentation of this file.

#ifndef WETLABSBB2FL_H
#define WETLABSBB2FL_H

#include "WetLabsBB2FLIF.h"

#include <vector>       // std::vector

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

class UniversalDataWriter;

class WetLabsBB2FL : public AsyncComponent
{
public:

    WetLabsBB2FL( const Module* module );

    virtual ~WetLabsBB2FL();

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

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

    void readConfig();

    // Parses the header information sent back
    bool parseHeader();

    // Parses the information sent back
    bool parse();

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

    // Sends data to DataWriters
    void writeData();

    // updates the bin used for onboard binning
    void update_temporal_bin();

    // calculates bin statistics and writes to the slate
    void calculate_and_report_temporal_bin_statistics();


#define MAX_DEVICE_RESPONSE ( 255U )

    // Stores the current response from the device
    char deviceResponse_[MAX_DEVICE_RESPONSE + 1];

    UartStream uart_;

    LoadControl loadControl_;

    Timestamp startTime_;

    Timespan timeout_;

    Timespan pausePeriod_;

    Timestamp dataTime_;

    DataWriter* output470Writer_;
    DataWriter* output650Writer_;
    DataWriter* outputChlWriter_;
    DataWriter* volScat470Writer_;
    DataWriter* volScat650Writer_;
    DataWriter* backScat470Writer_;
    DataWriter* backScat650Writer_;

    DataWriter* binMedianChlWriter_;
    DataWriter* binMeanChlWriter_;
    DataWriter* binVarianceChlWriter_;

    UniversalDataWriter* chlConcWriter_;

    ConfigReader* timeoutCfgReader_;
    ConfigReader* periodCfgReader_;
    ConfigReader* serialCfgReader_;
    ConfigReader* scaleFactor470CfgReader_;
    ConfigReader* darkCounts470CfgReader_;
    ConfigReader* scaleFactor650CfgReader_;
    ConfigReader* darkCounts650CfgReader_;
    ConfigReader* scaleFactorChlCfgReader_;
    ConfigReader* darkCountsChlCfgReader_;
    ConfigReader* chlAccuracyCfgReader_;

    UniversalDataReader* salinityReader_;

    float scaleFactor470_;
    int darkCounts470_;
    float scaleFactor650_;
    int darkCounts650_;
    float scaleFactorChl_;
    int darkCountsChl_;

    int samplesToAverage_;

    int currentSamplesToAverage_;

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

    // Serial number of this device
    Str serial_;

    bool debug_;

    // Raw measurement for backscatter at 470nm
    int output470_;

    // Raw measurement for backscatter at 650nm
    int output650_;

    // Raw measurement for chl fluorescence
    int outputChl_;

    // Output variable
    float volScat470_;

    // Output variable
    float backScat470_;

    // Output variable
    float volScat650_;

    // Output variable
    float backScat650_;

    // Output variable
    float chlConc_;

};
#endif /*WETLABSBB2FL_H*/