320 lines
13 KiB
C++
320 lines
13 KiB
C++
/**************************************************************************/
|
|
/*!
|
|
@file Adafruit_GPS.h
|
|
|
|
This is the Adafruit GPS library - the ultimate GPS library
|
|
for the ultimate GPS module!
|
|
|
|
Tested and works great with the Adafruit Ultimate GPS module
|
|
using MTK33x9 chipset
|
|
------> http://www.adafruit.com/products/746
|
|
Pick one up today at the Adafruit electronics shop
|
|
and help support open source hardware & software! -ada
|
|
|
|
Adafruit invests time and resources providing this open source code,
|
|
please support Adafruit and open-source hardware by purchasing
|
|
products from Adafruit!
|
|
|
|
Written by Limor Fried/Ladyada for Adafruit Industries.
|
|
BSD license, check license.txt for more information
|
|
All text above must be included in any redistribution
|
|
*/
|
|
/**************************************************************************/
|
|
|
|
// Fllybob added lines 34,35 and 40,41 to add 100mHz logging capability
|
|
|
|
#ifndef _ADAFRUIT_GPS_H
|
|
#define _ADAFRUIT_GPS_H
|
|
|
|
/**************************************************************************/
|
|
/**
|
|
Comment out the definition of NMEA_EXTENSIONS to make the library use as
|
|
little memory as possible for GPS functionality only. The ARDUINO_ARCH_AVR
|
|
test should leave it out of any compilations for the UNO and similar. */
|
|
#ifndef NMEA_EXTRAS // inject on the compile command line to force extensions
|
|
#ifndef ARDUINO_ARCH_AVR
|
|
#define NMEA_EXTENSIONS ///< if defined will include more NMEA sentences
|
|
#endif
|
|
#else
|
|
#if(NMEA_EXTRAS > 0)
|
|
#define NMEA_EXTENSIONS ///< if defined will include more NMEA sentences
|
|
#endif
|
|
#endif
|
|
|
|
#define USE_SW_SERIAL ///< comment this out if you don't want to include
|
|
///< software serial in the library
|
|
#define GPS_DEFAULT_I2C_ADDR \
|
|
0x10 ///< The default address for I2C transport of GPS data
|
|
#define GPS_MAX_I2C_TRANSFER \
|
|
32 ///< The max number of bytes we'll try to read at once
|
|
#define GPS_MAX_SPI_TRANSFER \
|
|
100 ///< The max number of bytes we'll try to read at once
|
|
#define MAXLINELENGTH 120 ///< how long are max NMEA lines to parse?
|
|
#define NMEA_MAX_SENTENCE_ID \
|
|
20 ///< maximum length of a sentence ID name, including terminating 0
|
|
#define NMEA_MAX_SOURCE_ID \
|
|
3 ///< maximum length of a source ID name, including terminating 0
|
|
|
|
#include "Arduino.h"
|
|
#if (defined(__AVR__) || defined(ESP8266)) && defined(USE_SW_SERIAL)
|
|
#include <SoftwareSerial.h>
|
|
#endif
|
|
#include <Adafruit_PMTK.h>
|
|
#include <NMEA_data.h>
|
|
#include <SPI.h>
|
|
#include <Wire.h>
|
|
|
|
/// type for resulting code from running check()
|
|
typedef enum {
|
|
NMEA_BAD = 0, ///< passed none of the checks
|
|
NMEA_HAS_DOLLAR = 1, ///< has a dollar sign in the first position
|
|
NMEA_HAS_CHECKSUM = 2, ///< has a valid checksum at the end
|
|
NMEA_HAS_NAME = 4, ///< there is a token after the $ followed by a comma
|
|
NMEA_HAS_SOURCE = 10, ///< has a recognized source ID
|
|
NMEA_HAS_SENTENCE = 20, ///< has a recognized sentence ID
|
|
NMEA_HAS_SENTENCE_P = 40 ///< has a recognized parseable sentence ID
|
|
} nmea_check_t;
|
|
|
|
/**************************************************************************/
|
|
/*!
|
|
@brief The GPS class
|
|
*/
|
|
class Adafruit_GPS : public Print {
|
|
public:
|
|
bool begin(uint32_t baud_or_i2caddr);
|
|
|
|
#if (defined(__AVR__) || defined(ESP8266)) && defined(USE_SW_SERIAL)
|
|
Adafruit_GPS(SoftwareSerial *ser); // Constructor when using SoftwareSerial
|
|
#endif
|
|
Adafruit_GPS(HardwareSerial *ser); // Constructor when using HardwareSerial
|
|
Adafruit_GPS(TwoWire *theWire); // Constructor when using I2C
|
|
Adafruit_GPS(SPIClass *theSPI, int8_t cspin); // Constructor when using SPI
|
|
Adafruit_GPS(); // Constructor for no communications, just data storage
|
|
virtual ~Adafruit_GPS();
|
|
|
|
char *lastNMEA(void);
|
|
bool newNMEAreceived();
|
|
void common_init(void);
|
|
|
|
void sendCommand(const char *);
|
|
|
|
void pause(bool b);
|
|
|
|
char read(void);
|
|
size_t write(uint8_t);
|
|
size_t available(void);
|
|
|
|
nmea_float_t secondsSinceFix();
|
|
nmea_float_t secondsSinceTime();
|
|
nmea_float_t secondsSinceDate();
|
|
void resetSentTime();
|
|
|
|
bool wakeup(void);
|
|
bool standby(void);
|
|
|
|
// NMEA_parse.cpp
|
|
bool parse(char *);
|
|
bool check(char *nmea);
|
|
bool onList(char *nmea, const char **list);
|
|
uint8_t parseHex(char c);
|
|
|
|
// NMEA_build.cpp
|
|
#ifdef NMEA_EXTENSIONS
|
|
char *build(char *nmea, const char *thisSource, const char *thisSentence,
|
|
char ref = 'R');
|
|
#endif
|
|
void addChecksum(char *buff);
|
|
|
|
// NMEA_data.cpp
|
|
void newDataValue(nmea_index_t tag, nmea_float_t v);
|
|
#ifdef NMEA_EXTENSIONS
|
|
nmea_float_t get(nmea_index_t idx);
|
|
nmea_float_t getSmoothed(nmea_index_t idx);
|
|
void initDataValue(nmea_index_t idx, char *label = NULL, char *fmt = NULL,
|
|
char *unit = NULL, unsigned long response = 0,
|
|
nmea_value_type_t type = NMEA_SIMPLE_FLOAT);
|
|
nmea_history_t *initHistory(nmea_index_t idx, nmea_float_t scale = 10.0,
|
|
nmea_float_t offset = 0.0,
|
|
unsigned historyInterval = 20,
|
|
unsigned historyN = 192);
|
|
void removeHistory(nmea_index_t idx);
|
|
void showDataValue(nmea_index_t idx, int n = 7);
|
|
bool isCompoundAngle(nmea_index_t idx);
|
|
#endif
|
|
nmea_float_t boatAngle(nmea_float_t s, nmea_float_t c);
|
|
nmea_float_t compassAngle(nmea_float_t s, nmea_float_t c);
|
|
|
|
int thisCheck = 0; ///< the results of the check on the current sentence
|
|
char thisSource[NMEA_MAX_SOURCE_ID] = {
|
|
0}; ///< the first two letters of the current sentence, e.g. WI, GP
|
|
char thisSentence[NMEA_MAX_SENTENCE_ID] = {
|
|
0}; ///< the next three letters of the current sentence, e.g. GLL, RMC
|
|
char lastSource[NMEA_MAX_SOURCE_ID] = {
|
|
0}; ///< the results of the check on the most recent successfully parsed
|
|
///< sentence
|
|
char lastSentence[NMEA_MAX_SENTENCE_ID] = {
|
|
0}; ///< the next three letters of the most recent successfully parsed
|
|
///< sentence, e.g. GLL, RMC
|
|
|
|
uint8_t hour; ///< GMT hours
|
|
uint8_t minute; ///< GMT minutes
|
|
uint8_t seconds; ///< GMT seconds
|
|
uint16_t milliseconds; ///< GMT milliseconds
|
|
uint8_t year; ///< GMT year
|
|
uint8_t month; ///< GMT month
|
|
uint8_t day; ///< GMT day
|
|
|
|
nmea_float_t latitude; ///< Floating point latitude value in degrees/minutes
|
|
///< as received from the GPS (DDMM.MMMM)
|
|
nmea_float_t longitude; ///< Floating point longitude value in degrees/minutes
|
|
///< as received from the GPS (DDDMM.MMMM)
|
|
|
|
/** Fixed point latitude and longitude value with degrees stored in units of
|
|
1/100000 degrees, and minutes stored in units of 1/100000 degrees. See pull
|
|
#13 for more details:
|
|
https://github.com/adafruit/Adafruit-GPS-Library/pull/13 */
|
|
int32_t latitude_fixed; ///< Fixed point latitude in decimal degrees
|
|
int32_t longitude_fixed; ///< Fixed point longitude in decimal degrees
|
|
|
|
nmea_float_t latitudeDegrees; ///< Latitude in decimal degrees
|
|
nmea_float_t longitudeDegrees; ///< Longitude in decimal degrees
|
|
nmea_float_t geoidheight; ///< Diff between geoid height and WGS84 height
|
|
nmea_float_t altitude; ///< Altitude in meters above MSL
|
|
nmea_float_t speed; ///< Current speed over ground in knots
|
|
nmea_float_t angle; ///< Course in degrees from true north
|
|
nmea_float_t magvariation; ///< Magnetic variation in degrees (vs. true north)
|
|
nmea_float_t HDOP; ///< Horizontal Dilution of Precision - relative accuracy
|
|
///< of horizontal position
|
|
nmea_float_t VDOP; ///< Vertical Dilution of Precision - relative accuracy
|
|
///< of vertical position
|
|
nmea_float_t PDOP; ///< Position Dilution of Precision - Complex maths derives
|
|
///< a simple, single number for each kind of DOP
|
|
char lat = 'X'; ///< N/S
|
|
char lon = 'X'; ///< E/W
|
|
char mag = 'X'; ///< Magnetic variation direction
|
|
bool fix; ///< Have a fix?
|
|
uint8_t fixquality; ///< Fix quality (0, 1, 2 = Invalid, GPS, DGPS)
|
|
uint8_t fixquality_3d; ///< 3D fix quality (1, 3, 3 = Nofix, 2D fix, 3D fix)
|
|
uint8_t satellites; ///< Number of satellites in use
|
|
|
|
bool waitForSentence(const char *wait, uint8_t max = MAXWAITSENTENCE,
|
|
bool usingInterrupts = false);
|
|
bool LOCUS_StartLogger(void);
|
|
bool LOCUS_StopLogger(void);
|
|
bool LOCUS_ReadStatus(void);
|
|
|
|
uint16_t LOCUS_serial; ///< Log serial number
|
|
uint16_t LOCUS_records; ///< Log number of data record
|
|
uint8_t LOCUS_type; ///< Log type, 0: Overlap, 1: FullStop
|
|
uint8_t LOCUS_mode; ///< Logging mode, 0x08 interval logger
|
|
uint8_t LOCUS_config; ///< Contents of configuration
|
|
uint8_t LOCUS_interval; ///< Interval setting
|
|
uint8_t LOCUS_distance; ///< Distance setting
|
|
uint8_t LOCUS_speed; ///< Speed setting
|
|
uint8_t LOCUS_status; ///< 0: Logging, 1: Stop logging
|
|
uint8_t LOCUS_percent; ///< Log life used percentage
|
|
|
|
#ifdef NMEA_EXTENSIONS
|
|
// NMEA additional public variables
|
|
nmea_datavalue_t
|
|
val[NMEA_MAX_INDEX]; ///< an array of data value structs, val[0] = most
|
|
///< recent HDOP so that ockam indexing works
|
|
nmea_float_t depthToKeel =
|
|
2.4; ///< depth from surface to bottom of keel in metres
|
|
nmea_float_t depthToTransducer =
|
|
0.0; ///< depth of transducer below the surface in metres
|
|
|
|
char toID[NMEA_MAX_WP_ID] = {
|
|
0}; ///< id of waypoint going to on this segment of the route
|
|
char fromID[NMEA_MAX_WP_ID] = {
|
|
0}; ///< id of waypoint coming from on this segment of the route
|
|
|
|
char txtTXT[63] = {0}; ///< text content from most recent TXT sentence
|
|
int txtTot = 0; ///< total TXT sentences in group
|
|
int txtID = 0; ///< id of the text message
|
|
int txtN = 0; ///< the TXT sentence number
|
|
#endif // NMEA_EXTENSIONS
|
|
|
|
private:
|
|
void parseLat(char *);
|
|
bool parseLatDir(char *);
|
|
void parseLon(char *);
|
|
bool parseLonDir(char *);
|
|
// NMEA_data.cpp
|
|
void data_init();
|
|
// NMEA_parse.cpp
|
|
const char *tokenOnList(char *token, const char **list);
|
|
bool parseCoord(char *p, nmea_float_t *angleDegrees = NULL,
|
|
nmea_float_t *angle = NULL, int32_t *angle_fixed = NULL,
|
|
char *dir = NULL);
|
|
char *parseStr(char *buff, char *p, int n);
|
|
bool parseTime(char *);
|
|
bool parseFix(char *);
|
|
bool isEmpty(char *pStart);
|
|
|
|
// used by check() for validity tests, room for future expansion
|
|
const char *sources[6] = {"II", "WI", "GP", "GN",
|
|
"P", "ZZZ"}; ///< valid source ids
|
|
#ifdef NMEA_EXTENSIONS
|
|
const char
|
|
*sentences_parsed[20] =
|
|
{
|
|
"GGA", "GLL", "GSA", "RMC", "DBT", "HDM", "HDT",
|
|
"MDA", "MTW", "MWV", "RMB", "TXT", "VHW", "VLW",
|
|
"VPW", "VWR", "WCV", "XTE", "ZZZ"}; ///< parseable sentence ids
|
|
const char *sentences_known[15] = {
|
|
"APB", "DPT", "GSV", "HDG", "MWD", "ROT",
|
|
"RPM", "RSA", "VDR", "VTG", "ZDA", "ZZZ"}; ///< known, but not parseable
|
|
#else // make the lists short to save memory
|
|
const char
|
|
*sentences_parsed[5] =
|
|
{
|
|
"GGA", "GLL", "GSA", "RMC", "ZZZ"}; ///< parseable sentence ids
|
|
const char *sentences_known[4] = {
|
|
"DBT", "HDM", "HDT", "ZZZ"}; ///< known, but not parseable
|
|
#endif
|
|
|
|
// Make all of these times far in the past by setting them near the middle of
|
|
// the millis() range. Timing assumes that sentences are parsed promptly.
|
|
uint32_t lastUpdate =
|
|
2000000000L; ///< millis() when last full sentence successfully parsed
|
|
uint32_t lastFix = 2000000000L; ///< millis() when last fix received
|
|
uint32_t lastTime = 2000000000L; ///< millis() when last time received
|
|
uint32_t lastDate = 2000000000L; ///< millis() when last date received
|
|
uint32_t recvdTime =
|
|
2000000000L; ///< millis() when last full sentence received
|
|
uint32_t sentTime = 2000000000L; ///< millis() when first character of last
|
|
///< full sentence received
|
|
bool paused;
|
|
|
|
uint8_t parseResponse(char *response);
|
|
#if (defined(__AVR__) || defined(ESP8266)) && defined(USE_SW_SERIAL)
|
|
SoftwareSerial *gpsSwSerial;
|
|
#endif
|
|
bool noComms = false;
|
|
HardwareSerial *gpsHwSerial;
|
|
TwoWire *gpsI2C;
|
|
SPIClass *gpsSPI;
|
|
int8_t gpsSPI_cs = -1;
|
|
SPISettings gpsSPI_settings =
|
|
SPISettings(1000000, MSBFIRST, SPI_MODE0); // default
|
|
char _spibuffer[GPS_MAX_SPI_TRANSFER]; // for when we write data, we need to
|
|
// read it too!
|
|
uint8_t _i2caddr;
|
|
char _i2cbuffer[GPS_MAX_I2C_TRANSFER];
|
|
int8_t _buff_max = -1, _buff_idx = 0;
|
|
char last_char = 0;
|
|
|
|
volatile char line1[MAXLINELENGTH]; ///< We double buffer: read one line in
|
|
///< and leave one for the main program
|
|
volatile char line2[MAXLINELENGTH]; ///< Second buffer
|
|
volatile uint8_t lineidx = 0; ///< our index into filling the current line
|
|
volatile char *currentline; ///< Pointer to current line buffer
|
|
volatile char *lastline; ///< Pointer to previous line buffer
|
|
volatile bool recvdflag; ///< Received flag
|
|
volatile bool inStandbyMode; ///< In standby flag
|
|
};
|
|
/**************************************************************************/
|
|
|
|
#endif
|