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_GNSS.h>
#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 *);
  void sendCommand(const __FlashStringHelper *);
  bool newNMEAreceived();
  void pause(bool b);
  char *lastNMEA(void);
  gnss_position_t lastPosition() const;
  bool waitForSentence(const char *wait, uint8_t max = MAXWAITSENTENCE,
                       bool usingInterrupts = false, uint32_t timeout = 10000);
  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[][4]);
  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);
  void setCoordinate(const gnss_coordinate_t &coordinate,
                     nmea_float_t *angleDegrees, nmea_float_t *angle,
                     int32_t *angle_fixed, char *dir);
  gnss_sentence_status_t updatePosition(nmea_span_t type, nmea_span_t fields);
  bool parseAntenna(char *);
  bool isEmpty(char *pStart);

  // Shared flash tables avoid RAM copies of both the IDs and their pointers.
  static const char PROGMEM sources[][4];          
  static const char PROGMEM sentences_parsed[][4]; 
  static const char PROGMEM sentences_known[][4];  

  // 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 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
  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]; 
  Adafruit_GNSS receiver{line1, line2, MAXLINELENGTH}; 
  const char *volatile lastline =
      (const char *)line2;     
  volatile bool recvdflag;     
  volatile bool inStandbyMode; 
};
/**************************************************************************/

#endif