ArGPS.h

/*
MobileRobots Advanced Robotics Interface for Applications (ARIA)
Copyright (C) 2004, 2005 ActivMedia Robotics LLC
Copyright (C) 2006, 2007 MobileRobots Inc.

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

If you wish to redistribute ARIA under different terms, contact 
MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
MobileRobots Inc, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481
*/


#ifndef ARGPS_H
#define ARGPS_H

#include "ariaTypedefs.h"
#include "ArFunctor.h"
#include "ariaUtil.h"
#include <string>
#include <vector>

class ArDeviceConnection; // for pointer in ArGPS

class ArGPS {

public:
    AREXPORT ArGPS();
    AREXPORT virtual ~ArGPS();

    AREXPORT void setDeviceConnection(ArDeviceConnection* deviceConn) { myDevice = deviceConn; }

    AREXPORT ArDeviceConnection* getDeviceConnection(ArDeviceConnection* deviceConn) const { return myDevice; }


    AREXPORT virtual bool connect();

    AREXPORT bool blockingConnect(unsigned long connectTimeout = 8000);

    
    typedef enum { 
      ReadFinished = 0,
      ReadError = 1, 
      ReadData = 2,
      ReadUpdated = 4
    } ReadFlags;

    AREXPORT virtual int read();

    AREXPORT void setIgnoreChecksum(bool ignore) { ignoreChecksum = ignore; }

    AREXPORT void logData() const;

    AREXPORT void printData() const;

    // @{
 
    typedef enum {  
        NoFix, BadFix, GPSFix, DGPSFix, PPSFix, 
        RTKinFix, FloatRTKinFix, DeadReckFix, 
        ManualFix, SimulatedFix, UnknownFixType 
     } FixType;

    AREXPORT FixType getFixType() const { return myFixType; }
    AREXPORT const char* getFixTypeName() const;

    AREXPORT bool havePosition() const { return myHavePosition; }
    AREXPORT bool haveLatitude() const { return myHavePosition; }
    AREXPORT bool haveLongitude() const { return myHavePosition; }

    AREXPORT double getLatitude() const { return myLatitude; }

    AREXPORT double getLongitude() const { return myLongitude; }

    AREXPORT ArTime getTimeReceivedPosition() const { return myTimeGotPosition; }

    AREXPORT bool haveSpeed() const { return myHaveSpeed; }

    AREXPORT double getSpeed() const { return mySpeed; }

    AREXPORT unsigned short getGPSPositionTimestamp() const { return myGPSPositionTimestamp; }

    AREXPORT unsigned short getNumSatellitesTracked() const { return myNumSatellitesTracked; }
    AREXPORT bool haveDGPSStation() const { return myHaveDGPSStation; }
    AREXPORT unsigned short getDGPSStationID() const { return myDGPSStationID; }

    AREXPORT bool havePositionError() const { return myHavePositionError; }
    AREXPORT double getPositionError() const { return myPositionError; }
    AREXPORT bool haveVerticalPositionError() const { return myHaveVerticalPositionError; }
    AREXPORT double getVerticalPositionError() const { return myVerticalPositionError; }

    AREXPORT bool haveCompassHeading() const { return myHaveCompassHeading; }
    AREXPORT double getCompassHeading() const { return myCompassHeading; }

    AREXPORT bool haveAltitude() const { return myHaveAltitude; }
    AREXPORT double getAltitude() const { return myAltitude; }

    AREXPORT bool haveHDOP() const { return myHaveHDOP; }
    AREXPORT double getHDOP() const { return myHDOP; }
    AREXPORT bool haveVDOP() const { return myHaveVDOP; }
    AREXPORT double getVDOP() const { return myVDOP; }
    AREXPORT bool havePDOP() const { return myHavePDOP; }
    AREXPORT double getPDOP() const { return myPDOP; }

protected:
    /* Last data received */
    double myLatitude;
    double myLongitude;
    bool myHavePosition;
    ArTime myTimeGotPosition;   // Time we got the data
    double mySpeed;
    bool myHaveSpeed;
    unsigned short myGPSPositionTimestamp;   // Timestamp provided by GPS device
    FixType myFixType;
    unsigned short myNumSatellitesTracked;
    double myAltitude;
    bool myHaveAltitude;
    unsigned short myDGPSStationID;
    bool myHaveDGPSStation;
    double myPositionError;
    bool myHavePositionError;
    double myVerticalPositionError;
    bool myHaveVerticalPositionError;
    double myCompassHeading;
    bool myHaveCompassHeading;
    bool myHaveHDOP;
    double myHDOP;
    bool myHaveVDOP;
    double myVDOP;
    bool myHavePDOP;
    double myPDOP;

    /* Read a doubleing point number out of a std::string, if possible.
     * @return true if the string was nonempty and @a target was modified.
     */
    bool readFloatFromString(std::string& str, double* target, double(*convf)(double) = NULL);

    /* Read an unsigned short integer out of a std::string, if possible.
     * @return true if the string was nonempty and @a target was modified.
     */
    bool readUShortFromString(std::string& str, unsigned short* target, unsigned short (*convf)(unsigned short) = NULL);


    /* Read a double from a member of a vector of strings, if it exists. */
    bool readFloatFromStringVec(std::vector<std::string>* vec, size_t i, double* target, double (*convf)(double) = NULL);

    /* Read a double from a member of a vector of strings, if it exists. */
    bool readUShortFromStringVec(std::vector<std::string>* vec, size_t i, unsigned short* target, unsigned short (*convf)(unsigned short) = NULL);

    /* Convert DDDMM.MMMM to decimal degrees */
    static double gpsDegminToDegrees(double degmin);

    /* Convert US nautical knots to meters/sec */
    static double knotsToMPS(double knots);
 
    /* Convert meters/sec to miles/hour */
    static double mpsToMph(double mps) { return mps * 2.23693629; }

    /* Convert meters to US feet */
    static double metersToFeet(double m) { return m * 3.2808399; }

    /* Convert US feet  to meters */
    static double feetToMeters(double f) { return f / 3.2808399; }
    

    /* Connection info */
    ArDeviceConnection *myDevice;
    bool myCreatedOwnDeviceCon;
    ArRetFunctorC<bool, ArGPS> myParseArgsCallback; 
    ArArgumentParser* myArgParser;
    
    /* NMEA message, divided into parts.  */
    typedef std::vector<std::string> MessageVector;

    /* NMEA message handler type. 
     * XXX Is the reference OK for ArFunctor?  
     */
    typedef ArFunctor1C<ArGPS, MessageVector*> Handler;

    /* Map of message identifiers to handler functors */
    typedef std::map<std::string, Handler*> HandlerMap;

    /* NMEA message handlers used by ArGPS */
    HandlerMap myHandlers;

    void handleGPRMC(MessageVector* message);
    Handler myGPRMCHandler;

    void handleGPGGA(MessageVector* message);
    Handler myGPGGAHandler;

    void handlePGRME(MessageVector* message);
    Handler myPGRMEHandler;

    void handlePGRMZ(MessageVector* message);
    Handler myPGRMZHandler;

    void handleHCHDG(MessageVector* message);
    Handler myHCHDGHandler;

    void handleGPGSA(MessageVector* message);
    Handler myGPGSAHandler;

    /*  NMEA scanner state.
     *  There are possabilities for opmitization here, such 
     *  as just storing the read data in a buffer and handling
     *  each field as it is found in the buffer, or building
     *  a list of char* for each field pointing into the buffer
     *  instead of copying each field into a std::string in the
     *  currentMessage vector, etc. etc.
     */
    const unsigned short MaxNumFields;
    const unsigned short MaxFieldSize; // bytes
    bool ignoreChecksum;

    MessageVector currentMessage;
    std::string currentField;
    char checksumBuf[3];
    short checksumBufOffset;
    bool inChecksum;
    bool inMessage;
    char currentChecksum;
    bool gotCR;

      // update state
    void beginMessage();
    void endMessage();
    void nextField();
    void beginChecksum();

};

#endif // ifdef ARGPS_H

---