| 0,0 → 1,217 |
|---|
| // -*- 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 |