Merge pull request #155 from sparkfun/release_candidate

Merging release_candidate: updates for v1.8.8

Author: PaulZC

.gitignore

@@ -53,3 +53,6 @@ Temporary Items
 *~
 [._]*.un~
 *.swp
+
+# Zephyr build files
+examples/Zephyr/*/build/*

CONTRIBUTING.md

@@ -1,14 +1,19 @@
-### How to Contribute
+# How to Contribute
 
 Thank you so *much* for offering to help out. We truly appreciate it.
 
 If you'd like to contribute, start by searching through the [issues](https://github.com/sparkfun/SparkFun_Ublox_Arduino_Library/issues) and [pull requests](https://github.com/sparkfun/SparkFun_Ublox_Arduino_Library/pulls) to see whether someone else has raised a similar idea or question.
+Please check the [closed issues](https://github.com/sparkfun/SparkFun_Ublox_Arduino_Library/issues?q=is%3Aissue+is%3Aclosed)
+and [closed pull requests](https://github.com/sparkfun/SparkFun_Ublox_Arduino_Library/pulls?q=is%3Apr+is%3Aclosed) too - you may find that your issue or feature has already been discussed.
 
 If you decide to add a feature to this library, please create a PR and follow these best practices:
 
-* Change as little as possible. Do not sumbit a PR that changes 100 lines of whitespace. Break up into multiple PRs if necessary.
+* Change as little as possible. Do not submit a PR that changes 100 lines of whitespace. Break up into multiple PRs if necessary.
 * If you've added a new feature document it with a simple example sketch. This serves both as a test of your PR and as a quick way for users to quickly learn how to use your new feature.
-* If you add new functions also add them to keywords.txt so that they are properly highlighted in Arduino. [Read more](https://www.arduino.cc/en/Hacking/libraryTutorial).
+* If you add new functions also add them to _keywords.txt_ so that they are properly highlighted in Arduino. [Read more](https://www.arduino.cc/en/Hacking/libraryTutorial).
+* **Important:** Please submit your PR using the [release_candidate branch](https://github.com/sparkfun/SparkFun_Ublox_Arduino_Library/tree/release_candidate). That way, we can merge and test your PR quickly without changing the _master_ branch
+
+![Contributing.JPG](./img/Contributing.JPG)
 
 ## Style guide
 

README.md

@@ -48,18 +48,32 @@ Thanks to:
 * [averywallis](https://github.com/averywallis) for adding good comments to the various constants.
 * [blazczak](https://github.com/blazczak) and [geeksville](https://github.com/geeksville) for adding support for the series 6 and 7 modules.
 * [bjorn@unsurv](https://github.com/unsurv) for adding powerOff and powerOffWithInterrupt.
+* [dotMorten](https://github.com/dotMorten) for the MSGOUT keys, autoHPPOSLLH, autoDOP and upgrades to autoPVT.
+* [markuckermann](https://github.com/markuckermann) for spotting the config layer gremlins
+* [vid553](https://github.com/vid553) for the Zephyr port
+* [balamuruganky](https://github.com/balamuruganky) for the NAV-PVT velocity parameters
+* [nelarsen](https://github.com/nelarsen) for the buffer overrun improvements
+* [mstranne](https://github.com/mstranne) and [shaneperera](https://github.com/shaneperera) for the pushRawData suggestion
+* [rubienr](https://github.com/rubienr) for spotting the logical AND issues
 
 Need a Python version for Raspberry Pi? Checkout the [Qwiic Ublox GPS Py module](https://github.com/sparkfun/Qwiic_Ublox_Gps_Py).
 
 Need a library for the Ublox and Particle? Checkout the [Particle library](https://github.com/aseelye/SparkFun_Ublox_Particle_Library) fork.
 
+Contributing
+--------------
+
+If you would like to contribute to this library: please do, we truly appreciate it, but please follow [these guidelines](./CONTRIBUTING.md). Thanks!
+
 Repository Contents
 -------------------
 
 * **/examples** - Example sketches for the library (.ino). Run these from the Arduino IDE.
 * **/src** - Source files for the library (.cpp, .h).
-* **keywords.txt** - Keywords from this library that will be highlighted in the Arduino IDE.
-* **library.properties** - General library properties for the Arduino package manager.
+* **[keywords.txt](./keywords.txt)** - Keywords from this library that will be highlighted in the Arduino IDE.
+* **[library.properties](./library.properties)** - General library properties for the Arduino package manager.
+* **[CONTRIBUTING.md](./CONTRIBUTING.md)** - Guidelines on how to contribute to this library.
+* **[Theory.md](./Theory.md)** - provides detail on how data is processed by the library.
 
 Documentation
 --------------

Theory.md

@@ -19,14 +19,21 @@ A method will call **sendCommand()**. This will begin waiting for a response wit
 
 Once **waitForACKResponse()** or **waitForNoACKResponse()** is called the library will start checking the ublox module for new bytes. These bytes may be part of a NMEA sentence, an RTCM sentence, or a UBX packet. The library will file each byte into the appropriate container. Once a given sentence or packet is complete, the appropriate processUBX(), processNMEA() will be called. These functions deal with specific processing for each type.
 
-Note: When interfacing to a ublox module over I2C **checkUbloxI2C()** will read all bytes currently sitting in the I2C buffer. This may pick up multiple UBX packets. For example, an ACK for a VALSET may be mixed in with an auto-PVT response. We cannot tell **checkUbloxI2C()** to stop once a given ACK is found because we run the risk of leaving bytes in the I2C buffer and losing them. We don't have this issue with **checkUbloxSerial()**.
+Note: When interfacing to a ublox module over I2C **checkUbloxI2C()** will read all bytes currently sitting in the I2C buffer. This may pick up multiple UBX packets. For example, an ACK for a VALSET may be mixed in with an **AutoPVT** response. We cannot tell **checkUbloxI2C()** to stop once a given ACK is found because we run the risk of leaving unprocessed bytes in the I2C buffer and losing them. We don't have this issue with **checkUbloxSerial()**.
 
 **processUBX()** will check the CRC of the UBX packet. If validated, the packet will be marked as valid. Once a packet is marked as valid then **processUBXpacket()** is called to extract the contents. This is most commonly used to get the position, velocity, and time (PVT) out of the packet but is also used to check the nature of an ACK packet.
 
-Once a packet has been processed, **waitForACKResponse()/waitForNoACKResponse()** makes the appropriate decision what to do with it. If a packet satisfies the CLS/ID and characteristics of what **waitForACKResponse()/waitForNoACKResponse()** is waiting for, then it returns back to sendCommand. If the packet didn't match or was invalid then **waitForACKResponse()/waitForNoACKResponse()** will continue to wait until the correct packet is received or we time out. **sendCommand()** then returns with a value from the **sfe_ublox_status_e** enum depending on the success of **waitForACKResponse()/waitForNoACKResponse()**.
+Once a packet has been processed, **waitForACKResponse()/waitForNoACKResponse()** makes the appropriate decision what to do with it. If a packet satisfies the CLS/ID and characteristics of what **waitForACKResponse()/waitForNoACKResponse()** is waiting for, then it returns back to **sendCommand()**. If the packet didn't match or was invalid then **waitForACKResponse()/waitForNoACKResponse()** will continue to wait until the correct packet is received or we time out. **sendCommand()** then returns with a value from the **sfe_ublox_status_e** enum depending on the success of **waitForACKResponse()/waitForNoACKResponse()**.
 
 If we are getting / polling data from the module, **sendCommand()** will return **SFE_UBLOX_STATUS_DATA_RECEIVED** if the get was successful.
 
 If we are setting / writing data to the module, **sendCommand()** will return **SFE_UBLOX_STATUS_DATA_SENT** if the set was successful.
 
-There are circumstances where the library can get the data it is expecting from the module, but it is overwritten (e.g. by an auto-PVT packet) before **sendCommand()** is able to return. In this case, **sendCommand()** will return the error **SFE_UBLOX_STATUS_DATA_OVERWRITTEN**. We should simply call the library function again, but we will need to reset the packet contents first as they will indeed have been overwritten as the error implies.
+We are proud that this library still compiles and runs on the original RedBoard (ATmega328P). We achieve that by being very careful about how much RAM we allocate to packet storage. We use only three buffers or containers to store the incoming data:
+- **packetBuf** (packetBuffer) - is small and is used to store only the head (and tail) of incoming UBX packets until we know they are. If the packet is _expected_ (i.e. it matches the Class and ID in the packet passed in **sendCommand()**) then the incoming bytes are diverted into **packetCfg** or **packetAck**. Unexpected packets are ignored.
+- **packetCfg** (packetConfiguration) - is used to store an _expected_ incoming UBX packet of up to 256 bytes. E.g. **getProtocolVersion()** returns about 220 bytes. Message data requested by a higher function is returned in packetCfg.
+- **packetAck** (packetAcknowledge) - is small and is used to store the ACK or NACK accompanying any _expected_ packetCfg.
+
+**AutoPVT**, **AutoHPPOSLLH** and **AutoDOP** packets can arrive at any time. They too _have_ to be stored and processed in **packetCfg**. This means there are circumstances where the library can get the data it is expecting from the module, but it is overwritten (e.g. by an **AutoPVT** packet) before **sendCommand()** is able to return. In this case, **sendCommand()** will return the error **SFE_UBLOX_STATUS_DATA_OVERWRITTEN**. We should simply call the library function again, but we will need to reset the packet contents first as they will indeed have been overwritten as the error implies.
+
+Need a command that is not currently "built-in" to the library? You can do that using a Custom Command. Check out [Example20_SendCustomCommand](https://github.com/sparkfun/SparkFun_Ublox_Arduino_Library/blob/master/examples/Example20_SendCustomCommand/Example20_SendCustomCommand.ino) for further details. Note: this will of course increase your RAM use.

examples/Example13_PVT/Example1_AutoPVT/Example1_AutoPVT.ino

@@ -78,7 +78,32 @@ void loop()
     int PDOP = myGPS.getPDOP();
     Serial.print(F(" PDOP: "));
     Serial.print(PDOP);
-    Serial.print(F(" (10^-2)"));    
+    Serial.print(F(" (10^-2)"));
+
+    int nedNorthVel = myGPS.getNedNorthVel();
+    Serial.print(F(" VelN: "));
+    Serial.print(nedNorthVel);
+    Serial.print(F(" (mm/s)"));
+
+    int nedEastVel = myGPS.getNedEastVel();
+    Serial.print(F(" VelE: "));
+    Serial.print(nedEastVel);
+    Serial.print(F(" (mm/s)"));
+
+    int nedDownVel = myGPS.getNedDownVel();
+    Serial.print(F(" VelD: "));
+    Serial.print(nedDownVel);
+    Serial.print(F(" (mm/s)"));
+
+    int verticalAccEst = myGPS.getVerticalAccEst();
+    Serial.print(F(" VAccEst: "));
+    Serial.print(verticalAccEst);
+    Serial.print(F(" (mm)"));
+
+    int horizontalAccEst = myGPS.getHorizontalAccEst();
+    Serial.print(F(" HAccEst: "));
+    Serial.print(horizontalAccEst);
+    Serial.print(F(" (mm)"));
 
     Serial.println();
   } else {

examples/Series_6_7/Example1_GetPositionAndTime_Series_6_7/SparkFun_Ublox_Arduino_Library_Series_6_7.cpp

@@ -899,7 +899,9 @@ void SFE_UBLOX_GPS::processUBXpacket(ubxPacket *msg)
   switch (msg->cls)
   {
   case UBX_CLASS_NAV:
-    if (msg->id == UBX_NAV_PVT && msg->len == 92)
+    //u-blox8 length == 92
+    //u-blox7 length == 84
+    if ((msg->id == UBX_NAV_PVT) && ((msg->len == 92) || (msg->len == 84)))
     {
       //Parse various byte fields into global vars
       constexpr int startingSpot = 0; //fixed value used in processUBX
@@ -915,6 +917,7 @@ void SFE_UBLOX_GPS::processUBXpacket(ubxPacket *msg)
       gpsNanosecond = extractLong(16); //Includes milliseconds
 
       fixType = extractByte(20 - startingSpot);
+      //Note: the u-blox7 does not support carrSoln. carrierSolution will be zero.
       carrierSolution = extractByte(21 - startingSpot) >> 6; //Get 6th&7th bits of this byte
       SIV = extractByte(23 - startingSpot);
       longitude = extractLong(24 - startingSpot);

examples/ZED-F9P/Example11_setStaticPosition/Example11_setStaticPosition.ino renamed to examples/ZED-F9P/Example12_setStaticPosition/Example12_setStaticPosition.ino

@@ -43,6 +43,7 @@ void setup()
   Wire.begin();
 
   //myGPS.enableDebugging(); // Uncomment this line to enable lots of helpful debug messages
+  //myGPS.enableDebugging(Serial, true); // Uncomment this line to enable the minimum of helpful debug messages
 
   if (myGPS.begin() == false) //Connect to the Ublox module using Wire port
   {
@@ -55,21 +56,21 @@ void setup()
 
   myGPS.setI2COutput(COM_TYPE_UBX); //Set the I2C port to output UBX only (turn off NMEA noise)
   myGPS.saveConfigSelective(VAL_CFG_SUBSEC_IOPORT); //Save the communications port settings to flash and BBR
-  
+
   myGPS.setNavigationFrequency(1); //Produce one solution per second
-  
+
 
   // The acid test: all four of these combinations should work seamlessly :-)
-  
+
   //myGPS.setAutoPVT(false); // Library will poll each reading
   //myGPS.setAutoHPPOSLLH(false); // Library will poll each reading
-  
+
   //myGPS.setAutoPVT(true); // Tell the GPS to "send" each solution automatically
   //myGPS.setAutoHPPOSLLH(false); // Library will poll each reading
 
   //myGPS.setAutoPVT(false); // Library will poll each reading
   //myGPS.setAutoHPPOSLLH(true); // Tell the GPS to "send" each hi res solution automatically
-  
+
   myGPS.setAutoPVT(true); // Tell the GPS to "send" each solution automatically
   myGPS.setAutoHPPOSLLH(true); // Tell the GPS to "send" each hi res solution automatically
 }
@@ -81,31 +82,31 @@ void loop()
   if ((myGPS.getHPPOSLLH()) || (myGPS.getPVT()))
   {
     Serial.println();
-      
+
     long highResLatitude = myGPS.getHighResLatitude();
     Serial.print(F("Hi Res Lat: "));
     Serial.print(highResLatitude);
-  
+
     int highResLatitudeHp = myGPS.getHighResLatitudeHp();
     Serial.print(F(" "));
     Serial.print(highResLatitudeHp);
-  
+
     long highResLongitude = myGPS.getHighResLongitude();
     Serial.print(F(" Hi Res Long: "));
     Serial.print(highResLongitude);
-  
+
     int highResLongitudeHp = myGPS.getHighResLongitudeHp();
     Serial.print(F(" "));
     Serial.print(highResLongitudeHp);
-  
+
     unsigned long horizAccuracy = myGPS.getHorizontalAccuracy();
     Serial.print(F(" Horiz accuracy: "));
     Serial.print(horizAccuracy);
-  
+
     long latitude = myGPS.getLatitude();
     Serial.print(F(" Lat: "));
     Serial.print(latitude);
-  
+
     long longitude = myGPS.getLongitude();
     Serial.print(F(" Long: "));
     Serial.println(longitude);

examples/ZED-F9P/Example11_autoHPPOSLLH/Example11_autoHPPOSLLH.ino renamed to examples/ZED-F9P/Example13_autoHPPOSLLH/Example13_autoHPPOSLLH.ino

@@ -29,12 +29,19 @@
 #include "SparkFun_Ublox_Arduino_Library.h" //http://librarymanager/All#SparkFun_Ublox_GPS
 SFE_UBLOX_GPS myGPS;
 
+//#define USE_SERIAL1 // Uncomment this line to push the RTCM data to Serial1
+
 void setup()
 {
   Serial.begin(115200);
   while (!Serial); //Wait for user to open terminal
   Serial.println("Ublox Base station example");
 
+#ifdef USE_SERIAL1
+  // If our board supports it, we can output the RTCM data on Serial1
+  Serial1.begin(115200);
+#endif
+
   Wire.begin();
   Wire.setClock(400000); //Increase I2C clock speed to 400kHz
 
@@ -44,8 +51,11 @@ void setup()
     while (1);
   }
 
+  // Uncomment the next line if you want to reset your module back to the default settings with 1Hz navigation rate
+  //myGPS.factoryDefault(); delay(5000);
+
   myGPS.setI2COutput(COM_TYPE_UBX); //Set the I2C port to output UBX only (turn off NMEA noise)
-  myGPS.saveConfiguration(); //Save the current settings to flash and BBR
+  myGPS.saveConfigSelective(VAL_CFG_SUBSEC_IOPORT); //Save the communications port settings to flash and BBR
 
   while (Serial.available()) Serial.read(); //Clear any latent chars in serial buffer
   Serial.println("Press any key to send commands to begin Survey-In");
@@ -153,7 +163,12 @@ void loop()
 //Useful for passing the RTCM correction data to a radio, Ntrip broadcaster, etc.
 void SFE_UBLOX_GPS::processRTCM(uint8_t incoming)
 {
-  //Let's just pretty-print the HEX values for now
+#ifdef USE_SERIAL1
+  //Push the RTCM data to Serial1
+  Serial1.write(incoming);
+#endif
+
+  //Pretty-print the HEX values to Serial
   if (myGPS.rtcmFrameCounter % 16 == 0) Serial.println();
   Serial.print(" ");
   if (incoming < 0x10) Serial.print("0");

examples/ZED-F9P/Example3_StartRTCMBase/Example3_StartRTCMBase.ino

@@ -26,12 +26,21 @@
 #include "SparkFun_Ublox_Arduino_Library.h" //http://librarymanager/All#SparkFun_Ublox_GPS
 SFE_UBLOX_GPS myGPS;
 
+//#define USE_SERIAL1 // Uncomment this line to push the RTCM data from Serial1 to the module via I2C
+
+size_t numBytes = 0; // Record the number os bytes received from Serial1
+
 void setup()
 {
   Serial.begin(115200);
   while (!Serial); //Wait for user to open terminal
   Serial.println("Ublox Base station example");
 
+#ifdef USE_SERIAL1
+  // If our board supports it, we can receive the RTCM data on Serial1
+  Serial1.begin(115200);
+#endif
+
   Wire.begin();
   Wire.setClock(400000); //Increase I2C clock speed to 400kHz
 
@@ -40,6 +49,15 @@ void setup()
     Serial.println(F("Ublox GPS not detected at default I2C address. Please check wiring. Freezing."));
     while (1);
   }
+
+  // Uncomment the next line if you want to reset your module back to the default settings with 1Hz navigation rate
+  //myGPS.factoryDefault(); delay(5000);
+
+#ifdef USE_SERIAL1
+  Serial.print(F("Enabling UBX and RTCM input on I2C. Result: "));
+  Serial.print(myGPS.setPortInput(COM_PORT_I2C, COM_TYPE_UBX | COM_TYPE_RTCM3)); //Enable UBX and RTCM input on I2C
+  myGPS.saveConfigSelective(VAL_CFG_SUBSEC_IOPORT); //Save the communications port settings to flash and BBR
+#endif
 }
 
 void loop()
@@ -121,5 +139,23 @@ void loop()
   else
     Serial.println("RELPOS request failed");
 
-  delay(4000);
+  for (int i = 0; i < 500; i++)
+  {
+#ifdef USE_SERIAL1
+    uint8_t store[256];
+    while ((Serial1.available()) && (numBytes < 256)) // Check if data has been received
+    {
+      store[numBytes++] = Serial1.read(); // Read a byte from Serial1 and store it
+    }
+    if (numBytes > 0) // Check if data was received
+    {
+      //Serial.print("Pushing ");
+      //Serial.print(numBytes);
+      //Serial.println(" bytes via I2C");
+      myGPS.pushRawData(((uint8_t *)&store), numBytes); // Push the RTCM data via I2C
+      numBytes = 0; // Reset numBytes
+    }
+#endif
+    delay(10);
+  }
 }

examples/ZED-F9P/Example5_RelativePositioningInformation/Example5_RelativePositioningInformation.ino

@@ -67,15 +67,15 @@ void setup()
   //Original: myGPS.enableRTCMmessage(UBX_RTCM_1005, COM_PORT_I2C, 1); //Enable message 1005 to output through I2C port, message every second
 
   //Begin with newCfgValset8/16/32
-  setValueSuccess &= myGPS.newCfgValset8(CFG_MSGOUT_RTCM_3X_TYPE1005_I2C, 1); //Set output rate of msg 1005 over the I2C port to once per measurement (value is 8-bit (U1))
-  //setValueSuccess &= myGPS.newCfgValset8(CFG_MSGOUT_RTCM_3X_TYPE1005_I2C, 1, 7); //Set this and the following settings into Flash/RAM/BBR instead of BBR
+  setValueSuccess &= myGPS.newCfgValset8(UBLOX_CFG_MSGOUT_RTCM_3X_TYPE1005_I2C, 1); //Set output rate of msg 1005 over the I2C port to once per measurement (value is 8-bit (U1))
+  //setValueSuccess &= myGPS.newCfgValset8(UBLOX_CFG_MSGOUT_RTCM_3X_TYPE1005_I2C, 1, VAL_LAYER_RAM); //Set this and the following settings in RAM only instead of Flash/RAM/BBR
   //Add extra keyIDs and values using addCfgValset8/16/32
-  setValueSuccess &= myGPS.addCfgValset8(CFG_MSGOUT_RTCM_3X_TYPE1077_I2C, 1); //Set output rate of msg 1077 over the I2C port to once per measurement (value is 8-bit (U1))
-  setValueSuccess &= myGPS.addCfgValset8(CFG_MSGOUT_RTCM_3X_TYPE1087_I2C, 1); //Set output rate of msg 1087 over the I2C port to once per measurement (value is 8-bit (U1))
-  setValueSuccess &= myGPS.addCfgValset8(CFG_MSGOUT_RTCM_3X_TYPE1127_I2C, 1); //Set output rate of msg 1127 over the I2C port to once per measurement (value is 8-bit (U1))
-  setValueSuccess &= myGPS.addCfgValset8(CFG_MSGOUT_RTCM_3X_TYPE1097_I2C, 1); //Set output rate of msg 1097 over the I2C port to once per measurement (value is 8-bit (U1))
+  setValueSuccess &= myGPS.addCfgValset8(UBLOX_CFG_MSGOUT_RTCM_3X_TYPE1077_I2C, 1); //Set output rate of msg 1077 over the I2C port to once per measurement (value is 8-bit (U1))
+  setValueSuccess &= myGPS.addCfgValset8(UBLOX_CFG_MSGOUT_RTCM_3X_TYPE1087_I2C, 1); //Set output rate of msg 1087 over the I2C port to once per measurement (value is 8-bit (U1))
+  setValueSuccess &= myGPS.addCfgValset8(UBLOX_CFG_MSGOUT_RTCM_3X_TYPE1127_I2C, 1); //Set output rate of msg 1127 over the I2C port to once per measurement (value is 8-bit (U1))
+  setValueSuccess &= myGPS.addCfgValset8(UBLOX_CFG_MSGOUT_RTCM_3X_TYPE1097_I2C, 1); //Set output rate of msg 1097 over the I2C port to once per measurement (value is 8-bit (U1))
   // Add the final value and send the packet using sendCfgValset8/16/32
-  setValueSuccess &= myGPS.sendCfgValset8(CFG_MSGOUT_RTCM_3X_TYPE1230_I2C, 10); //Set output rate of msg 1230 over the I2C port to once every 10 measurements (value is 8-bit (U1))
+  setValueSuccess &= myGPS.sendCfgValset8(UBLOX_CFG_MSGOUT_RTCM_3X_TYPE1230_I2C, 10); //Set output rate of msg 1230 over the I2C port to once every 10 measurements (value is 8-bit (U1))
 
   if (setValueSuccess == true)
   {

examples/ZED-F9P/Example9_multiSetVal/Example9_multiSetVal.ino

@@ -0,0 +1,14 @@
+# SPDX-License-Identifier: Apache-2.0
+
+cmake_minimum_required(VERSION 3.13.1)
+
+find_package(Zephyr HINTS $ENV{ZEPHYR_BASE})
+project(sparkfun_ublox_zephyr_library)
+
+zephyr_compile_options(-fdiagnostics-color=always)
+
+zephyr_include_directories(.)
+target_sources(app PRIVATE src/SparkFun_Ublox_Zephyr_Library.cpp)
+target_sources(app PRIVATE src/SparkFun_Ublox_Zephyr_Interface.cpp)
+
+target_sources(app PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src/main.c)

examples/Zephyr/Example1_GetPositionAndTime_Zephyr/CMakeLists.txt

@@ -0,0 +1,4 @@
+&i2c0 {
+	status = "okay";
+	compatible = "nordic,nrf-twim";
+};

examples/Zephyr/Example1_GetPositionAndTime_Zephyr/nrf52840dk_nrf52840.overlay

@@ -0,0 +1,7 @@
+#turn on c++ support
+CONFIG_CPLUSPLUS=y
+
+# turn on peripherals
+CONFIG_GPIO=y
+CONFIG_I2C=y
+CONFIG_I2C_0=y

examples/Zephyr/Example1_GetPositionAndTime_Zephyr/prj.conf

@@ -0,0 +1,100 @@
+/*
+    This is an interface that connects the CPP Ublox library with the main C code.
+    Added to make it possible to run Ublox lib on Zephyr (NCS)
+
+    This port was made by Vid Rajtmajer <vid@irnas.eu>, www.irnas.eu
+*/
+#include "SparkFun_Ublox_Zephyr_Interface.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#include "SparkFun_Ublox_Zephyr_Library.h"
+
+
+SFE_UBLOX_GPS myGPS; // driver class instance
+long lastTime = 0;   // Simple local timer. Limits amount if I2C traffic to Ublox module.
+
+// init GPIO checksumFailurePin and load GPIO device pointer to the driver
+uint8_t set_gpio_dev(struct device *gpio_dev, uint8_t enable_debug)
+{
+    if (myGPS.init_gpio_pins(*gpio_dev) == false)
+    {
+        return -EIO;
+    }
+    // turn on debugging if enable_debug is set
+    if (enable_debug)
+    {
+        myGPS.enableDebugging();
+    }
+    return 0;
+}
+
+// initialize I2C and check if GPS device respons
+uint8_t gps_begin(struct device *i2c_dev)
+{
+    if (myGPS.begin(*i2c_dev) == false)
+    {
+        return -EIO;
+    }
+    return 0;
+}
+
+// This will pipe all NMEA sentences to UART so we can see them
+void pipe_nmea_sentences(void)
+{
+    myGPS.setNMEAOutputPort();
+}
+
+// Check for available bytes from the device
+void check_ublox(void)
+{
+    myGPS.checkUblox();
+}
+
+// Get position information when requested, also display number of satellites used in the fix
+int get_position(void)
+{
+    //Query module only every second. Doing it more often will just cause I2C traffic.
+    //The module only responds when a new position is available, print it to console
+    if (k_uptime_get_32() - lastTime > 1000)
+    {
+        lastTime = k_uptime_get_32(); //Update the timer
+
+        long latitude = myGPS.getLatitude();
+        long longitude = myGPS.getLongitude();
+        long altitude = myGPS.getAltitude();
+        uint8_t SIV = myGPS.getSIV();
+
+        printk("Position: Lat: %ld, Lon: %ld, Alt: %ld, SIV: %d", latitude, longitude, altitude, SIV);
+        return 0;
+    }
+    return -EBUSY;
+}
+
+// Get date and time information when requested, check if they are valid and print info to console, it returns UNIX time
+void get_datetime(void)
+{
+    int year = myGPS.getYear();
+    int month = myGPS.getMonth();
+    int day = myGPS.getDay();
+    int hour = myGPS.getHour();
+    int minute = myGPS.getMinute();
+    int second = myGPS.getSecond();
+
+    printk("DateTime: %d-%d-%d %d:%d:%d\n", year, month, day, hour, minute, second);
+
+    printk("Time is ");
+    if (myGPS.getTimeValid() == false)
+    {
+      printk("not ");
+    }
+    printk("valid. Date is ");
+    if (myGPS.getDateValid() == false)
+    {
+      printk("not ");
+    }
+    printk("valid.\n");
+}

examples/Zephyr/Example1_GetPositionAndTime_Zephyr/src/SparkFun_Ublox_Zephyr_Interface.cpp

@@ -0,0 +1,29 @@
+/*
+    This is an interface that connects the CPP Ublox library with the main C code.
+    Added to make it possible to run Ublox lib on Zephyr (NCS)
+
+    This port was made by Vid Rajtmajer <vid@irnas.eu>, www.irnas.eu
+*/
+#include <time.h>
+#include <zephyr.h>
+
+#ifndef _UBLOX_LIB_INTERFACE_H_
+#define _UBLOX_LIB_INTERFACE_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    uint8_t set_gpio_dev(struct device *gpio_dev, uint8_t enable_debug); // init GPIO
+    uint8_t gps_begin(struct device *i2c_dev);                           // initialize I2C and check if GPS device respons
+    void pipe_nmea_sentences(void);                                      // print NMEA sentences
+
+    void check_ublox(void);  // Check for available bytes from the device
+    int get_position(void); // Get position information
+    void get_datetime(void); // Get date and time information
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  //UBLOX_LIB_INTERFACE_H_

examples/Zephyr/Example1_GetPositionAndTime_Zephyr/src/SparkFun_Ublox_Zephyr_Interface.h

@@ -0,0 +1,102 @@
+/*
+    Reading lat, long and UTC time via UBX binary commands
+    By: Nathan Seidle
+    SparkFun Electronics
+    Date: August 22nd, 2018
+    License: MIT. See license file for more information but you can
+    basically do whatever you want with this code.
+
+    This example reads the NMEA setences from the Ublox module over I2c and outputs
+    them to the serial port
+
+    Open the serial monitor at 115200 baud to see the output
+    I2C clock speed: 100 kHz
+
+    Ported to Zephyr by Vid Rajtmajer <vid@irnas.eu>, www.irnas.eu
+
+    Development environment specifics: NCS v1.0.3 release
+
+    To build: west build -b <BOARD_NAME> -p    Can also read NMEA sentences over I2C with check_ublox function
+    To flash: west flash --erase
+*/
+#include <device.h>
+#include <drivers/i2c.h>
+#include <errno.h>
+#include <zephyr.h>
+#include <zephyr/types.h>
+
+#include "SparkFun_Ublox_Zephyr_Interface.h"
+
+
+#define I2C_DEV "I2C_0"
+
+struct device *gpio_dev;
+struct device *i2c_dev;
+/* I2C pins used are defaults for I2C_0 on nrf52840
+	SDA: 26
+	SCL: 27
+*/
+
+uint8_t init_gpio(void) {
+	const char* gpioName = "GPIO_0";
+	gpio_dev = device_get_binding(gpioName);
+	if (gpio_dev == NULL) {
+		printk("Error: Could not get %s device\n", gpioName);
+		return -EIO;
+	}
+    int err = set_gpio_dev(gpio_dev, true);     // set GPIO_0 device and enable debugging
+    if (err) {
+        return -EIO;
+    }
+    return 0;
+}
+
+uint8_t init_i2c(void) {
+	i2c_dev = device_get_binding(I2C_DEV);
+    if (!i2c_dev)
+    {
+        printk("I2C_0 error\n");
+        return -1;
+    }
+    else
+    {
+        printk("I2C_0 Init OK\n");
+        return 0;
+    }
+}
+
+uint8_t init_gps(void) {
+	if (gps_begin(i2c_dev) != 0)
+  	{
+    	printk("Ublox GPS init error!\n");
+        return -1;
+  	}
+    return 0;
+}
+
+
+void main(void) {
+	printk("Zephyr Ublox example\n");
+
+	int err;
+    err = init_gpio();
+    if (err) {
+        return;
+    }
+    err = init_i2c();
+    if (err) {
+        return;
+    }
+
+	err = init_gps();
+    if (err) {
+        return;
+    }
+
+	while(1) {
+        //check_ublox(); // See if new data is available. Process bytes as they come in.
+        get_position();
+        get_datetime();
+        k_msleep(250); // Don't pound too hard on the I2C bus
+	}
+}

examples/Zephyr/Example1_GetPositionAndTime_Zephyr/src/SparkFun_Ublox_Zephyr_Library.cpp

@@ -53,6 +53,11 @@ getGroundSpeed	KEYWORD2
 getHeading	KEYWORD2
 getPDOP	KEYWORD2
 getTimeOfWeek	KEYWORD2
+getHorizontalAccEst	KEYWORD2
+getVerticalAccEst	KEYWORD2
+getNedNorthVel	KEYWORD2
+getNedEastVel	KEYWORD2
+getNedDownVel	KEYWORD2
 
 setPortOutput	KEYWORD2
 setPortInput	KEYWORD2
@@ -168,6 +173,8 @@ getI2CTransactionSize	KEYWORD2
 
 setStaticPosition   KEYWORD2
 
+pushRawData   KEYWORD2
+
 #######################################
 # Constants (LITERAL1)
 #######################################

examples/Zephyr/Example1_GetPositionAndTime_Zephyr/src/SparkFun_Ublox_Zephyr_Library.h

@@ -1,5 +1,5 @@
 name=SparkFun u-blox Arduino Library
-version=1.8.7
+version=1.8.8
 author=SparkFun Electronics <techsupport@sparkfun.com>
 maintainer=SparkFun Electronics <sparkfun.com>
 sentence=Library for I2C and Serial Communication with u-blox modules

examples/Zephyr/Example1_GetPositionAndTime_Zephyr/src/main.c

@@ -52,20 +52,6 @@
 
 #include "u-blox_config_keys.h"
 
-// Define Serial for SparkFun SAMD based boards.
-// Boards like the RedBoard Turbo use SerialUSB (not Serial).
-// But other boards like the SAMD51 Thing Plus use Serial (not SerialUSB).
-// The next nine lines let the code compile cleanly on as many SAMD boards as possible.
-#if defined(ARDUINO_ARCH_SAMD)												// Is this a SAMD board?
-#if defined(USB_VID)														// Is the USB Vendor ID defined?
-#if (USB_VID == 0x1B4F)														// Is this a SparkFun board?
-#if !defined(ARDUINO_SAMD51_THING_PLUS) & !defined(ARDUINO_SAMD51_MICROMOD) // If it is not a SAMD51 Thing Plus or SAMD51 MicroMod
-#define Serial SerialUSB													// Define Serial as SerialUSB
-#endif
-#endif
-#endif
-#endif
-
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 //Define a digital pin to aid checksum failure capture and analysis
@@ -492,6 +478,7 @@ class SFE_UBLOX_GPS
 // The same is true for getHPPOSLLH.
 #define getPVTmaxWait 1100		// Default maxWait for getPVT and all functions which call it
 #define getHPPOSLLHmaxWait 1100 // Default maxWait for getHPPOSLLH and all functions which call it
+#define getDOPmaxWait 1100 // Default maxWait for getDOP and all functions which all it
 
 	boolean assumeAutoPVT(boolean enabled, boolean implicitUpdate = true);							//In case no config access to the GPS is possible and PVT is send cyclically already
 	boolean setAutoPVT(boolean enabled, uint16_t maxWait = defaultMaxWait);							//Enable/disable automatic PVT reports at the navigation frequency
@@ -501,13 +488,27 @@ class SFE_UBLOX_GPS
 	boolean setAutoHPPOSLLH(boolean enabled, uint16_t maxWait = defaultMaxWait);							//Enable/disable automatic HPPOSLLH reports at the navigation frequency
 	boolean setAutoHPPOSLLH(boolean enabled, boolean implicitUpdate, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic HPPOSLLH reports at the navigation frequency, with implicitUpdate == false accessing stale data will not issue parsing of data in the rxbuffer of your interface, instead you have to call checkUblox when you want to perform an update
 	boolean getHPPOSLLH(uint16_t maxWait = getHPPOSLLHmaxWait);										//Query module for latest group of datums and load global vars: lat, long, alt, speed, SIV, accuracies, etc. If autoPVT is disabled, performs an explicit poll and waits, if enabled does not block. Returns true if new HPPOSLLH is available.
+  boolean assumeAutoDOP(boolean enabled, boolean implicitUpdate = true);              //In case no config access to the GPS is possible and DOP is send cyclically already
+  boolean setAutoDOP(boolean enabled, uint16_t maxWait = defaultMaxWait);              //Enable/disable automatic DOP reports at the navigation frequency
+  boolean setAutoDOP(boolean enabled, boolean implicitUpdate, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic DOP reports at the navigation frequency, with implicitUpdate == false accessing stale data will not issue parsing of data in the rxbuffer of your interface, instead you have to call checkUblox when you want to perform an update
+  boolean getDOP(uint16_t maxWait = getDOPmaxWait);                   //Query module for latest dilution of precision values and load global vars:. If autoDOP is disabled, performs an explicit poll and waits, if enabled does not block. Returns true if new DOP is available.
 	void flushPVT();																				//Mark all the PVT data as read/stale. This is handy to get data alignment after CRC failure
 	void flushHPPOSLLH();																				//Mark all the PVT data as read/stale. This is handy to get data alignment after CRC failure
+  void flushDOP();                                       //Mark all the DOP data as read/stale. This is handy to get data alignment after CRC failure
 
+	bool getGnssFixOk(uint16_t maxWait = getPVTmaxWait);          //Get whether we have a valid fix (i.e within DOP & accuracy masks)
+	bool getDiffSoln(uint16_t maxWait = getPVTmaxWait);           //Get whether differential corrections were applied
 	int32_t getLatitude(uint16_t maxWait = getPVTmaxWait);			  //Returns the current latitude in degrees * 10^-7. Auto selects between HighPrecision and Regular depending on ability of module.
 	int32_t getLongitude(uint16_t maxWait = getPVTmaxWait);			  //Returns the current longitude in degrees * 10-7. Auto selects between HighPrecision and Regular depending on ability of module.
 	int32_t getAltitude(uint16_t maxWait = getPVTmaxWait);			  //Returns the current altitude in mm above ellipsoid
 	int32_t getAltitudeMSL(uint16_t maxWait = getPVTmaxWait);		  //Returns the current altitude in mm above mean sea level
+
+	int32_t getHorizontalAccEst(uint16_t maxWait = getPVTmaxWait);
+	int32_t getVerticalAccEst(uint16_t maxWait = getPVTmaxWait);
+	int32_t getNedNorthVel(uint16_t maxWait = getPVTmaxWait);
+	int32_t getNedEastVel(uint16_t maxWait = getPVTmaxWait);
+	int32_t getNedDownVel(uint16_t maxWait = getPVTmaxWait);
+
 	uint8_t getSIV(uint16_t maxWait = getPVTmaxWait);				  //Returns number of sats used in fix
 	uint8_t getFixType(uint16_t maxWait = getPVTmaxWait);			  //Returns the type of fix: 0=no, 3=3D, 4=GNSS+Deadreckoning
 	uint8_t getCarrierSolutionType(uint16_t maxWait = getPVTmaxWait); //Returns RTK solution: 0=no, 1=float solution, 2=fixed solution
@@ -538,6 +539,14 @@ class SFE_UBLOX_GPS
 	uint32_t getHorizontalAccuracy(uint16_t maxWait = getHPPOSLLHmaxWait);
 	uint32_t getVerticalAccuracy(uint16_t maxWait = getHPPOSLLHmaxWait);
 
+  uint16_t getGeometricDOP(uint16_t maxWait = getDOPmaxWait);
+  uint16_t getPositionDOP(uint16_t maxWait = getDOPmaxWait);
+  uint16_t getTimeDOP(uint16_t maxWait = getDOPmaxWait);
+  uint16_t getVerticalDOP(uint16_t maxWait = getDOPmaxWait);
+  uint16_t getHorizontalDOP(uint16_t maxWait = getDOPmaxWait);
+  uint16_t getNorthingDOP(uint16_t maxWait = getDOPmaxWait);
+  uint16_t getEastingDOP(uint16_t maxWait = getDOPmaxWait);
+
 	//Port configurations
 	boolean setPortOutput(uint8_t portID, uint8_t comSettings, uint16_t maxWait = defaultMaxWait); //Configure a given port to output UBX, NMEA, RTCM3 or a combination thereof
 	boolean setPortInput(uint8_t portID, uint8_t comSettings, uint16_t maxWait = defaultMaxWait);  //Configure a given port to input UBX, NMEA, RTCM3 or a combination thereof
@@ -574,9 +583,9 @@ class SFE_UBLOX_GPS
 	uint8_t setVal8(uint32_t keyID, uint8_t value, uint8_t layer = VAL_LAYER_ALL, uint16_t maxWait = 250);				 //Sets the 8-bit value at a given group/id/size location
 	uint8_t setVal16(uint32_t keyID, uint16_t value, uint8_t layer = VAL_LAYER_ALL, uint16_t maxWait = 250);			 //Sets the 16-bit value at a given group/id/size location
 	uint8_t setVal32(uint32_t keyID, uint32_t value, uint8_t layer = VAL_LAYER_ALL, uint16_t maxWait = 250);			 //Sets the 32-bit value at a given group/id/size location
-	uint8_t newCfgValset8(uint32_t keyID, uint8_t value, uint8_t layer = VAL_LAYER_BBR);								 //Define a new UBX-CFG-VALSET with the given KeyID and 8-bit value
-	uint8_t newCfgValset16(uint32_t keyID, uint16_t value, uint8_t layer = VAL_LAYER_BBR);								 //Define a new UBX-CFG-VALSET with the given KeyID and 16-bit value
-	uint8_t newCfgValset32(uint32_t keyID, uint32_t value, uint8_t layer = VAL_LAYER_BBR);								 //Define a new UBX-CFG-VALSET with the given KeyID and 32-bit value
+	uint8_t newCfgValset8(uint32_t keyID, uint8_t value, uint8_t layer = VAL_LAYER_ALL);								 //Define a new UBX-CFG-VALSET with the given KeyID and 8-bit value
+	uint8_t newCfgValset16(uint32_t keyID, uint16_t value, uint8_t layer = VAL_LAYER_ALL);								 //Define a new UBX-CFG-VALSET with the given KeyID and 16-bit value
+	uint8_t newCfgValset32(uint32_t keyID, uint32_t value, uint8_t layer = VAL_LAYER_ALL);								 //Define a new UBX-CFG-VALSET with the given KeyID and 32-bit value
 	uint8_t addCfgValset8(uint32_t keyID, uint8_t value);																 //Add a new KeyID and 8-bit value to an existing UBX-CFG-VALSET ubxPacket
 	uint8_t addCfgValset16(uint32_t keyID, uint16_t value);																 //Add a new KeyID and 16-bit value to an existing UBX-CFG-VALSET ubxPacket
 	uint8_t addCfgValset32(uint32_t keyID, uint32_t value);																 //Add a new KeyID and 32-bit value to an existing UBX-CFG-VALSET ubxPacket
@@ -601,7 +610,28 @@ class SFE_UBLOX_GPS
 
 	boolean getRELPOSNED(uint16_t maxWait = 1100); //Get Relative Positioning Information of the NED frame
 
+	// Enable debug messages using the chosen Serial port (Stream)
+	// Boards like the RedBoard Turbo use SerialUSB (not Serial).
+	// But other boards like the SAMD51 Thing Plus use Serial (not SerialUSB).
+	// These lines let the code compile cleanly on as many SAMD boards as possible.
+	#if defined(ARDUINO_ARCH_SAMD)	// Is this a SAMD board?
+	#if defined(USB_VID)						// Is the USB Vendor ID defined?
+	#if (USB_VID == 0x1B4F)					// Is this a SparkFun board?
+	#if !defined(ARDUINO_SAMD51_THING_PLUS) & !defined(ARDUINO_SAMD51_MICROMOD) // If it is not a SAMD51 Thing Plus or SAMD51 MicroMod
+	void enableDebugging(Stream &debugPort = SerialUSB, boolean printLimitedDebug = false); //Given a port to print to, enable debug messages. Default to all, not limited.
+	#else
+	void enableDebugging(Stream &debugPort = Serial, boolean printLimitedDebug = false); //Given a port to print to, enable debug messages. Default to all, not limited.
+	#endif
+	#else
+	void enableDebugging(Stream &debugPort = Serial, boolean printLimitedDebug = false); //Given a port to print to, enable debug messages. Default to all, not limited.
+	#endif
+	#else
 	void enableDebugging(Stream &debugPort = Serial, boolean printLimitedDebug = false); //Given a port to print to, enable debug messages. Default to all, not limited.
+	#endif
+	#else
+	void enableDebugging(Stream &debugPort = Serial, boolean printLimitedDebug = false); //Given a port to print to, enable debug messages. Default to all, not limited.
+	#endif
+
 	void disableDebugging(void);														 //Turn off debug statements
 	void debugPrint(char *message);														 //Safely print debug statements
 	void debugPrintln(char *message);													 //Safely print debug statements
@@ -636,6 +666,10 @@ class SFE_UBLOX_GPS
 	bool setStaticPosition(int32_t ecefXOrLat, int8_t ecefXOrLatHP, int32_t ecefYOrLon, int8_t ecefYOrLonHP, int32_t ecefZOrAlt, int8_t ecefZOrAltHP, bool latLong = false, uint16_t maxWait = 250);
 	bool setStaticPosition(int32_t ecefXOrLat, int32_t ecefYOrLon, int32_t ecefZOrAlt, bool latLong = false, uint16_t maxWait = 250);
 
+	// Push (e.g.) RTCM data directly to the module
+	// Warning: this function does not check that the data is valid. It is the user's responsibility to ensure the data is valid before pushing.
+	boolean pushRawData(uint8_t *dataBytes, size_t numDataBytes);
+
 	//Survey-in specific controls
 	struct svinStructure
 	{
@@ -687,10 +721,18 @@ class SFE_UBLOX_GPS
 	bool gpsDateValid;
 	bool gpsTimeValid;
 
+
+	bool gnssFixOk;      //valid fix (i.e within DOP & accuracy masks)
+	bool diffSoln;       //Differential corrections were applied
 	int32_t latitude;		 //Degrees * 10^-7 (more accurate than floats)
 	int32_t longitude;		 //Degrees * 10^-7 (more accurate than floats)
 	int32_t altitude;		 //Number of mm above ellipsoid
 	int32_t altitudeMSL;	 //Number of mm above Mean Sea Level
+	uint32_t horizontalAccEst;
+	uint32_t verticalAccEst;
+	int32_t nedNorthVel;
+	int32_t nedEastVel;
+	int32_t nedDownVel;
 	uint8_t SIV;			 //Number of satellites used in position solution
 	uint8_t fixType;		 //Tells us when we have a solution aka lock
 	uint8_t carrierSolution; //Tells us when we have an RTK float/fixed solution
@@ -715,6 +757,14 @@ class SFE_UBLOX_GPS
 
 	uint16_t rtcmFrameCounter = 0; //Tracks the type of incoming byte inside RTCM frame
 
+uint16_t geometricDOP; // Geometric dilution of precision * 10^-2
+uint16_t positionDOP; // Posoition dilution of precision * 10^-2
+uint16_t timeDOP; // Time dilution of precision * 10^-2
+uint16_t verticalDOP; // Vertical dilution of precision * 10^-2
+uint16_t horizontalDOP; // Horizontal dilution of precision * 10^-2
+uint16_t northingDOP; // Northing dilution of precision * 10^-2
+uint16_t eastingDOP; // Easting dilution of precision * 10^-2
+
 #define DEF_NUM_SENS 7
 	struct deadReckData
 	{
@@ -804,6 +854,7 @@ class SFE_UBLOX_GPS
 	//Functions
 	boolean checkUbloxInternal(ubxPacket *incomingUBX, uint8_t requestedClass = 255, uint8_t requestedID = 255); //Checks module with user selected commType
 	uint32_t extractLong(uint8_t spotToStart);																	 //Combine four bytes from payload into long
+	int32_t extractSignedLong(uint8_t spotToStart);																//Combine four bytes from payload into signed long (avoiding any ambiguity caused by casting)
 	uint16_t extractInt(uint8_t spotToStart);																	 //Combine two bytes from payload into int
 	uint8_t extractByte(uint8_t spotToStart);																	 //Get byte from payload
 	int8_t extractSignedChar(uint8_t spotToStart);																 //Get signed 8-bit value from payload
@@ -850,6 +901,9 @@ class SFE_UBLOX_GPS
 	boolean autoPVTImplicitUpdate = true; // Whether autoPVT is triggered by accessing stale data (=true) or by a call to checkUblox (=false)
 	boolean autoHPPOSLLH = false;			  //Whether autoHPPOSLLH is enabled or not
 	boolean autoHPPOSLLHImplicitUpdate = true; // Whether autoHPPOSLLH is triggered by accessing stale data (=true) or by a call to checkUblox (=false)
+  boolean autoDOP = false;       //Whether autoDOP is enabled or not
+  boolean autoDOPImplicitUpdate = true; // Whether autoDOP is triggered by accessing stale data (=true) or by a call to checkUblox (=false)
+
 	uint16_t ubxFrameCounter;			  //It counts all UBX frame. [Fixed header(2bytes), CLS(1byte), ID(1byte), length(2bytes), payload(x bytes), checksums(2bytes)]
 
 	uint8_t rollingChecksumA; //Rolls forward as we receive incoming bytes. Checked against the last two A/B checksum bytes
@@ -873,10 +927,19 @@ class SFE_UBLOX_GPS
 		uint32_t gpsNanosecond : 1;
 
 		uint32_t all : 1;
+		uint32_t gnssFixOk : 1;
+		uint32_t diffSoln : 1;
 		uint32_t longitude : 1;
 		uint32_t latitude : 1;
 		uint32_t altitude : 1;
 		uint32_t altitudeMSL : 1;
+
+		uint32_t horizontalAccEst : 1;
+		uint32_t verticalAccEst : 1;
+		uint32_t nedNorthVel : 1;
+		uint32_t nedEastVel : 1;
+		uint32_t nedDownVel : 1;
+
 		uint32_t SIV : 1;
 		uint32_t fixType : 1;
 		uint32_t carrierSolution : 1;
@@ -903,6 +966,18 @@ class SFE_UBLOX_GPS
 		uint16_t highResLongitudeHp : 1;
 	} highResModuleQueried;
 
+  struct
+  {
+    uint16_t all : 1;
+    uint16_t geometricDOP : 1;
+    uint16_t positionDOP : 1;
+    uint16_t timeDOP : 1;
+    uint16_t verticalDOP : 1;
+    uint16_t horizontalDOP : 1;
+    uint16_t northingDOP : 1;
+    uint16_t eastingDOP : 1;
+  } dopModuleQueried;
+
 	uint16_t rtcmLen = 0;
 };