Subversion Repositories FlightCtrl

// -*- tab-width: 4; Mode: C++; c-basic-offset: 4; indent-tabs-mode: t -*-

/// @file       GPS.h
/// @brief      Interface definition for the various GPS drivers.

#ifndef GPS_h
#define GPS_h

#include <inttypes.h>
//#include "Stream.h"

/// @class      GPS
/// @brief      Abstract base class for GPS receiver drivers.
class GPS
{
public:

    /// Update GPS state based on possible bytes received from the module.
    ///
    /// This routine must be called periodically to process incoming data.
    ///
    /// GPS drivers should not override this function; they should implement
    /// ::read instead.
    ///
    void                        update(void);

    void (*callback)(unsigned long t);

    /// GPS status codes
    ///
    /// \note Non-intuitive ordering for legacy reasons
    ///
    enum GPS_Status {
        NO_GPS = 0,             ///< No GPS connected/detected
        NO_FIX = 1,             ///< Receiving valid GPS messages but no lock
        GPS_OK = 2              ///< Receiving valid messages and locked
    };

    /// Query GPS status
    ///
    /// The 'valid message' status indicates that a recognised message was
    /// received from the GPS within the last 500ms.
    ///
    /// @returns                        Current GPS status
    ///
    GPS_Status          status(void) {
        return _status;
    }

    /// GPS time epoch codes
    ///
    enum        GPS_Time_Epoch {
        TIME_OF_DAY     = 0,            ///<
        TIME_OF_WEEK    = 1,            ///< Ublox
        TIME_OF_YEAR    = 2,            ///< MTK, NMEA
        UNIX_EPOCH              = 3                     ///< If available
    };                                                                  ///< SIFR?


    /// Query GPS time epoch
    ///
    /// @returns                        Current GPS time epoch code
    ///
    GPS_Time_Epoch              epoch(void) {
        return _epoch;
    }

    /// Startup initialisation.
    ///
    /// This routine performs any one-off initialisation required to set the
    /// GPS up for use.
    ///
    /// Must be implemented by the GPS driver.
    ///
    virtual void        init(void) = 0;

    // Properties
    long        time;                   ///< GPS time (milliseconds from epoch)
    long        date;                   ///< GPS date (FORMAT TBD)
    long        latitude;               ///< latitude in degrees * 10,000,000
    long        longitude;              ///< longitude in degrees * 10,000,000
    long        altitude;               ///< altitude in cm
    long        ground_speed;   ///< ground speed in cm/sec
    long        ground_course;  ///< ground course in 100ths of a degree
    long        speed_3d;               ///< 3D speed in cm/sec (not always available)
    int         hdop;                   ///< horizontal dilution of precision in cm
    uint8_t num_sats;           ///< Number of visible satelites

    /// Set to true when new data arrives.  A client may set this
    /// to false in order to avoid processing data they have
    /// already seen.
    bool        new_data;

    // Deprecated properties
    bool        fix;                    ///< true if we have a position fix (use ::status instead)
    bool        valid_read;             ///< true if we have seen data from the GPS (use ::status instead)

    // Debug support
    bool        print_errors;   ///< deprecated

    // HIL support
    virtual void setHIL(long time, float latitude, float longitude, float altitude,
                        float ground_speed, float ground_course, float speed_3d, uint8_t num_sats);

    /// Time in milliseconds after which we will assume the GPS is no longer
    /// sending us updates and attempt a re-init.
    ///
    /// 1200ms allows a small amount of slack over the worst-case 1Hz update
    /// rate.
    ///
    uint32_t    idleTimeout;

        // our approximate linear acceleration in m/s/s
        float acceleration(void) { return _acceleration; }

        // the time we got our last fix in system milliseconds
        uint32_t last_fix_time;

protected:
    /// Stream  *_port;                 ///< port the GPS is attached to
    /// Constructor
    ///
    /// @note The stream is expected to be set up and configured for the
    ///       correct bitrate before ::init is called.
    ///
    /// @param  s       Stream connected to the GPS module.
    ///
    GPS(void *s) {};

    /// read from the GPS stream and update properties
    ///
    /// Must be implemented by the GPS driver.
    ///
    /// @returns                        true if a valid message was received from the GPS
    ///
    virtual bool        read(void) = 0;

    /// perform an endian swap on a long
    ///
    /// @param  bytes           pointer to a buffer containing bytes representing a
    ///                                         long in the wrong byte order
    /// @returns                        endian-swapped value
    ///
    long                        _swapl(const void *bytes);

    /// perform an endian swap on an int
    ///
    /// @param  bytes           pointer to a buffer containing bytes representing an
    ///                                         int in the wrong byte order
    /// @returns                        endian-swapped value
    int16_t                             _swapi(const void *bytes);

    /// emit an error message
    ///
    /// based on the value of print_errors, emits the printf-formatted message
    /// in msg,... to stderr
    ///
    /// @param  fmt                     printf-like format string
    ///
    /// @note deprecated as-is due to the difficulty of hooking up to a working
    ///       printf vs. the potential benefits
    ///
    void                        _error(const char *msg);

    /// Time epoch code for the gps in use
    GPS_Time_Epoch                              _epoch;

private:


    /// Last time that the GPS driver got a good packet from the GPS
    ///
    uint32_t                            _idleTimer;

    /// Our current status
    GPS_Status                                  _status;

        // previous ground speed in cm/s
    uint32_t _last_ground_speed;

        // smoothed estimate of our acceleration
        float _acceleration;
};

inline long
GPS::_swapl(const void *bytes)
{
    const uint8_t       *b = (const uint8_t *)bytes;
    union {
        long    v;
        uint8_t b[4];
    } u;

    u.b[0] = b[3];
    u.b[1] = b[2];
    u.b[2] = b[1];
    u.b[3] = b[0];

    return(u.v);
}

inline int16_t
GPS::_swapi(const void *bytes)
{
    const uint8_t       *b = (const uint8_t *)bytes;
    union {
        int16_t v;
        uint8_t b[2];
    } u;

    u.b[0] = b[1];
    u.b[1] = b[0];

    return(u.v);
}

#endif