Adafruit_GPS.h

Go to the documentation of this file.

/**************************************************************************/
/**************************************************************************/

#ifndef _ADAFRUIT_GPS_H
#define _ADAFRUIT_GPS_H

/**************************************************************************/
#ifndef NMEA_EXTRAS // inject on the compile command line to force extensions
#ifndef ARDUINO_ARCH_AVR
#define NMEA_EXTENSIONS 
#endif
#else
#if (NMEA_EXTRAS > 0)
#define NMEA_EXTENSIONS 
#endif
#endif

#if (defined(__AVR__) || ((defined(ARDUINO_UNOR4_WIFI) || defined(ESP8266)) && \
                          !defined(NO_SW_SERIAL)))
#define USE_SW_SERIAL 
#endif                
#define GPS_DEFAULT_I2C_ADDR                                                   \
  0x10 
#define GPS_MAX_I2C_TRANSFER                                                   \
  32 
#define GPS_MAX_SPI_TRANSFER                                                   \
  100                     
#define MAXLINELENGTH 120 
#define NMEA_MAX_SENTENCE_ID                                                   \
  20 
#define NMEA_MAX_SOURCE_ID                                                     \
  3 

#include "Arduino.h"
#ifdef USE_SW_SERIAL
#include <SoftwareSerial.h>
#endif
#include <Adafruit_PMTK.h>
#include <NMEA_data.h>
#include <SPI.h>
#include <Wire.h>

typedef enum {
  NMEA_BAD = 0, 
  NMEA_HAS_DOLLAR =
      1, 
  NMEA_HAS_CHECKSUM = 2,   
  NMEA_HAS_NAME = 4,       
  NMEA_HAS_SOURCE = 10,    
  NMEA_HAS_SENTENCE = 20,  
  NMEA_HAS_SENTENCE_P = 40 
} nmea_check_t;

/**************************************************************************/
class Adafruit_GPS : public Print {
public:
  // Adafruit_GPS.cpp
  bool begin(uint32_t baud_or_i2caddr);

#ifdef USE_SW_SERIAL
  Adafruit_GPS(SoftwareSerial *ser); // Constructor when using SoftwareSerial
#endif
  Adafruit_GPS(HardwareSerial *ser); // Constructor when using HardwareSerial
  Adafruit_GPS(Stream *data);        // Constructor when using Stream
  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
  void common_init(void);
  virtual ~Adafruit_GPS();

  size_t available(void);
  size_t write(uint8_t);
  char read(void);
  void sendCommand(const char *);
  bool newNMEAreceived();
  void pause(bool b);
  char *lastNMEA(void);
  bool waitForSentence(const char *wait, uint8_t max = MAXWAITSENTENCE,
                       bool usingInterrupts = false);
  bool LOCUS_StartLogger(void);
  bool LOCUS_StopLogger(void);
  bool LOCUS_ReadStatus(void);
  bool standby(void);
  bool wakeup(void);
  nmea_float_t secondsSinceFix();
  nmea_float_t secondsSinceTime();
  nmea_float_t secondsSinceDate();
  void resetSentTime();

  // 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', bool noCRLF = false);
#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; 
  char thisSource[NMEA_MAX_SOURCE_ID] = {
      0}; 
  char thisSentence[NMEA_MAX_SENTENCE_ID] = {
      0}; 
  char lastSource[NMEA_MAX_SOURCE_ID] = {
      0}; 
  char lastSentence[NMEA_MAX_SENTENCE_ID] = {
      0}; 

  uint8_t hour;          
  uint8_t minute;        
  uint8_t seconds;       
  uint16_t milliseconds; 
  uint8_t year;          
  uint8_t month;         
  uint8_t day;           

  nmea_float_t latitude;  
  nmea_float_t longitude; 

  int32_t latitude_fixed;  
  int32_t longitude_fixed; 

  nmea_float_t latitudeDegrees;  
  nmea_float_t longitudeDegrees; 
  nmea_float_t geoidheight;      
  nmea_float_t altitude;         
  nmea_float_t speed;            
  nmea_float_t angle;            
  nmea_float_t magvariation; 
  nmea_float_t HDOP; 
  nmea_float_t VDOP; 
  nmea_float_t PDOP; 
  char lat = 'X';    
  char lon = 'X';    
  char mag = 'X';    
  bool fix;          
  uint8_t fixquality;    
  uint8_t fixquality_3d; 
  uint8_t satellites;    
  uint8_t antenna;       

  uint16_t LOCUS_serial;  
  uint16_t LOCUS_records; 
  uint8_t LOCUS_type;     
  uint8_t LOCUS_mode;     
  uint8_t LOCUS_config;   
  uint8_t LOCUS_interval; 
  uint8_t LOCUS_distance; 
  uint8_t LOCUS_speed;    
  uint8_t LOCUS_status;   
  uint8_t LOCUS_percent;  

#ifdef NMEA_EXTENSIONS
  // NMEA additional public variables
  nmea_datavalue_t
      val[NMEA_MAX_INDEX]; 
  nmea_float_t depthToKeel =
      2.4; 
  nmea_float_t depthToTransducer =
      0.0; 

  char toID[NMEA_MAX_WP_ID] = {
      0}; 
  char fromID[NMEA_MAX_WP_ID] = {
      0}; 

  char txtTXT[63] = {0}; 
  int txtTot = 0;        
  int txtID = 0;         
  int txtN = 0;          
#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 parseAntenna(char *);
  bool isEmpty(char *pStart);

  // used by check() for validity tests, room for future expansion
  const char *sources[7] = {"II", "WI", "GP", "PG",
                            "GN", "P",  "ZZZ"}; 
#ifdef NMEA_EXTENSIONS
  const char *sentences_parsed[21] = {"GGA", "GLL", "GSA", "RMC", "DBT", "HDM",
                                      "HDT", "MDA", "MTW", "MWV", "RMB", "TOP",
                                      "TXT", "VHW", "VLW", "VPW", "VWR", "WCV",
                                      "XTE", "ZZZ"}; 
  const char *sentences_known[15] = {
      "APB", "DPT", "GSV", "HDG", "MWD", "ROT",
      "RPM", "RSA", "VDR", "VTG", "ZDA", "ZZZ"}; 
#else // make the lists short to save memory
  const char *sentences_parsed[6] = {"GGA", "GLL", "GSA", "RMC",
                                     "TOP", "ZZZ"}; 
  const char *sentences_known[4] = {"DBT", "HDM", "HDT",
                                    "ZZZ"}; 
#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; 
  uint32_t lastFix = 2000000000L;  
  uint32_t lastTime = 2000000000L; 
  uint32_t lastDate = 2000000000L; 
  uint32_t recvdTime =
      2000000000L; 
  uint32_t sentTime = 2000000000L; 
  bool paused;

  uint8_t parseResponse(char *response);
#ifdef USE_SW_SERIAL
  SoftwareSerial *gpsSwSerial;
#endif
  bool noComms = false;
  HardwareSerial *gpsHwSerial;
  Stream *gpsStream;
  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]; 
  volatile char line2[MAXLINELENGTH]; 
  volatile uint8_t lineidx = 0; 
  volatile char *currentline;   
  volatile char *lastline;      
  volatile bool recvdflag;      
  volatile bool inStandbyMode;  
};
/**************************************************************************/

#endif