Rowe_600.h

Go to the documentation of this file.

// TODO: Following the apparent naming convention, perhaps this module should
// actually be called [ADCP_Rowe]. Nothing in the interface is specific to the
// 600 kHz nominal center frequency anyway.

#ifndef Rowe_600_H
#define Rowe_600_H

#include "component/AsyncComponent.h"
#include "data/Matrix3x3.h"
#include "data/Point3D.h"
#include "data/Mtx.h"
#include "io/UartStream.h"
#include "io/LoadControl.h"
#include "logger/Logger.h"

#include "sensorModule/Rowe_600IF.h" // for Rowe_600IF::MAX_SIZE_OF_ENSEMBLE

static const unsigned char RTI_PREAMBLE[16] =
{
    0x80, 0x80, 0x80, 0x80, \
    0x80, 0x80, 0x80, 0x80, \
    0x80, 0x80, 0x80, 0x80, \
    0x80, 0x80, 0x80, 0x80
};
#define SIZE_OF_RTI_HEADER 16 // additional bytes in RTI header -- gives ensemble number & payload size
#define SIZE_OF_RTI_CHECKSUM 4 // additional bytes in device response after MATv4 payload
#define MAT_HEADER_SIZE 20  // bytes
#define MAT_NAME_SIZE    8  // bytes
static const char RTI_MAT_SIGNATURE[7] = { 0x00, 0x08, 0x45, 0x30, 0x30, 0x30, 0x30 };

class UniversalDataWriter;

class Rowe_600 : public AsyncComponent
{
public:

    Rowe_600( const Module* module );

    virtual ~Rowe_600();

//    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 start();
    }

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

    //*------------------- vehicle parameters --------------------------*/



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

    // scan configuration settings
    bool readConfig( void );

    // read configuration settings controlling interface functions
    bool readInterfaceConfigs( void );

    // read config settings controlling where data is logged
    bool readWriterConfigs( void );

    // read config settings controlling accuracy settings
    bool readAccuracyConfigs( void );

    // read config settings controlling offset settings
    bool readOffsetConfigs( void );

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

    // sets the system time on the instrument
    bool setInstrumentTime( void ); // TODO: Implement this.

    // read a full RTI ensemble from the uart
    bool readEnsemble( void );

    // skip the preamble -- parse the ensemble number and payload size
    // readEnsemble uses this to make sure it gets the entire ensemble
    bool parseRoweHeader( void );

    // reset all of the matrix offsets
    void resetMatrixOffsets( const int i = 0 );

    // pull the data out of deviceResponse_ into member parameters of this instance
    void processEnsemble( void );

    // write a message to the syslog with some information about hte matrix you found in the buffer
    void logMatrixOffset( int i );

    // read the ensemble data out of the int32 array
    int readEnsembleDataMatrix( void );

    // read the bottom track data out of the E000010 matrix (or the simulator)
    int readBottomTrackMatrix( void );

    // read ancillary data out of the E0000xx matrix
    int readAncillaryDataMatrix( void );

    // rotate the vector data from the instrument into the vehicle frame
    void rotateDataIntoVehicleFrame( void );

    // compute derived measurements (height above seafloor, speed, etc.) and scalar data quality metrics
    void preprocessData( void );

    // set bottom track writers as valid or invalid
    void setBottomTrackWritersInvalid( bool invalid );

    // set ensemble data writers as valid or invalid
    void setEnsembleDataWritersInvalid( bool invalid );

    // set water reference layer writers as valid or invalid
    void setWaterReferenceLayerWritersInvalid( bool invalid );

    // finally, write the data to the slate
    void writeData( void );

    // write waw ENS blob to a separate file
    void appendEnsembleToFile( void );

    // optionally report vector components from bottom track data to the syslog (controlled by verbosity config setting)
    void reportBottomTrackComponents( void );

    // Read a MATv4 matrix of single-precision floats into a Mtx container.
    int readMATv4float32( Mtx &tgt, const char* mat ); // TODO: Migrate this somewhere more suitable in the codebase.

    // standard member parameters   TODO: should these be moved up to the superclass?
    bool debug_; // flag for debugging outputs
    int verbosity_; // counter for verbosity level (messages to syslog, etc.)
    LoadControl loadControl_; // the interface for the assigned load control board
    Timespan powerOnTimeout_; // timeout for powering down/up
    UartStream uart_; // holds the communications device
    Timespan pausePeriod_; // pause period for Asynchronous component

    // device-specific member parameters
    Timestamp dataTimestamp_; // time the RTI preamble was successfully read
    Timespan sampleTime_;
    Timestamp startTime_; // time data request started
    char deviceResponse_[ sizeof( RTI_PREAMBLE ) + SIZE_OF_RTI_HEADER + Rowe_600IF::MAX_SIZE_OF_ENSEMBLE + SIZE_OF_RTI_CHECKSUM ]; // stores the current response from Rowe_600.
    bool hasDeviceResponse_; // flag indicating whether the interface received a complete & valid ensemble
    bool hasRoweHeader_;
    int numberOfBeamsCfg_;
    int numberOfBinsCfg_;
    bool writeBeamVelocityProfileCfg_, writeInstrumentVelocityProfileCfg_, writeEarthVelocityProfileCfg_, writeAmplitudeProfileCfg_, writeCorrelationProfileCfg_, writeGoodBeamPingsProfileCfg_, writeGoodEarthPingsProfileCfg_, writeRawEnsembleCfg_;
    float acousticBlankingDistanceCfg_;
    float bottomTrackVelocityAccuracyCfg_;
    float waterTrackVelocityAccuracyCfg_;
    float altitudeAccuracyCfg_;
//    float waterProfileVelocityAccuracyCfg_;
    double rollOffsetCfg_, pitchOffsetCfg_, headingOffsetCfg_;
    float maxSpeedCfg_;
    int waterReferenceLayerBin_;

    Matrix3x3 rotationFromInstrumentToVehicleFrame_;
    Matrix3x3 rotationFromVehicleToInstrumentFrame_;

    // filename for external ensemble file
    char ens_filename_[128]; // TODO: could be 32?

    // data from the Rowe binary packet
    int32_t ensembleNumber_; // int32 (4 byte integer) max 2147483647
    int32_t payloadSize_; // int32 (4 byte integer) max 2147483647
    Mtx beamVelocity_; // float32 [bins x beams] Beam velocity in m/s. (Contains the Beam coordinate velocity profile data as measured along each beam. The data is useful for diagnostic purposes and for when the user wants to perform their own transformation. It is arranged beam 0 to 3 for all bins.) Beam velocity is positive pointing (away from/toward?) the transducer.
    int beamVelocityOffset_;
    Mtx instrumentVelocity_; // float32 [bins x beams] Instrument velocity in m/s. (Contains the Instrument coordinate velocity profile. It is arranged X, Y, Z, Q for all bins.) X points from transducer _ to _, Y points from _ to _, and Z points from _ to _.
    int instrumentVelocityOffset_;
    Mtx earthVelocity_; // float32 [bins x beams] Earth velocity in m/s. (Contains the Earth coordinate velocity profile. It is arranged E, N, U, Q for all bins.)
    int earthVelocityOffset_;
    Mtx amplitude_; // float32 [bins x beams] Amplitude in dB. (Contains the Beam Amplitude profile. It is arranged beam 0 to 3 for all bins.)
    int amplitudeOffset_;
    Mtx correlation_; // float32 [bins x beams] Correlation where 1.0 = 100% and 0.5 = 50% correlation. (Contains the Beam Correlation profile. It is arranged beam 0 to 3 for all bins.)
    int correlationOffset_;
    Mtx goodBeamPings_; // int32 [bins x beams] (Contains the number of good pings for each bin/beam in the beam velocity data matrix E000001. It is arranged beam 0 to 3 for all bins.)
    int goodBeamPingsOffset_;
    Mtx goodEarthPings_; // int32 [bins x beams] (Contains the number of good pings for each bin/beam in the ENUQ velocity data matrix E000003. It is arranged NG3, NG3, NG3, NG4 for each bin. Where: NG3 = the Number of Good 3 beam solutions and NG4 = the Number of Good 4 beam solutions in the bin.)
    int goodEarthPingsOffset_;
    int ensembleData_[22]; // int32 [22 x 1] ensemble number, bins, beams, pings desired, pings acquired, status, time, serial number, firmware version, subsystem configuration
    int ensembleDataOffset_;
    Mtx ancillaryData_; // float32 [13 x 1] more ensemble data (E000009)
    int ancillaryDataOffset_;
    Mtx bottomTrack_; // float32 [54 x 1] bottom track data (E000010)
    int bottomTrackOffset_;
    // Since we are not planning to send NMEA strings to the ADCP, we will not bother parsing the variable-length E000011 data. That can be captured to the slate using the raw ensemble writer.
    bool waterReferenceLayerVelocitiesInvalid_;

    // individual ensemble parameters
    // ensembleNumber_ initially comes from the Rowe header, but is also at ensembleData_[0]. Check that they match for consistency, but do not keep track of two member parameters.
    int numberOfBins_;
    int numberOfBeams_;
    int numberOfDesiredPings_;
    int numberOfAcquiredPings_;
    int status_;
    Timestamp ensembleTimestamp_; // Set from the ensemble integers for year, month, day, hour, minute, second, hundredths
    // TODO: Decide whether to really deal with the serial number.
    // TODO: Decide whether to really deal with the system type & firmware version.
    // TODO: Decide whether to really deal with the subsystem configuration.
    //  The system type, firmware, and subsystem configuration variables will be necessary to handle if we get a multifrequency or multidirectional system in the future.
    // TODO: fill in the ancillary parameters from E000009

    // individual bottom track parameters
    float firstBottomTrackPingTime_, lastBottomTrackPingTime_;
    float headingDegrees_, pitchDegrees_, rollDegrees_; // TODO: Deprecated -- go straight to orientationVector_ and orientationMatrix_
    float waterTemperatureDegreesCelsius_;
    float systemTemperatureDegreesCelsius_;
    float salinityPPT_;
    float pressureBar_;
    float depthMeters_;
    float soundspeed_;
    bool statusOr_; // explicit cast from float32
    int numberOfBottomTrackBeams_; // explicit cast from float32
    int pingCount_; // explicit cast from float32
    Mtx verticalRange_; // float32 [4 x 1]
    Mtx signalToNoiseRatio_; // float32 [4 x 1]
    Mtx bottomTrackAmplitude_; // float32 [4 x 1]
    Mtx bottomTrackCorrelation_; // float32 [4 x 1]
    Mtx bottomTrackBeamVelocity_; // float32 [4 x 1]
    Mtx bottomTrackNumberOfPingsAveraged_; // float32 [4 x 1]
    Mtx bottomTrackInstrumentVelocity_; // float32 [4 x 1]
    Mtx bottomTrackNumberOfInstrumentSolutionsAveraged_; // float32 [4 x 1]
    Mtx bottomTrackEarthVelocity_; // float32 [4 x 1]
    Mtx bottomTrackNumberOfEarthSolutionsAveraged_; // float32 [4 x 1]

    // additional parameters for LRAUV software interface
    float altitude_; // we will probably use the minimum from Mtx verticalRange_
    Point3D velocityRelativeToGroundInVehicleFrame_;
    Point3D velocityRelativeToWaterInVehicleFrame_;

    // Config readers
    ConfigReader* verbosityCfgReader_; // reads an int to set the verbosity level
    ConfigReader* pausePeriodCfgReader_; // reads an int to set the verbosity level
    ConfigReader* writeBeamVelocityProfileCfgReader_;
    ConfigReader* writeInstrumentVelocityProfileCfgReader_;
    ConfigReader* writeEarthVelocityProfileCfgReader_;
    ConfigReader* writeAmplitudeProfileCfgReader_;
    ConfigReader* writeCorrelationProfileCfgReader_;
    ConfigReader* writeGoodBeamPingsProfileCfgReader_;
    ConfigReader* writeGoodEarthPingsProfileCfgReader_;
    ConfigReader* writeRawEnsembleCfgReader_; // reads a boolean indicating whether to record the raw ensemble to an external ENS file
    ConfigReader* acousticBlankingDistanceCfgReader_; //
    ConfigReader* numberOfBeamsCfgReader_; // reads an int to specify the expected number of beams
    ConfigReader* numberOfBinsCfgReader_; // reads an int to specify the expected number of bins
    ConfigReader* sampleTimeCfgReader_; // reads a float to specify the number of seconds a sample is allowed to take
    ConfigReader* bottomTrackVelocityAccuracyCfgReader_; // reads a float indicating the rated accuracy of the bottom track velocity
    ConfigReader* waterTrackVelocityAccuracyCfgReader_; // reads a float indicating the rated accuracy of the bottom track velocity
    ConfigReader* altitudeAccuracyCfgReader_; // reads a float indicating the rated accuracy of the bottom track velocity
//    ConfigReader* waterProfileVelocityAccuracyCfgReader_; // reads a float indicating the rated accuracy of the bottom track velocity
    // TODO: A configuration reader pointing to a file with the instrument firmware configuration.
    // TODO: A configuration reader pointing to a file with the calibrated transformation from instrument to vehicle coordinates. (This should be a binary file of some sort -- could use Mtx for now, but mat-file might be better in the future, since we'd like double-precision for something critical like this...)
    ConfigReader* rollOffsetCfgReader_; // reads a double
    ConfigReader* pitchOffsetCfgReader_; // reads a double
    ConfigReader* headingOffsetCfgReader_; // reads a double
    ConfigReader* maxSpeedCfgReader_; // reads a float
    ConfigReader* waterReferenceLayerBinCfgReader_; // reads an int

    // Universal readers
    // TODO: Does the Rowe ADCP interface actually need to know location for anything?

    // Universal writers
    UniversalDataWriter* altitudeWriter_;
    UniversalBlobWriter* velocityWrtGroundWriter_;
    // UniversalBlobWriter* velocityWrtWaterWriter_;
    BlobWriter* velocityWrtWaterWriter_;

    // component-level writers to the slate
    DataWriter* firstBottomTrackPingTimeWriter_;
    DataWriter* lastBottomTrackPingTimeWriter_;
    DataWriter* headingWriter_;
    DataWriter* pitchWriter_;
    DataWriter* rollWriter_;
    DataWriter* waterTemperatureWriter_;
    DataWriter* systemTemperatureWriter_;
    DataWriter* salinityWriter_;
    DataWriter* pressureWriter_;
    DataWriter* depthWriter_;
    DataWriter* soundspeedWriter_;
    DataWriter* statusOrWriter_;
    DataWriter* numberOfBottomTrackBeamsWriter_;
    DataWriter* pingCountWriter_;

    BlobWriter* verticalRangeWriter_;
    BlobWriter* signalToNoiseRatioWriter_;
    BlobWriter* bottomTrackAmplitudeWriter_;
    BlobWriter* bottomTrackCorrelationWriter_;
    BlobWriter* bottomTrackBeamVelocityWriter_;
    BlobWriter* bottomTrackNumberOfPingsAveragedWriter_;
    BlobWriter* bottomTrackInstrumentVelocityWriter_;
    BlobWriter* bottomTrackNumberOfInstrumentSolutionsAveragedWriter_;
    BlobWriter* bottomTrackEarthVelocityWriter_;
    BlobWriter* bottomTrackNumberOfEarthSolutionsAveragedWriter_;

    DataWriter* ensembleNumberWriter_;
    DataWriter* payloadSizeWriter_;
    DataWriter* numberOfBeamsWriter_;
    DataWriter* numberOfBinsWriter_;
    DataWriter* numberOfDesiredPingsWriter_;
    DataWriter* numberOfAcquiredPingsWriter_;
    DataWriter* statusWriter_;
    DataWriter* ensembleTimestampWriter_;

    BlobWriter* beamVelocityWriter_;
    BlobWriter* instrumentVelocityWriter_;
    BlobWriter* earthVelocityWriter_;
    BlobWriter* amplitudeWriter_;
    BlobWriter* correlationWriter_;
    BlobWriter* goodBeamPingsWriter_;
    BlobWriter* goodEarthPingsWriter_;

    BlobWriter* rawEnsembleWriter_;
};
#endif /*Rowe_600_H*/