Cansat
/
esp32_Adafruit_GPS
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

clangify

This commit is contained in:
ladyada 2020-01-17 16:18:09 -05:00
parent 418d265a74
commit e4eb78f41c
2 changed files with 507 additions and 444 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

229
Adafruit_GPS.cpp
View File

@ -36,17 +36,22 @@ static boolean strStartsWith(const char* str, const char* prefix);
/*!
@brief Parse a NMEA string
@param nmea Pointer to the NMEA string
@return True if we parsed it, false if it has an invalid checksum or invalid data
@return True if we parsed it, false if it has an invalid checksum or invalid
data
*/
/**************************************************************************/
boolean Adafruit_GPS::parse(char *nmea) {
// do checksum check
if(!check(nmea)) return false;
// passed the check, so there's a valid source in thisSource and a valid sentence in thisSentence
if (!check(nmea))
return false;
// passed the check, so there's a valid source in thisSource and a valid
// sentence in thisSentence
// look for a few common sentences
char *p = nmea; // Pointer to move through the sentence -- good parsers are non-destructive
p = strchr(p, ',')+1; // Skip to the character after the next comma, then check sentence.
char *p = nmea; // Pointer to move through the sentence -- good parsers are
// non-destructive
p = strchr(p, ',') +
1; // Skip to the character after the next comma, then check sentence.
if (!strcmp(thisSentence, "GGA")) {
// found GGA
@ -57,17 +62,18 @@ boolean Adafruit_GPS::parse(char *nmea) {
p = strchr(p, ',') + 1;
parseLat(p);
p = strchr(p, ',') + 1;
if(!parseLatDir(p)) return false;
if (!parseLatDir(p))
return false;
// parse out longitude
p = strchr(p, ',') + 1;
parseLon(p);
p = strchr(p, ',') + 1;
if(!parseLonDir(p)) return false;
if (!parseLonDir(p))
return false;
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
fixquality = atoi(p);
if (fixquality > 0) {
fix = true;
@ -77,27 +83,23 @@ boolean Adafruit_GPS::parse(char *nmea) {
}
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
satellites = atoi(p);
}
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
HDOP = atof(p);
}
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
altitude = atof(p);
}
p = strchr(p, ',') + 1;
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
geoidheight = atof(p);
}
}
@ -109,37 +111,37 @@ boolean Adafruit_GPS::parse(char *nmea) {
// fix or no fix
p = strchr(p, ',') + 1;
if(!parseFix(p)) return false;
if (!parseFix(p))
return false;
// parse out latitude
p = strchr(p, ',') + 1;
parseLat(p);
p = strchr(p, ',') + 1;
if(!parseLatDir(p)) return false;
if (!parseLatDir(p))
return false;
// parse out longitude
p = strchr(p, ',') + 1;
parseLon(p);
p = strchr(p, ',') + 1;
if(!parseLonDir(p)) return false;
if (!parseLonDir(p))
return false;
// speed
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
speed = atof(p);
}
// angle
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
angle = atof(p);
}
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
uint32_t fulldate = atof(p);
day = fulldate / 10000;
month = (fulldate % 10000) / 100;
@ -153,13 +155,15 @@ boolean Adafruit_GPS::parse(char *nmea) {
// parse out latitude
parseLat(p);
p = strchr(p, ',') + 1;
if(!parseLatDir(p)) return false;
if (!parseLatDir(p))
return false;
// parse out longitude
p = strchr(p, ',') + 1;
parseLon(p);
p = strchr(p, ',') + 1;
if(!parseLonDir(p)) return false;
if (!parseLonDir(p))
return false;
// get time
p = strchr(p, ',') + 1;
@ -167,7 +171,8 @@ boolean Adafruit_GPS::parse(char *nmea) {
// fix or no fix
p = strchr(p, ',') + 1;
if(!parseFix(p)) return false;
if (!parseFix(p))
return false;
}
else if (!strcmp(thisSentence, "GSA")) {
@ -175,36 +180,34 @@ boolean Adafruit_GPS::parse(char *nmea) {
// parse out Auto selection, but ignore them
// parse out 3d fixquality
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
fixquality_3d = atoi(p);
}
// skip 12 Satellite PDNs without interpreting them
for(int i = 0;i < 12;i++) p = strchr(p, ',')+1;
for (int i = 0; i < 12; i++)
p = strchr(p, ',') + 1;
// parse out PDOP
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
PDOP = atof(p);
}
// parse out HDOP, we also parse this from the GGA sentence. Chipset should report the same for both
// parse out HDOP, we also parse this from the GGA sentence. Chipset should
// report the same for both
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
HDOP = atof(p);
}
// parse out VDOP
p = strchr(p, ',') + 1;
if (',' != *p)
{
if (',' != *p) {
VDOP = atof(p);
}
}
// we dont parse the remaining, yet!
else return false;
else
return false;
// Record the successful parsing of where the last data came from and when
strcpy(lastSource, thisSource);
@ -224,20 +227,29 @@ boolean Adafruit_GPS::parse(char *nmea) {
/**************************************************************************/
boolean Adafruit_GPS::check(char *nmea) {
thisCheck = 0; // new check
if(*nmea != '$') return false; // doesn't start with $
else thisCheck += NMEA_HAS_DOLLAR;
// do checksum check -- first look if we even have one -- ignore all but last *
if (*nmea != '$')
return false; // doesn't start with $
else
thisCheck += NMEA_HAS_DOLLAR;
// do checksum check -- first look if we even have one -- ignore all but last
// *
char *ast = nmea; // not strchr(nmea,'*'); for first *
while(*ast) ast++; // go to the end
while(*ast != '*' && ast > nmea) ast--; // then back to * if it's there
if (*ast != '*') return false; // there is no asterisk
while (*ast)
ast++; // go to the end
while (*ast != '*' && ast > nmea)
ast--; // then back to * if it's there
if (*ast != '*')
return false; // there is no asterisk
else {
uint16_t sum = parseHex(*(ast + 1)) * 16; // extract checksum
sum += parseHex(*(ast + 2));
char *p = nmea; // check checksum
for (char *p1 = p+1; p1 < ast; p1++) sum ^= *p1;
if (sum != 0) return false; // bad checksum :(
else thisCheck += NMEA_HAS_CHECKSUM;
for (char *p1 = p + 1; p1 < ast; p1++)
sum ^= *p1;
if (sum != 0)
return false; // bad checksum :(
else
thisCheck += NMEA_HAS_CHECKSUM;
}
// extract source of variable length
char *p = nmea + 1;
@ -245,7 +257,8 @@ boolean Adafruit_GPS::check(char *nmea) {
if (src) {
strcpy(thisSource, src);
thisCheck += NMEA_HAS_SOURCE;
} else return false;
} else
return false;
p += strlen(src);
// extract sentence id and check if parsed
const char *snc = tokenOnList(p, sentences_parsed);
@ -273,9 +286,11 @@ boolean Adafruit_GPS::check(char *nmea) {
/**************************************************************************/
const char *Adafruit_GPS::tokenOnList(char *token, const char **list) {
int i = 0; // index in the list
while(strncmp(list[i],"ZZ",2) && i < 1000){ // stop at terminator and don't crash without it
while (strncmp(list[i], "ZZ", 2) &&
i < 1000) { // stop at terminator and don't crash without it
// test for a match on the sentence name
if(!strncmp((const char *)list[i],(const char *)token,strlen(list[i]))) return list[i];
if (!strncmp((const char *)list[i], (const char *)token, strlen(list[i])))
return list[i];
i++;
}
return NULL; // couldn't find a match
@ -330,8 +345,7 @@ void Adafruit_GPS::parseLat(char *p) {
int32_t degree;
long minutes;
char degreebuff[10];
if (',' != *p)
{
if (',' != *p) {
strncpy(degreebuff, p, 2);
p += 2;
degreebuff[2] = '\0';
@ -380,8 +394,7 @@ void Adafruit_GPS::parseLon(char *p) {
int32_t degree;
long minutes;
char degreebuff[10];
if (',' != *p)
{
if (',' != *p) {
strncpy(degreebuff, p, 3);
p += 3;
degreebuff[3] = '\0';
@ -406,8 +419,7 @@ void Adafruit_GPS::parseLon(char *p) {
*/
/**************************************************************************/
boolean Adafruit_GPS::parseLonDir(char *p) {
if (',' != *p)
{
if (',' != *p) {
if (p[0] == 'W') {
lon = 'W';
longitudeDegrees *= -1.0;
@ -434,8 +446,7 @@ boolean Adafruit_GPS::parseFix(char *p) {
if (p[0] == 'A') {
fix = true;
lastFix = sentTime;
}
else if (p[0] == 'V')
} else if (p[0] == 'V')
fix = false;
else
return false;
@ -449,9 +460,7 @@ boolean Adafruit_GPS::parseFix(char *p) {
@return float value in seconds since last fix.
*/
/**************************************************************************/
float Adafruit_GPS::secondsSinceFix() {
return (millis()-lastFix) / 1000.;
}
float Adafruit_GPS::secondsSinceFix() { return (millis() - lastFix) / 1000.; }
/**************************************************************************/
/*!
@ -460,9 +469,7 @@ float Adafruit_GPS::secondsSinceFix() {
@return float value in seconds since last GPS time.
*/
/**************************************************************************/
float Adafruit_GPS::secondsSinceTime() {
return (millis()-lastTime) / 1000.;
}
float Adafruit_GPS::secondsSinceTime() { return (millis() - lastTime) / 1000.; }
/**************************************************************************/
/*!
@ -471,18 +478,18 @@ float Adafruit_GPS::secondsSinceTime() {
@return float value in seconds since last GPS date.
*/
/**************************************************************************/
float Adafruit_GPS::secondsSinceDate() {
return (millis()-lastDate) / 1000.;
}
float Adafruit_GPS::secondsSinceDate() { return (millis() - lastDate) / 1000.; }
/**************************************************************************/
/*!
@brief How many bytes are available to read - part of 'Print'-class functionality
@brief How many bytes are available to read - part of 'Print'-class
functionality
@return Bytes available, 0 if none
*/
/**************************************************************************/
size_t Adafruit_GPS::available(void) {
if (paused) return 0;
if (paused)
return 0;
#if (defined(__AVR__) || defined(ESP8266)) && defined(USE_SW_SERIAL)
if (gpsSwSerial) {
@ -493,14 +500,16 @@ size_t Adafruit_GPS::available(void) {
return gpsHwSerial->available();
}
if (gpsI2C || gpsSPI) {
return 1; // I2C/SPI doesnt have 'availability' so always has a byte at least to read!
return 1; // I2C/SPI doesnt have 'availability' so always has a byte at
// least to read!
}
return 0;
}
/**************************************************************************/
/*!
@brief Write a byte to the underlying transport - part of 'Print'-class functionality
@brief Write a byte to the underlying transport - part of 'Print'-class
functionality
@param c A single byte to send
@return Bytes written - 1 on success, 0 on failure
*/
@ -550,7 +559,8 @@ char Adafruit_GPS::read(void) {
uint32_t tStart = millis(); // as close as we can get to time char was sent
char c = 0;
if (paused) return c;
if (paused)
return c;
#if (defined(__AVR__) || defined(ESP8266)) && defined(USE_SW_SERIAL)
if (gpsSwSerial) {
@ -570,7 +580,8 @@ char Adafruit_GPS::read(void) {
_buff_idx++;
} else {
// refill the buffer!
if (gpsI2C->requestFrom(0x10, GPS_MAX_I2C_TRANSFER, true) == GPS_MAX_I2C_TRANSFER) {
if (gpsI2C->requestFrom(0x10, GPS_MAX_I2C_TRANSFER, true) ==
GPS_MAX_I2C_TRANSFER) {
// got data!
_buff_max = 0;
char curr_char = 0;
@ -606,14 +617,16 @@ char Adafruit_GPS::read(void) {
}
gpsSPI->endTransaction();
// skip duplicate 0x0A's - but keep as part of a CRLF
} while (((c == 0x0A) && (last_char != 0x0D)) || (!isprint(c) && !isspace(c)) );
} while (((c == 0x0A) && (last_char != 0x0D)) ||
(!isprint(c) && !isspace(c)));
last_char = c;
}
// Serial.print(c);
currentline[lineidx++] = c;
if (lineidx >= MAXLINELENGTH)
lineidx = MAXLINELENGTH-1; // ensure there is someplace to put the next received character
lineidx = MAXLINELENGTH -
1; // ensure there is someplace to put the next received character
if (c == '\n') {
currentline[lineidx] = 0;
@ -637,7 +650,8 @@ char Adafruit_GPS::read(void) {
return c; // wait until next character to set time
}
if(firstChar == 0) firstChar = tStart;
if (firstChar == 0)
firstChar = tStart;
return c;
}
@ -648,8 +662,7 @@ char Adafruit_GPS::read(void) {
*/
/**************************************************************************/
#if (defined(__AVR__) || defined(ESP8266)) && defined(USE_SW_SERIAL)
Adafruit_GPS::Adafruit_GPS(SoftwareSerial *ser)
{
Adafruit_GPS::Adafruit_GPS(SoftwareSerial *ser) {
common_init(); // Set everything to common state, then...
gpsSwSerial = ser; // ...override gpsSwSerial with value passed.
}
@ -690,7 +703,6 @@ Adafruit_GPS::Adafruit_GPS(SPIClass *theSPI, int8_t cspin) {
gpsSPI_cs = cspin;
}
/**************************************************************************/
/*!
@brief Initialization code used by all constructor types
@ -709,13 +721,13 @@ void Adafruit_GPS::common_init(void) {
currentline = line1;
lastline = line2;
hour = minute = seconds = year = month = day =
fixquality = fixquality_3d = satellites = 0; // uint8_t
hour = minute = seconds = year = month = day = fixquality = fixquality_3d =
satellites = 0; // uint8_t
lat = lon = mag = 0; // char
fix = false; // boolean
milliseconds = 0; // uint16_t
latitude = longitude = geoidheight = altitude =
speed = angle = magvariation = HDOP = VDOP = PDOP = 0.0; // float
latitude = longitude = geoidheight = altitude = speed = angle = magvariation =
HDOP = VDOP = PDOP = 0.0; // float
}
/**************************************************************************/
@ -725,8 +737,7 @@ void Adafruit_GPS::common_init(void) {
@returns True on successful hardware init, False on failure
*/
/**************************************************************************/
bool Adafruit_GPS::begin(uint32_t baud_or_i2caddr)
{
bool Adafruit_GPS::begin(uint32_t baud_or_i2caddr) {
#if (defined(__AVR__) || defined(ESP8266)) && defined(USE_SW_SERIAL)
if (gpsSwSerial) {
gpsSwSerial->begin(baud_or_i2caddr);
@ -765,9 +776,7 @@ bool Adafruit_GPS::begin(uint32_t baud_or_i2caddr)
@param str Pointer to a string holding the command to send
*/
/**************************************************************************/
void Adafruit_GPS::sendCommand(const char *str) {
println(str);
}
void Adafruit_GPS::sendCommand(const char *str) { println(str); }
/**************************************************************************/
/*!
@ -775,9 +784,7 @@ void Adafruit_GPS::sendCommand(const char *str) {
@return True if received, false if not
*/
/**************************************************************************/
boolean Adafruit_GPS::newNMEAreceived(void) {
return recvdflag;
}
boolean Adafruit_GPS::newNMEAreceived(void) { return recvdflag; }
/**************************************************************************/
/*!
@ -785,9 +792,7 @@ boolean Adafruit_GPS::newNMEAreceived(void) {
@param p True = pause, false = unpause
*/
/**************************************************************************/
void Adafruit_GPS::pause(boolean p) {
paused = p;
}
void Adafruit_GPS::pause(boolean p) { paused = p; }
/**************************************************************************/
/*!
@ -804,7 +809,8 @@ char *Adafruit_GPS::lastNMEA(void) {
/*!
@brief Parse a hex character and return the appropriate decimal value
@param c Hex character, e.g. '0' or 'B'
@return Integer value of the hex character. Returns 0 if c is not a proper character
@return Integer value of the hex character. Returns 0 if c is not a proper
character
*/
/**************************************************************************/
// read a Hex value and return the decimal equivalent
@ -826,11 +832,13 @@ uint8_t Adafruit_GPS::parseHex(char c) {
@brief Wait for a specified sentence from the device
@param wait4me Pointer to a string holding the desired response
@param max How long to wait, default is MAXWAITSENTENCE
@param usingInterrupts True if using interrupts to read from the GPS (default is false)
@param usingInterrupts True if using interrupts to read from the GPS
(default is false)
@return True if we got what we wanted, false otherwise
*/
/**************************************************************************/
boolean Adafruit_GPS::waitForSentence(const char *wait4me, uint8_t max, boolean usingInterrupts) {
boolean Adafruit_GPS::waitForSentence(const char *wait4me, uint8_t max,
boolean usingInterrupts) {
uint8_t i = 0;
while (i < max) {
if (!usingInterrupts)
@ -888,7 +896,8 @@ boolean Adafruit_GPS::LOCUS_ReadStatus(void) {
uint16_t parsed[10];
uint8_t i;
for (i=0; i<10; i++) parsed[i] = -1;
for (i = 0; i < 10; i++)
parsed[i] = -1;
response = strchr(response, ',');
for (i = 0; i < 10; i++) {
@ -896,8 +905,7 @@ boolean Adafruit_GPS::LOCUS_ReadStatus(void) {
break;
response++;
parsed[i] = 0;
while ((response[0] != ',') &&
(response[0] != '*') && (response[0] != 0)) {
while ((response[0] != ',') && (response[0] != '*') && (response[0] != 0)) {
parsed[i] *= 10;
char c = response[0];
if (isDigit(c))
@ -932,12 +940,13 @@ boolean Adafruit_GPS::LOCUS_ReadStatus(void) {
/**************************************************************************/
boolean Adafruit_GPS::standby(void) {
if (inStandbyMode) {
return false; // Returns false if already in standby mode, so that you do not wake it up by sending commands to GPS
}
else {
return false; // Returns false if already in standby mode, so that you do
// not wake it up by sending commands to GPS
} else {
inStandbyMode = true;
sendCommand(PMTK_STANDBY);
//return waitForSentence(PMTK_STANDBY_SUCCESS); // don't seem to be fast enough to catch the message, or something else just is not working
// return waitForSentence(PMTK_STANDBY_SUCCESS); // don't seem to be fast
// enough to catch the message, or something else just is not working
return true;
}
}
@ -953,8 +962,7 @@ boolean Adafruit_GPS::wakeup(void) {
inStandbyMode = false;
sendCommand(""); // send byte to wake it up
return waitForSentence(PMTK_AWAKE);
}
else {
} else {
return false; // Returns false if not in standby mode, nothing to wakeup
}
}
@ -967,8 +975,7 @@ boolean Adafruit_GPS::wakeup(void) {
@return True if str starts with prefix, false otherwise
*/
/**************************************************************************/
static boolean strStartsWith(const char* str, const char* prefix)
{
static boolean strStartsWith(const char *str, const char *prefix) {
while (*prefix) {
if (*prefix++ != *str++)
return false;

172
Adafruit_GPS.h
View File

@ -26,36 +26,46 @@
#ifndef _ADAFRUIT_GPS_H
#define _ADAFRUIT_GPS_H
#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 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
#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 <Wire.h>
#include <SPI.h>
#include <Wire.h>
/**************************************************************************/
/**
Different commands to set the update rate from once a second (1 Hz) to 10 times a second (10Hz)
Note that these only control the rate at which the position is echoed, to actually speed up the
position fix you must also send one of the position fix rate commands below too. */
#define PMTK_SET_NMEA_UPDATE_100_MILLIHERTZ "$PMTK220,10000*2F" ///< Once every 10 seconds, 100 millihertz.
#define PMTK_SET_NMEA_UPDATE_200_MILLIHERTZ "$PMTK220,5000*1B" ///< Once every 5 seconds, 200 millihertz.
Different commands to set the update rate from once a second (1 Hz) to 10 times
a second (10Hz) Note that these only control the rate at which the position is
echoed, to actually speed up the position fix you must also send one of the
position fix rate commands below too. */
#define PMTK_SET_NMEA_UPDATE_100_MILLIHERTZ \
"$PMTK220,10000*2F" ///< Once every 10 seconds, 100 millihertz.
#define PMTK_SET_NMEA_UPDATE_200_MILLIHERTZ \
"$PMTK220,5000*1B" ///< Once every 5 seconds, 200 millihertz.
#define PMTK_SET_NMEA_UPDATE_1HZ "$PMTK220,1000*1F" ///< 1 Hz
#define PMTK_SET_NMEA_UPDATE_2HZ "$PMTK220,500*2B" ///< 2 Hz
#define PMTK_SET_NMEA_UPDATE_5HZ "$PMTK220,200*2C" ///< 5 Hz
#define PMTK_SET_NMEA_UPDATE_10HZ "$PMTK220,100*2F" ///< 10 Hz
// Position fix update rate commands.
#define PMTK_API_SET_FIX_CTL_100_MILLIHERTZ "$PMTK300,10000,0,0,0,0*2C" ///< Once every 10 seconds, 100 millihertz.
#define PMTK_API_SET_FIX_CTL_200_MILLIHERTZ "$PMTK300,5000,0,0,0,0*18" ///< Once every 5 seconds, 200 millihertz.
#define PMTK_API_SET_FIX_CTL_100_MILLIHERTZ \
"$PMTK300,10000,0,0,0,0*2C" ///< Once every 10 seconds, 100 millihertz.
#define PMTK_API_SET_FIX_CTL_200_MILLIHERTZ \
"$PMTK300,5000,0,0,0,0*18" ///< Once every 5 seconds, 200 millihertz.
#define PMTK_API_SET_FIX_CTL_1HZ "$PMTK300,1000,0,0,0,0*1C" ///< 1 Hz
#define PMTK_API_SET_FIX_CTL_5HZ "$PMTK300,200,0,0,0,0*2F" ///< 5 Hz
// Can't fix position faster than 5 times a second!
@ -64,43 +74,67 @@
#define PMTK_SET_BAUD_57600 "$PMTK251,57600*2C" ///< 57600 bps
#define PMTK_SET_BAUD_9600 "$PMTK251,9600*17" ///< 9600 bps
#define PMTK_SET_NMEA_OUTPUT_GLLONLY "$PMTK314,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on only the GPGLL sentence
#define PMTK_SET_NMEA_OUTPUT_RMCONLY "$PMTK314,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on only the GPRMC sentence
#define PMTK_SET_NMEA_OUTPUT_VTGONLY "$PMTK314,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on only the GPVTG
#define PMTK_SET_NMEA_OUTPUT_GGAONLY "$PMTK314,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on just the GPGGA
#define PMTK_SET_NMEA_OUTPUT_GSAONLY "$PMTK314,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on just the GPGSA
#define PMTK_SET_NMEA_OUTPUT_GSVONLY "$PMTK314,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on just the GPGSV
#define PMTK_SET_NMEA_OUTPUT_RMCGGA "$PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*28" ///< turn on GPRMC and GPGGA
#define PMTK_SET_NMEA_OUTPUT_RMCGGAGSA "$PMTK314,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on GPRMC, GPGGA and GPGSA
#define PMTK_SET_NMEA_OUTPUT_ALLDATA "$PMTK314,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0*28" ///< turn on ALL THE DATA
#define PMTK_SET_NMEA_OUTPUT_OFF "$PMTK314,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*28" ///< turn off output
#define PMTK_SET_NMEA_OUTPUT_GLLONLY \
"$PMTK314,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on only the
///< GPGLL sentence
#define PMTK_SET_NMEA_OUTPUT_RMCONLY \
"$PMTK314,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on only the
///< GPRMC sentence
#define PMTK_SET_NMEA_OUTPUT_VTGONLY \
"$PMTK314,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on only the
///< GPVTG
#define PMTK_SET_NMEA_OUTPUT_GGAONLY \
"$PMTK314,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on just the
///< GPGGA
#define PMTK_SET_NMEA_OUTPUT_GSAONLY \
"$PMTK314,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on just the
///< GPGSA
#define PMTK_SET_NMEA_OUTPUT_GSVONLY \
"$PMTK314,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on just the
///< GPGSV
#define PMTK_SET_NMEA_OUTPUT_RMCGGA \
"$PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*28" ///< turn on GPRMC and
///< GPGGA
#define PMTK_SET_NMEA_OUTPUT_RMCGGAGSA \
"$PMTK314,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0*29" ///< turn on GPRMC, GPGGA
///< and GPGSA
#define PMTK_SET_NMEA_OUTPUT_ALLDATA \
"$PMTK314,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0*28" ///< turn on ALL THE DATA
#define PMTK_SET_NMEA_OUTPUT_OFF \
"$PMTK314,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0*28" ///< turn off output
// to generate your own sentences, check out the MTK command datasheet and use a checksum calculator
// such as the awesome http://www.hhhh.org/wiml/proj/nmeaxor.html
// to generate your own sentences, check out the MTK command datasheet and use a
// checksum calculator such as the awesome
// http://www.hhhh.org/wiml/proj/nmeaxor.html
#define PMTK_LOCUS_STARTLOG "$PMTK185,0*22" ///< Start logging data
#define PMTK_LOCUS_STOPLOG "$PMTK185,1*23" ///< Stop logging data
#define PMTK_LOCUS_STARTSTOPACK "$PMTK001,185,3*3C" ///< Acknowledge the start or stop command
#define PMTK_LOCUS_STARTSTOPACK \
"$PMTK001,185,3*3C" ///< Acknowledge the start or stop command
#define PMTK_LOCUS_QUERY_STATUS "$PMTK183*38" ///< Query the logging status
#define PMTK_LOCUS_ERASE_FLASH "$PMTK184,1*22" ///< Erase the log flash data
#define LOCUS_OVERLAP 0 ///< If flash is full, log will overwrite old data with new logs
#define LOCUS_OVERLAP \
0 ///< If flash is full, log will overwrite old data with new logs
#define LOCUS_FULLSTOP 1 ///< If flash is full, logging will stop
#define PMTK_ENABLE_SBAS "$PMTK313,1*2E" ///< Enable search for SBAS satellite (only works with 1Hz output rate)
#define PMTK_ENABLE_SBAS \
"$PMTK313,1*2E" ///< Enable search for SBAS satellite (only works with 1Hz
///< output rate)
#define PMTK_ENABLE_WAAS "$PMTK301,2*2E" ///< Use WAAS for DGPS correction data
#define PMTK_STANDBY "$PMTK161,0*28" ///< standby command & boot successful message
#define PMTK_STANDBY \
"$PMTK161,0*28" ///< standby command & boot successful message
#define PMTK_STANDBY_SUCCESS "$PMTK001,161,3*36" ///< Not needed currently
#define PMTK_AWAKE "$PMTK010,002*2D" ///< Wake up
#define PMTK_Q_RELEASE "$PMTK605*31" ///< ask for the release and version
#define PGCMD_ANTENNA "$PGCMD,33,1*6C" ///< request for updates on antenna status
#define PGCMD_ANTENNA \
"$PGCMD,33,1*6C" ///< request for updates on antenna status
#define PGCMD_NOANTENNA "$PGCMD,33,0*6D" ///< don't show antenna status messages
#define MAXWAITSENTENCE 10 ///< how long to wait when we're looking for a response
#define MAXWAITSENTENCE \
10 ///< how long to wait when we're looking for a response
/**************************************************************************/
/// type for resulting code from running check()
@ -154,10 +188,16 @@ class Adafruit_GPS : public Print{
boolean standby(void);
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
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
@ -167,11 +207,14 @@ class Adafruit_GPS : public Print{
uint8_t month; ///< GMT month
uint8_t day; ///< GMT day
float latitude; ///< Floating point latitude value in degrees/minutes as received from the GPS (DDMM.MMMM)
float longitude; ///< Floating point longitude value in degrees/minutes as received from the GPS (DDDMM.MMMM)
float latitude; ///< Floating point latitude value in degrees/minutes as
///< received from the GPS (DDMM.MMMM)
float 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:
/** 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
@ -183,9 +226,12 @@ class Adafruit_GPS : public Print{
float speed; ///< Current speed over ground in knots
float angle; ///< Course in degrees from true north
float magvariation; ///< Magnetic variation in degrees (vs. true north)
float HDOP; ///< Horizontal Dilution of Precision - relative accuracy of horizontal position
float VDOP; ///< Vertical Dilution of Precision - relative accuracy of vertical position
float PDOP; ///< Position Dilution of Precision - Complex maths derives a simple, single number for each kind of DOP
float HDOP; ///< Horizontal Dilution of Precision - relative accuracy of
///< horizontal position
float VDOP; ///< Vertical Dilution of Precision - relative accuracy of
///< vertical position
float PDOP; ///< Position Dilution of Precision - Complex maths derives a
///< simple, single number for each kind of DOP
char lat; ///< N/S
char lon; ///< E/W
char mag; ///< Magnetic variation direction
@ -194,7 +240,8 @@ class Adafruit_GPS : public Print{
uint8_t fixquality_3d; ///< 3D fix quality (1, 3, 3 = Nofix, 2D fix, 3D fix)
uint8_t satellites; ///< Number of satellites in use
boolean waitForSentence(const char *wait, uint8_t max = MAXWAITSENTENCE, boolean usingInterrupts = false);
boolean waitForSentence(const char *wait, uint8_t max = MAXWAITSENTENCE,
boolean usingInterrupts = false);
boolean LOCUS_StartLogger(void);
boolean LOCUS_StopLogger(void);
boolean LOCUS_ReadStatus(void);
@ -219,18 +266,24 @@ class Adafruit_GPS : public Print{
boolean parseLonDir(char *);
boolean parseFix(char *);
// used by check() for validity tests, room for future expansion
const char *sources[5] = {"II", "WI", "GP", "GN", "ZZZ"}; ///< valid source ids
const char *sentences_parsed[5] = {"GGA", "GLL", "GSA", "RMC", "ZZZ"}; ///< parseable sentence ids
const char *sentences_known[1] = {"ZZZ"}; ///< known, but not parseable sentence ids
const char *sources[5] = {"II", "WI", "GP", "GN",
"ZZZ"}; ///< valid source ids
const char *sentences_parsed[5] = {"GGA", "GLL", "GSA", "RMC",
"ZZZ"}; ///< parseable sentence ids
const char *sentences_known[1] = {
"ZZZ"}; ///< known, but not parseable sentence ids
// 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
// 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
uint32_t recvdTime =
2000000000L; ///< millis() when last full sentence received
uint32_t sentTime = 2000000000L; ///< millis() when first character of last
///< full sentence received
boolean paused;
uint8_t parseResponse(char *response);
@ -241,14 +294,17 @@ class Adafruit_GPS : public Print{
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!
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 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