ardupilot/libraries/AP_GPS/GPS.h

260 lines
7.6 KiB
C
Raw Normal View History

// -*- 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 <AP_HAL.h>
#include <inttypes.h>
2012-12-12 17:45:12 -04:00
#include <AP_Progmem.h>
/// @class GPS
/// @brief Abstract base class for GPS receiver drivers.
class GPS
{
public:
2011-10-28 15:52:50 -03:00
/// 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.
///
2012-08-21 23:19:52 -03:00
void update(void);
2011-10-28 15:52:50 -03:00
/// GPS status codes
///
/// \note Non-intuitive ordering for legacy reasons
///
enum GPS_Status {
2012-08-21 23:19:52 -03:00
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
2011-10-28 15:52:50 -03:00
};
2012-08-21 23:19:52 -03:00
// GPS navigation engine settings. Not all GPS receivers support
// this
enum GPS_Engine_Setting {
GPS_ENGINE_NONE = -1,
GPS_ENGINE_PORTABLE = 0,
GPS_ENGINE_STATIONARY = 2,
2012-08-21 23:19:52 -03:00
GPS_ENGINE_PEDESTRIAN = 3,
GPS_ENGINE_AUTOMOTIVE = 4,
GPS_ENGINE_SEA = 5,
GPS_ENGINE_AIRBORNE_1G = 6,
GPS_ENGINE_AIRBORNE_2G = 7,
GPS_ENGINE_AIRBORNE_4G = 8
};
2011-10-28 15:52:50 -03:00
/// 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
///
2012-08-21 23:19:52 -03:00
GPS_Status status(void) {
2011-10-28 15:52:50 -03:00
return _status;
}
/// GPS time epoch codes
///
2012-08-21 23:19:52 -03:00
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?
2011-10-28 15:52:50 -03:00
/// Query GPS time epoch
///
/// @returns Current GPS time epoch code
///
2012-08-21 23:19:52 -03:00
GPS_Time_Epoch epoch(void) {
2011-10-28 15:52:50 -03:00
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(AP_HAL::UARTDriver *s, enum GPS_Engine_Setting engine_setting = GPS_ENGINE_NONE) = 0;
2011-10-28 15:52:50 -03:00
// Properties
2012-08-21 23:19:52 -03:00
uint32_t time; ///< GPS time (milliseconds from epoch)
uint32_t date; ///< GPS date (FORMAT TBD)
int32_t latitude; ///< latitude in degrees * 10,000,000
int32_t longitude; ///< longitude in degrees * 10,000,000
int32_t altitude; ///< altitude in cm
uint32_t ground_speed; ///< ground speed in cm/sec
int32_t ground_course; ///< ground course in 100ths of a degree
int32_t speed_3d; ///< 3D speed in cm/sec (not always available)
int16_t hdop; ///< horizontal dilution of precision in cm
uint8_t num_sats; ///< Number of visible satelites
2011-10-28 15:52:50 -03:00
/// Set to true when new data arrives. A client may set this
/// to false in order to avoid processing data they have
/// already seen.
2012-08-21 23:19:52 -03:00
bool new_data;
2011-10-28 15:52:50 -03:00
// Deprecated properties
2012-08-21 23:19:52 -03:00
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)
2011-10-28 15:52:50 -03:00
// Debug support
2012-08-21 23:19:52 -03:00
bool print_errors; ///< deprecated
2011-10-28 15:52:50 -03:00
// HIL support
virtual void setHIL(uint32_t time, float latitude, float longitude, float altitude,
2011-10-28 15:52:50 -03:00
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.
///
2012-08-21 23:19:52 -03:00
uint32_t idleTimeout;
// components of velocity in 2D, in m/s
float velocity_north(void) {
return _status == GPS_OK ? _velocity_north : 0;
}
float velocity_east(void) {
return _status == GPS_OK ? _velocity_east : 0;
}
float velocity_down(void) {
return _status == GPS_OK ? _velocity_down : 0;
}
2012-08-21 23:19:52 -03:00
// last ground speed in m/s. This can be used when we have no GPS
// lock to return the last ground speed we had with lock
float last_ground_speed(void) {
return _last_ground_speed_cm * 0.01;
}
// the expected lag (in seconds) in the position and velocity readings from the gps
virtual float get_lag() { return 1.0; }
2012-08-21 23:19:52 -03:00
// the time we got our last fix in system milliseconds
uint32_t last_fix_time;
2012-03-07 00:15:13 -04:00
// return true if the GPS supports raw velocity values
protected:
AP_HAL::UARTDriver *_port; ///< port the GPS is attached to
2011-10-28 15:52:50 -03:00
/// 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
///
2012-08-21 23:19:52 -03:00
virtual bool read(void) = 0;
2011-10-28 15:52:50 -03:00
/// 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
///
2012-08-21 23:19:52 -03:00
int32_t _swapl(const void *bytes);
2011-10-28 15:52:50 -03:00
/// 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
2012-08-21 23:19:52 -03:00
int16_t _swapi(const void *bytes);
2011-10-28 15:52:50 -03:00
/// 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
///
2012-08-21 23:19:52 -03:00
void _error(const char *msg);
2011-10-28 15:52:50 -03:00
/// Time epoch code for the gps in use
2012-08-21 23:19:52 -03:00
GPS_Time_Epoch _epoch;
2012-08-21 23:19:52 -03:00
enum GPS_Engine_Setting _nav_setting;
void _write_progstr_block(AP_HAL::UARTDriver *_fs, const prog_char *pstr, uint8_t size);
void _send_progstr(AP_HAL::UARTDriver *_fs, const prog_char *pstr, uint8_t size);
void _update_progstr(void);
2012-08-21 23:19:52 -03:00
// velocities in cm/s if available from the GPS
int32_t _vel_north;
int32_t _vel_east;
int32_t _vel_down;
2012-08-21 23:19:52 -03:00
// does this GPS support raw velocity numbers?
bool _have_raw_velocity;
private:
2011-10-28 15:52:50 -03:00
/// Last time that the GPS driver got a good packet from the GPS
///
2012-08-21 23:19:52 -03:00
uint32_t _idleTimer;
2011-10-28 15:52:50 -03:00
/// Our current status
2012-08-21 23:19:52 -03:00
GPS_Status _status;
2012-08-21 23:19:52 -03:00
// previous ground speed in cm/s
uint32_t _last_ground_speed_cm;
2012-08-21 23:19:52 -03:00
// components of the velocity, in m/s
float _velocity_north;
float _velocity_east;
float _velocity_down;
};
inline int32_t
GPS::_swapl(const void *bytes)
{
2012-08-21 23:19:52 -03:00
const uint8_t *b = (const uint8_t *)bytes;
2011-10-28 15:52:50 -03:00
union {
2012-08-21 23:19:52 -03:00
int32_t v;
2011-10-28 15:52:50 -03:00
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)
{
2012-08-21 23:19:52 -03:00
const uint8_t *b = (const uint8_t *)bytes;
2011-10-28 15:52:50 -03:00
union {
2012-08-21 23:19:52 -03:00
int16_t v;
2011-10-28 15:52:50 -03:00
uint8_t b[2];
} u;
2011-10-28 15:52:50 -03:00
u.b[0] = b[1];
u.b[1] = b[0];
2011-10-28 15:52:50 -03:00
return(u.v);
}
#endif // __GPS_H__