DAT.h

Go to the documentation of this file.

#ifndef DAT_H
#define DAT_H

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

#include "data/Matrix3x3.h"

class UniversalDataReader;
class UniversalDataWriter;

class DAT : public SyncSensorComponent
{
public:

    DAT( const Module* module );

    virtual ~DAT();

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

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

    void readConfig();

    ConfigReader* localAddressCfgReader_;

    // Slate inputs
    DataReader *queryAddressRequestedReader_;
    DataReader *numberOfPingsRequestedReader_;

    // universal outputs
    UniversalDataWriter* rxTimeWriter_;
    UniversalDataWriter* txTimeWriter_;

    // Slate outputs
    DataWriter* lvl1Writer_;
    DataWriter* lvl2Writer_;
    DataWriter* lvl3Writer_;
    DataWriter* lvl4Writer_;
    DataWriter* agcWriter_;
    DataWriter* idxPeakWriter_;
    DataWriter* idxFitWriter_;
    DataWriter* idxPhaseWriter_;
    DataWriter* phaseAWriter_;
    DataWriter* phaseBWriter_;
    DataWriter* phaseCWriter_;
    DataWriter* vectorMagnitudeWriter_;
    DataWriter* rawAzimuthWriter_;
    DataWriter* rawElevationWriter_;
    DataWriter* calibratedAzimuthWriter_;
    DataWriter* calibratedElevationWriter_;
    DataWriter* rotatedAzimuthWriter_;
    DataWriter* rotatedElevationWriter_;
    DataWriter* remoteAddressWriter_;
    DataWriter* localAddressWriter_;
    DataWriter* rangeWriter_;
    DataWriter* onewayCmdWriter_;

    DataWriter* tAzimuthWriter_;
    DataWriter* tElevationWriter_;
    DataWriter* vAzimuthWriter_;
    DataWriter* vElevationWriter_;

    BlobWriter* tDirectionWriter_;
    BlobWriter* vDirectionWriter_;

    bool debug_;
    int verbosity_;
    char deviceResponse_[396]; // Stores the current response from the modem

    Matrix3x3 transformationFromTetrahedronToVehicleFrame_, transformationFromVehicleToTetrahedronFrame_; // alignment matrices from vehicle to instrument frame and vice versa

    // Instance of load controller
    LoadControl loadControl_;
    Timestamp startTime_;
    Timestamp powerOffTimeStart_;
    Timespan poTimeout_, powerDownTimeout_;

    UartStream uart_; // Holds the communications device

    int localAddressCfgSetting_;
    bool commandModeSent_, commandModeAcknowledged_, localAddressSettingSent_, localAddressSettingAcknowledged_; // TODO: These state flags are clunky -- it would be cleaner if we just made this component asynchronous and let the serial port wait for a reasonable time for a response.
    Timespan acousticResponseTimeout_;
    int remoteAddressRequested_, numPingsRequested_; // The query from another component, consisting of the address of the modem from which the DAT is requesting data and the number of return pings it is requesting
    int numPingsReceived_;
    bool gotResponseNotReceived_, gotRangeMessage_, gotDirectionMessage_;
    int commRate_;

//    bool rangeRequested_; // Has info from the DAT been requested?
//    bool oneWayRequested_; // Has oneway mode has been requested of the homing target?
    double range_, phaseA_, phaseB_, phaseC_;
    Timestamp transmitPingTime_, receivePingTime_;
    int levelA_, levelB_, levelC_, levelD_, agc_, idxPeak_;
    float idxFit_, idxPhase_, vectorMagnitude_;
    float rawAzimuth_, rawElevation_, calibratedAzimuth_, calibratedElevation_, rotatedAzimuth_, rotatedElevation_;
    int remoteAddress_, localAddress_;

    Point3D directionInTetrahedronFrame_, directionInVehicleFrame_;
    float azimuthInTetrahedronFrame_, elevationInTetrahedronFrame_;
    float azimuthInVehicleFrame_, elevationInVehicleFrame_;

    void logVoltageAndCurrent();


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

    bool gotNewQuery( void );

    Timestamp requestRange( const int remoteAddress, const int numPings );

    int clearUserPrompt( void );

    void readAndParseResponses( void );

    void parseResponses( void );

    void cleanResponse( void );

    bool parseDirectionMessage( void );

    bool parseRangeMessage( void );

    void publishData( void );

    Point3D phaseToUnitVector( const double phaseA, const double phaseB, const double phaseC, const double phaseD );

    void unitVectorToAzimuthAndElevation( Point3D &uhat, float &azimuth, float &elevation ) __attribute__( ( deprecated ) ); // TODO migrate this elsewhere

    void azimuthAndElevationToUnitVector( float &azimuth, float &elevation, Point3D &uhat ) __attribute__( ( deprecated ) ); // TODO migrate this elsewhere

    void phasesToDirectionInVehicleFrame( void );

    void directionsToAngles( void );

    bool getSimulatedMeasurements( void ); // TODO fix simulator where appropriate so that this method just reads sim outputs and rewrites them to the slate in the appropriate places

};

#endif /*DAT_H*/