NAL9602.h

Go to the documentation of this file.

/****

!!! The NAL9602-LP requires the following active profile to be set on the bench prior to use in the vehicle !!!

Set +PNAV=4 for at sea operation

Set ^GRS=3,30 for GPS safety reset

Echo Off



ACTIVE PROFILE:

E0 Q0 V1 ^CAL1 ^ID0 ^RMF1 ^GAO0 ^TMD1 ^TBR5.0 ^TTKT255 ^UE0 ^START0

+IPR6 +SBDMTA1 +SBDAREG0 +CIER0000 *R1 *S1 +PP1 +PNAV4 ^BIGR0 ^ERF0

^TBRT0.0 ^TTKTT255 ^TBRE0.0 ^TTKTE255 ^CALT1 ^CALE1

^TBRA3.0 ^TTKTA255 ^TBRTA1.0 ^TTKTTA255 ^TBREA1.0 ^TTKTEA255

^PR0 ^WFI0 ^ITE0 ^MSA000,0,0 ^MSW10 ^SPSR0,10,4,120 ^SSR0

^MSB3,10 ^MSE3 ^MSWT5 ^MSWE5 ^S0,0,0,0,0 ^SR3 ^STEW0

^SPSRT0,10,4,120 ^SPSRE0,10,4,120

^USAIG0 ^BASMR0,0,0 ^GRS3,30

***/

#ifndef NAL9602_H
#define NAL9602_H

#include "component/SyncComponent.h"
#include "data/StrValue.h"
#include "io/UartStream.h"
#include "io/LoadControl.h"
#include "logger/Logger.h"
#include "utils/Timestamp.h"
#include "utils/FlexArray.h"
#include "NAL9602IF.h"

#include <stdint.h>

class UniversalDataReader;
class UniversalDataWriter;

#define READ_TIMEOUT_MSEC 6000
#define MAX_DOWNLINK_MSG_BYTES 340L
#define DOWNLINK_DATA_OFFSET ( sizeof(uint32_t) + 2 * sizeof(uint16_t) )
#define MAX_DOWNLINK_DATA_BYTES ( MAX_DOWNLINK_MSG_BYTES - DOWNLINK_DATA_OFFSET )
#define MAX_UPLINK_MSG_BYTES 270L
#define MAX_UPLINKS_PER_SESSION 10

#define MAX_GPS_SATS_9602 NAL9602IF::MAX_GPS_SATS_9602
#define MAX_SATS_PER_LINE 4

class NAL9602: public SyncSensorComponent
{
public:

    NAL9602( const Module* module );

    virtual ~NAL9602();

    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;

    virtual ConfigURI getConfigURI( ConfigOption configOption, ElementURI forElement ) 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.
    NAL9602( const NAL9602& old ); // disallow copy constructor

    // Slate inputs
    UniversalDataReader* depthReader_;
    UniversalDataReader* latitudeReader_;
    UniversalDataReader* longitudeReader_;

    // Slate outputs
    DataWriter* numSatellitesWriter_;
    DataWriter* goodFixWriter_;
    DataWriter* sigQualityWriter_;
    DataWriter* sogWriter_;
    DataWriter* cogWriter_;

    UniversalDataWriter* timeFixWriter_;
    UniversalDataWriter* latitudeFixWriter_;
    UniversalDataWriter* longitudeFixWriter_;
    UniversalBlobWriter* locationFixWriter_;
    UniversalDataWriter* communicationsWriter_;

    ConfigReader* surfaceThresholdCfgReader_;
    ConfigReader* sendDataToShoreCfgReader_;
    ConfigReader* checkMTQueueCfgReader_; // Tells the component whether to explicitly check for messages queued for the NAL9602 even if an Iridium transaction isn't required.
    ConfigReader* gpsFailTimeoutCfgReader_;
    ConfigReader* iridiumFailTimeoutCfgReader_; // How long to wait for an Iridium session to check for waiting MT SBD messages in the queue
    ConfigReader* requestGGACfgReader_;


    // Used to save state since there are long potential waiting periods for this device to respond
    enum CommsState
    {
        SLEEPING,
        WAKING,
        CMDMODE,
        AWAKE,
        NEED_FIX,
        NEED_GSV,
        GET_SIG_QUALITY,
        SENDING_FILL_BUFFER,
        SENDING_TRANSMIT,
        SENDING_VERIFY,
        RECEIVING_1,
        RECEIVING_2,
        MTQUEUE_QUALITY,
        MTQUEUE_SESSION,
        GO_TO_SLEEP
    };

    void waking();
    void cmdMode();
    void awake();
    void needFix();
    void needGSV(); // Gets the GPGSV data from the GPS.
    void getSigQuality();
    void sendingFillBuffer();
    void sendingTransmit();
    void sendingVerify();
    void receiving1();
    void receiving2();
    void goToSleep();
    void getMTQueueSignalStrength(); // Used only for session initiation for checking status of MT queue. Doesn't alter communicationsDone_
    void sessionMTQueueVerify(); // Used only for session initiation verification for checking status of MT queue.


    struct SNRWriters
    {
        // Constructor
        SNRWriters();

        // And the writer
        DataWriter *snrWriter_;
    };

    // Array to store the battery packs and their associated writers
    SNRWriters snrWriters_[MAX_GPS_SATS_9602];

    // To hold our state
    CommsState commsState_;

    char modemResponse_[512];

    char command_[512];

    Timespan powerDownTimeout_, poResetTimeout_;
    Timespan requestTimeout_;
    Timespan gpsFailTimeout_;
    Timespan iridiumMTQueueTimeout_;
    Timespan bufferFillTimeout_;

    Timestamp startTime_, powerOnTimeStart_, powerOffTimeStart_, needFixStartTime_, utcTime_, needMTQueueStartTime_;

    bool gotFix_;
    bool gotMTQueue_; // To prevent having to re-check queue status every time needGSV gets called. Just do it once per GPS fix.

    FlexArray<int*> snrData_;

    // indicates whether things are ok to run
    bool ok_;

    float surfaceThreshold_;
    bool sendDataToShore_;
    bool checkMTQueue_; // Tells the component whether to explicitly check for messages queued for the NAL9602 even if an Iridium transaction isn't required.
    StrValue keyText_;
    int requestGGA_;

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

    // Used for storing status of messages coming from GSS to NAL9602
    int uplinkStatus_, uplinkSeqNo_;
    unsigned int nUplinkBytes_, nPendingUplinks_;

    // Lets us know when we've got nothing left to send back to shore
    bool communicationsDone_;

    // True if a command has been received from shore since the last time power was applied
    bool cmdReceived_;

    // True if a fix request has been sent
    bool fixRequested_;

    // We're counting down to throw a failure if we haven't gotten a fix in the required time.
    bool gpsTimeoutArmed_;

    // How long we spend trying to check the Iridium MT queue
    bool iridiumTimeoutArmed_;

    // True if a GSV NMEA request has been sent
    bool gsvRequested_;

    // True if an Iridium signal quality request has been sent
    bool qualityRequested_;

//    // Send the current queue of outgoing messages and recieves anything
//    // in the queue from the GSS.

    //bool sendMessage( const unsigned char *msg, size_t nMsgBytes );

    // Fills the buffer for next time a SBD session is initiated
    bool fillBuffer( const unsigned char *msg, size_t nMsgBytes );

    // Checks the response from filling the buffer and looks for errors.
    // Then initiates an SBD session
    bool initiateSession();

    // Checks the response from session initiation
    // And verifies that the data was indeed transmitted
    bool verifySessionXmit();

    // Clears the mobile originated buffer via the +SBDD0 command
    bool clearMOBuffer();

//    /// Get recieved (uplinked) message(s) through
//    /// modem and add to uplink queue
//    int getIncomingMessages();

    bool retrieveAndQueueIncoming( int nUplinkBytes );

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

    // Debugging outputs
    bool debug_;

    UartStream uart_;
    LoadControl loadControl_;

    // "Quality" as defined by NMEA standard.
    // In the case of the NAL9602-LP:
    // 0 = Invalid Fix, 1 or 2 = Valid Fix, 3 = Estimated Dead Reckoning
    enum DataQuality
    {
        INVALID,
        VALID_ONE,
        VALID_TWO,
        DEAD_RECKON
    };

    enum Hemisphere
    {
        NORTHERN_HEMI,
        SOUTHERN_HEMI,
        EASTERN_HEMI,
        WESTERN_HEMI,
        INVALID_HEMISPHERE
    };

    //
    // Save Gps time in the following structure:
    //
    struct NmeaUTCTime
    {
        // Constructor
        NmeaUTCTime();

        int hours_;
        int minutes_;
        int seconds_;
        int centiSeconds_;
    };

    //
    // Save GPS date in the following structure:
    //
    struct NmeaUTCDate
    {
        // Constructor
        NmeaUTCDate();

        int day_;
        int month_;
        int year_;
    };

    struct Fix
    {
        // Constructor
        Fix();

        NmeaUTCTime utctime_;

        NmeaUTCDate utcdate_;

        // Latitude (degrees)
        double latitude_;

        Hemisphere nsHemisphere_;

        // Longitude (degrees)
        double longitude_;

        Hemisphere ewHemisphere_;

        bool status_; // RMC only. A==valid, V==invalid

        float sog_;

        float cog_;

        DataQuality quality_;

        short nSatellites_;

        float hdop_;

        float altitude_;

        float geoidHeight_;

        short dgpsDataAge_;

        short dgpsStationId_;
    };

    Fix fix_;

    void getReceivedSignalStrength();

    short sigQuality_;

    bool belowSurfaceThreshold( void );

    bool getFix( void );

    bool requestFix( void );

    bool requestGSV( void );

    enum SentenceType
    {
        GPGGA, GPGSA, GPRMC, UNKNOWN_NMEA_TYPE
    };

    static SentenceType GetNmeaSentenceType( const char *sentence );

    bool parseGGAFix( const char *ggaSentence );

    bool parseRMCFix( const char *rmcSentence );

    bool parseGSV( void );

    bool goodGGAFixIndicator( const char *ggaSentence );
    bool goodRMCFixIndicator( const char *rmcSentence );

    bool radioEnabled_;

    static double ParseLatitude( const char *nmeaString );

//    /// Print latitude in "dd mm.xx" format. (Input in radians)
//    static char *PrintLatitude( double degrees );

    static double ParseLongitude( const char *nmeaString );

//    /// Print longitude in "ddd mm.xx" format. (Input in radians)
//    static char *PrintLongitude( double degrees );

    Hemisphere char2Hemisphere( unsigned char hem );

    char* resendSBDFilename_;

    struct SendPacket
    {
        uint32_t timeT_;
        uint16_t index_;
        uint16_t packetsLeft_;
        uint8_t data_[ MAX_DOWNLINK_DATA_BYTES ];
        size_t dataSize_;
        int debug_;
        Str sendFilename_;
        size_t sendFilesize_;
    } sendPacket_;

    unsigned int sentIndex_;

};

#endif /*NAL9602_H*/