Add support for auto-reporting of navigation solutions using UBX_NAV_PVT

Author: tve

examples/Example13_AutoPVT/Example13_AutoPVT.ino

@@ -0,0 +1,84 @@
+/*
+  Configuring the GPS to automatically send position reports over I2C
+  By: Nathan Seidle
+  SparkFun Electronics
+  Date: January 3rd, 2019
+  License: MIT. See license file for more information but you can
+  basically do whatever you want with this code.
+
+  This example shows how to configure the U-Blox GPS the send navigation reports automatically
+  and retrieving the latest one via getPVT. This eliminates the blocking in getPVT while the GPS
+  produces a fresh navigation solution at the expense of returning a slighly old solution.
+
+  This can be used over serial or over I2C, this example shows the I2C use. With serial the GPS
+  simply outputs the UBX_NAV_PVT packet. With I2C it queues it into its internal I2C buffer (4KB in
+  size?) where it can be retrieved in the next I2C poll.
+
+  Feel like supporting open source hardware?
+  Buy a board from SparkFun!
+  ZED-F9P RTK2: https://www.sparkfun.com/products/15136
+  NEO-M8P RTK: https://www.sparkfun.com/products/15005
+  SAM-M8Q: https://www.sparkfun.com/products/15106
+
+  Hardware Connections:
+  Plug a Qwiic cable into the GPS and a BlackBoard
+  If you don't have a platform with a Qwiic connection use the SparkFun Qwiic Breadboard Jumper (https://www.sparkfun.com/products/14425)
+  Open the serial monitor at 115200 baud to see the output
+*/
+
+#include <Particle.h>
+#include <Wire.h> //Needed for I2C to GPS
+
+#include <SparkFun_Ublox_Arduino_Library.h> //http://librarymanager/All#SparkFun_Ublox_GPS
+SFE_UBLOX_GPS myGPS;
+
+void setup()
+{
+  Serial.begin(115200);
+  while (!Serial); //Wait for user to open terminal
+  Serial.println("SparkFun Ublox Example");
+
+  Wire.begin();
+
+  if (myGPS.begin() == false) //Connect to the Ublox module using Wire port
+  {
+    Serial.println(F("Ublox GPS not detected at default I2C address. Please check wiring. Freezing."));
+    while (1);
+  }
+
+  myGPS.setI2COutput(COM_TYPE_UBX); //Set the I2C port to output UBX only (turn off NMEA noise)
+  myGPS.setNavigationFrequency(2); //Produce two solutions per second
+  myGPS.setAutoPVT(true); //Tell the GPS to "send" each solution
+  myGPS.saveConfiguration(); //Save the current settings to flash and BBR
+}
+
+void loop()
+{
+    // Calling getPVT returns true if there actually is a fresh navigation solution available.
+    if (myGPS.getPVT())
+    {
+        Serial.println();
+        long latitude = myGPS.getLatitude();
+        Serial.print(F("Lat: "));
+        Serial.print(latitude);
+
+        long longitude = myGPS.getLongitude();
+        Serial.print(F(" Long: "));
+        Serial.print(longitude);
+        Serial.print(F(" (degrees * 10^-7)"));
+
+        long altitude = myGPS.getAltitude();
+        Serial.print(F(" Alt: "));
+        Serial.print(altitude);
+        Serial.print(F(" (mm)"));
+
+        byte SIV = myGPS.getSIV();
+        Serial.print(F(" SIV: "));
+        Serial.print(SIV);
+
+        Serial.println();
+    } else {
+        Serial.print(".");
+        delay(50);
+    }
+}

src/SparkFun_Ublox_Arduino_Library.cpp

@@ -188,6 +188,7 @@ boolean SFE_UBLOX_GPS::checkUbloxI2C()
 	  debug.println("No bytes available");
 #endif
       lastCheck = millis(); //Put off checking to avoid I2C bus traffic
+      return true;
 	}
 
     while (bytesAvailable)
@@ -455,27 +456,50 @@ void SFE_UBLOX_GPS::processUBX(uint8_t incoming, ubxPacket *incomingUBX)
 //Once a packet has been received and validated, identify this packet's class/id and update internal flags
 void SFE_UBLOX_GPS::processUBXpacket(ubxPacket *msg)
 {
-  if (msg->cls == UBX_CLASS_ACK)
-  {
-    //We don't want to store ACK packets, just set commandAck flag
-    if (msg->id == UBX_ACK_ACK)
-    {
-      if (msg->payload[0] == packetCfg.cls && msg->payload[1] == packetCfg.id)
-      {
-        //The ack we just received matched the CLS/ID of last packetCfg sent
+    switch (msg->cls) {
+    case UBX_CLASS_ACK:
+        //We don't want to store ACK packets, just set commandAck flag
+        if (msg->id == UBX_ACK_ACK && msg->payload[0] == packetCfg.cls && msg->payload[1] == packetCfg.id)
+        {
+            //The ack we just received matched the CLS/ID of last packetCfg sent
 #ifdef DEBUG
-        debug.println("Command sent/ack'd successfully");
+            debug.println("Command sent/ack'd successfully");
 #endif
+            commandAck = true;
+        }
+        break;
 
-        commandAck = true;
-      }
+    case UBX_CLASS_NAV:
+        Serial.println("**************************************************");
+        if (msg->id == UBX_NAV_PVT && msg->len == 92)
+        {
+            //Parse various byte fields into global vars
+            fixType = extractByte(20 - packetCfg.startingSpot);
+            carrierSolution = extractByte(21 - packetCfg.startingSpot) >> 6; //Get 6th&7th bits of this byte
+            SIV = extractByte(23 - packetCfg.startingSpot);
+            longitude = extractLong(24 - packetCfg.startingSpot);
+            latitude = extractLong(28 - packetCfg.startingSpot);
+            altitude = extractLong(32 - packetCfg.startingSpot);
+            altitudeMSL = extractLong(36 - packetCfg.startingSpot);
+            groundSpeed = extractLong(60 - packetCfg.startingSpot);
+            headingOfMotion = extractLong(64 - packetCfg.startingSpot);
+            pDOP = extractLong(76 - packetCfg.startingSpot);
+
+            //Mark all datums as fresh (not read before)
+            moduleQueried.all = true;
+            moduleQueried.longitude = true;
+            moduleQueried.latitude = true;
+            moduleQueried.altitude = true;
+            moduleQueried.altitudeMSL = true;
+            moduleQueried.SIV = true;
+            moduleQueried.fixType = true;
+            moduleQueried.carrierSolution = true;
+            moduleQueried.groundSpeed = true;
+            moduleQueried.headingOfMotion = true;
+            moduleQueried.pDOP = true;
+        }
+        break;
     }
-    //else
-    //{
-      //Serial.println("Command send fail");
-      //module.ackReceived = false;
-    //}
-  }
 }
 
 //Given a packet and payload, send everything including CRC bytes via I2C port
@@ -1035,6 +1059,24 @@ uint8_t SFE_UBLOX_GPS::getNavigationFrequency(uint16_t maxWait)
 	return (measurementRate);
 }
 
+//Enable or disable automatic navigation message generation by the GPS. This changes the way getPVT
+//works.
+boolean SFE_UBLOX_GPS::setAutoPVT(boolean enable, uint16_t maxWait)
+{
+    packetCfg.cls = UBX_CLASS_CFG;
+    packetCfg.id = UBX_CFG_MSG;
+    packetCfg.len = 3;
+    packetCfg.startingSpot = 0;
+    payloadCfg[0] = UBX_CLASS_NAV;
+    payloadCfg[1] = UBX_NAV_PVT;
+    payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+
+    bool ok = sendCommand(packetCfg, maxWait);
+    if (ok) autoPVT = enable;
+    moduleQueried.all = false;
+    return ok;
+}
+
 //Given a spot in the payload array, extract four bytes and build a long
 uint32_t SFE_UBLOX_GPS::extractLong(uint8_t spotToStart)
 {
@@ -1064,42 +1106,22 @@ uint8_t SFE_UBLOX_GPS::extractByte(uint8_t spotToStart)
 //Get the latest Position/Velocity/Time solution and fill all global variables
 boolean SFE_UBLOX_GPS::getPVT(uint16_t maxWait)
 {
-	//Query the module for the latest lat/long
-	packetCfg.cls = UBX_CLASS_NAV;
-	packetCfg.id = UBX_NAV_PVT;
-	packetCfg.len = 0;
-	packetCfg.startingSpot = 20; //Begin listening at spot 20 so we can record up to 20+MAX_PAYLOAD_SIZE = 84 bytes
-
-	if(sendCommand(packetCfg, maxWait) == false)
-		return(false); //If command send fails then bail
+    if (autoPVT) {
+        //The GPS is automatically reporting, we just check whether we got unread data
+        checkUblox();
+        return moduleQueried.all;
+    } else {
+        //The GPS is not automatically reporting navigation position so we have to poll explicitly
+        packetCfg.cls = UBX_CLASS_NAV;
+        packetCfg.id = UBX_NAV_PVT;
+        packetCfg.len = 0;
+        packetCfg.startingSpot = 20; //Begin listening at spot 20 so we can record up to 20+MAX_PAYLOAD_SIZE = 84 bytes
 
-	//Parse various byte fields into global vars
-	fixType = extractByte(20 - packetCfg.startingSpot);
-	carrierSolution = extractByte(21 - packetCfg.startingSpot) >> 6; //Get 6th&7th bits of this byte
-	SIV = extractByte(23 - packetCfg.startingSpot);
-	longitude = extractLong(24 - packetCfg.startingSpot);
-	latitude = extractLong(28 - packetCfg.startingSpot);
-	altitude = extractLong(32 - packetCfg.startingSpot);
-	altitudeMSL = extractLong(36 - packetCfg.startingSpot);
-	groundSpeed = extractLong(60 - packetCfg.startingSpot);
-	headingOfMotion = extractLong(64 - packetCfg.startingSpot);
-	pDOP = extractLong(76 - packetCfg.startingSpot);
-
-	//Mark all datums as fresh (not read before)
-	//moduleQueried ThisStruct;
-	//memset(&ThisStruct, 0, sizeof(moduleQueried));
-	moduleQueried.longitude = true;
-	moduleQueried.latitude = true;
-	moduleQueried.altitude = true;
-	moduleQueried.altitudeMSL = true;
-	moduleQueried.SIV = true;
-	moduleQueried.fixType = true;
-	moduleQueried.carrierSolution = true;
-	moduleQueried.groundSpeed = true;
-	moduleQueried.headingOfMotion = true;
-	moduleQueried.pDOP = true;
+        //The data is parsed as part of processing the response
+        return sendCommand(packetCfg, maxWait);
+            return(false); //If command send fails then bail
+    }
 
-	return(true);
 }
 
 //Get the current 3D high precision positional accuracy - a fun thing to watch
@@ -1137,6 +1159,7 @@ int32_t SFE_UBLOX_GPS::getLongitude(uint16_t maxWait)
 {
 	if(moduleQueried.longitude == false) getPVT();
 	moduleQueried.longitude = false; //Since we are about to give this to user, mark this data as stale
+        moduleQueried.all = false;
 
 	return(longitude);
 }
@@ -1146,6 +1169,7 @@ int32_t SFE_UBLOX_GPS::getAltitude(uint16_t maxWait)
 {
 	if(moduleQueried.altitude == false) getPVT();
 	moduleQueried.altitude = false; //Since we are about to give this to user, mark this data as stale
+        moduleQueried.all = false;
 
 	return(altitude);
 }
@@ -1157,6 +1181,7 @@ int32_t SFE_UBLOX_GPS::getAltitudeMSL(uint16_t maxWait)
 {
 	if(moduleQueried.altitudeMSL == false) getPVT();
 	moduleQueried.altitudeMSL = false; //Since we are about to give this to user, mark this data as stale
+        moduleQueried.all = false;
 
 	return(altitudeMSL);
 }
@@ -1166,6 +1191,7 @@ uint8_t SFE_UBLOX_GPS::getSIV(uint16_t maxWait)
 {
 	if(moduleQueried.SIV == false) getPVT();
 	moduleQueried.SIV = false; //Since we are about to give this to user, mark this data as stale
+        moduleQueried.all = false;
 
 	return(SIV);
 }
@@ -1176,6 +1202,7 @@ uint8_t SFE_UBLOX_GPS::getFixType(uint16_t maxWait)
 {
 	if(moduleQueried.fixType == false) getPVT();
 	moduleQueried.fixType = false; //Since we are about to give this to user, mark this data as stale
+        moduleQueried.all = false;
 
 	return(fixType);
 }
@@ -1187,6 +1214,7 @@ uint8_t SFE_UBLOX_GPS::getCarrierSolutionType(uint16_t maxWait)
 {
 	if(moduleQueried.carrierSolution == false) getPVT();
 	moduleQueried.carrierSolution = false; //Since we are about to give this to user, mark this data as stale
+        moduleQueried.all = false;
 
 	return(carrierSolution);
 }
@@ -1196,6 +1224,7 @@ int32_t SFE_UBLOX_GPS::getGroundSpeed(uint16_t maxWait)
 {
 	if(moduleQueried.groundSpeed == false) getPVT();
 	moduleQueried.groundSpeed = false; //Since we are about to give this to user, mark this data as stale
+        moduleQueried.all = false;
 
 	return(groundSpeed);
 }
@@ -1205,6 +1234,7 @@ int32_t SFE_UBLOX_GPS::getHeading(uint16_t maxWait)
 {
 	if(moduleQueried.headingOfMotion == false) getPVT();
 	moduleQueried.headingOfMotion = false; //Since we are about to give this to user, mark this data as stale
+        moduleQueried.all = false;
 
 	return(headingOfMotion);
 }
@@ -1214,6 +1244,7 @@ uint16_t SFE_UBLOX_GPS::getPDOP(uint16_t maxWait)
 {
 	if(moduleQueried.pDOP == false) getPVT();
 	moduleQueried.pDOP = false; //Since we are about to give this to user, mark this data as stale
+        moduleQueried.all = false;
 
 	return(pDOP);
 }

src/SparkFun_Ublox_Arduino_Library.h

@@ -110,6 +110,7 @@ const uint8_t UBX_NAV_HPPOSLLH = 0x14; //Used for obtaining lat/long/alt in high
 const uint8_t UBX_NAV_SVIN = 0x3B; //Used for checking Survey In status
 
 const uint8_t UBX_MON_VER = 0x04; //Used for obtaining Protocol Version
+const uint8_t UBX_MON_TXBUF = 0x08; //Used for query tx buffer size/state
 
 //The following are used to enable RTCM messages
 const uint8_t UBX_CFG_MSG = 0x01;
@@ -200,7 +201,7 @@ class SFE_UBLOX_GPS
 	void processNMEA(char incoming) __attribute__((weak)); //Given a NMEA character, do something with it. User can overwrite if desired to use something like tinyGPS or MicroNMEA libraries
 
 	void calcChecksum(ubxPacket *msg); //Sets the checksumA and checksumB of a given messages
-	boolean sendCommand(ubxPacket outgoingUBX, uint16_t maxWait = 250); //Given a packet and payload, send everything including CRC bytes
+	boolean sendCommand(ubxPacket outgoingUBX, uint16_t maxWait = 250); //Given a packet and payload, send everything including CRC bytes, return true if we got a response
 	boolean sendI2cCommand(ubxPacket outgoingUBX, uint16_t maxWait = 250);
 	void sendSerialCommand(ubxPacket outgoingUBX);
 
@@ -220,7 +221,9 @@ class SFE_UBLOX_GPS
 
 	boolean waitForResponse(uint8_t requestedClass, uint8_t requestedID, uint16_t maxTime = 250); //Poll the module until and ack is received
 
-	boolean getPVT(uint16_t maxWait = 1000); //Query module for latest group of datums and load global vars: lat, long, alt, speed, SIV, accuracies, etc.
+        boolean setAutoPVT(boolean enabled, uint16_t maxWait = 250); //Enable/disable automatic PVT reports at the navigation frequency
+	boolean getPVT(uint16_t maxWait = 1000); //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. Retruns true if new PVT is available.
+
 	int32_t getLatitude(uint16_t maxWait = 250); //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 = 250); //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 = 250); //Returns the current altitude in mm above ellipsoid
@@ -336,6 +339,7 @@ class SFE_UBLOX_GPS
 
 	const uint8_t I2C_POLLING_WAIT_MS = 25; //Limit checking of new characters to every X ms
 	unsigned long lastCheck = 0;
+        boolean autoPVT = false; //Whether autoPVT is enabled or not
 	boolean commandAck = false; //This goes true after we send a command and it's ack'd
 	uint8_t ubxFrameCounter;
 
@@ -347,6 +351,7 @@ class SFE_UBLOX_GPS
 	//This reduces the number of times we have to call getPVT as this can take up to ~1s per read
 	//depending on update rate
 	struct {
+	   uint16_t all : 1;
 	   uint16_t longitude : 1;
 	   uint16_t latitude : 1;
 	   uint16_t altitude : 1;