Adding configuration save and factory reset functions.

Author: nseidle

examples/Example10_ResetConfiguration/Example10_ResetConfiguration.ino

@@ -0,0 +1,59 @@
+/*
+  Reading lat and long via UBX binary commands - no more NMEA parsing!
+  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 reset a module to its factory defaults. This includes
+  changing all the ports back to UBX+NMEA input/output and nav updates back to 1Hz.
+
+  Helpful if you just need to get back to a sane state.
+
+  Note: Long/lat are large numbers because they are * 10^7. To convert lat/long
+  to something google maps understands simply divide the numbers by 10,000,000. We 
+  do this so that we don't have to use floating point numbers.
+
+  Leave NMEA parsing behind. Now you can simply ask the module for the datums you want!
+
+  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 <Wire.h> //Needed for I2C to GPS
+
+#include "SparkFun_Ublox_Arduino_Library.h" //http://librarymanager/All#SparkFun_Ublox_GPS
+SFE_UBLOX_GPS myGPS;
+
+long lastTime = 0; //Simple local timer. Limits amount if I2C traffic to Ublox module.
+
+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.factoryDefault(); //Return module to default settings (1Hz update, NMEA+UBX on all ports, etc)
+}
+
+void loop()
+{
+
+}

src/SparkFun_Ublox_Arduino_Library.cpp

@@ -113,7 +113,10 @@ boolean SFE_UBLOX_GPS::checkUbloxI2C()
     }
 
     if (bytesAvailable == 0)
+	{
+		Serial.println("No bytes available");
       lastCheck = millis(); //Put off checking to avoid I2C bus traffic
+	}
 
     while (bytesAvailable)
     {
@@ -221,9 +224,9 @@ void SFE_UBLOX_GPS::process(uint8_t incoming)
 
     //Depending on this frame's class, pass different structs and payload arrays
     if (ubxFrameClass == CLASS_ACK)
-		processUBX(incoming, &packetAck);
+	  processUBX(incoming, &packetAck);
     else if (ubxFrameClass == CLASS_NOT_AN_ACK)
-      processUBX(incoming, &packetCfg);
+	  processUBX(incoming, &packetCfg);
   }
   else if (currentSentence == NMEA)
   {
@@ -311,7 +314,7 @@ void SFE_UBLOX_GPS::processRTCM(uint8_t incoming)
 //Set valid = true once sentence is completely received and passes CRC
 //The payload portion of the packet can be 100s of bytes but the max array
 //size is roughly 64 bytes. startingSpot can be set so we only record
-//interim bytes. 
+//a subset of bytes within a larger packet. 
 void SFE_UBLOX_GPS::processUBX(uint8_t incoming, ubxPacket *incomingUBX)
 {
 	//Add all incoming bytes to the rolling checksum
@@ -470,7 +473,8 @@ boolean SFE_UBLOX_GPS::sendCommand(ubxPacket outgoingUBX, uint16_t maxWait)
 
   if (maxWait > 0)
   {
-    if (waitForResponse(maxWait) == false) //Wait for Ack response
+	//Give waitForResponse the cls/id to check for
+    if (waitForResponse(outgoingUBX.cls, outgoingUBX.id, maxWait) == false) //Wait for Ack response
       return (false);
   }
   return (true);
@@ -549,18 +553,37 @@ void SFE_UBLOX_GPS::printPacket(ubxPacket *packet)
 
 
 //Poll the module until and ack is received
-boolean SFE_UBLOX_GPS::waitForResponse(uint16_t maxTime)
+boolean SFE_UBLOX_GPS::waitForResponse(uint8_t requestedClass, uint8_t requestedID, uint16_t maxTime)
 {
   commandAck = false; //Reset flag
   packetCfg.valid = false; //This will go true when we receive a response to the packet we sent
 
-  long startTime = millis();
+  unsigned long startTime = millis();
   while (millis() - startTime < maxTime)
   {
     checkUblox(); //See if new data is available. Process bytes as they come in.
 
     if (commandAck == true) return (true); //If the packet we just sent was a CFG packet then we'll get an ACK
-    if (packetCfg.valid == true) return (true); //If the packet we just sent was a NAV packet then we'll just get data back
+    if (packetCfg.valid == true)
+	{
+		//Did we receive a config packet that matches the cls/id we requested?
+		if(packetCfg.cls == requestedClass && packetCfg.id == requestedID)
+		{
+#ifdef DEBUG
+			debug.println(F("CLS/ID match!"));
+#endif
+			return (true); //If the packet we just sent was a NAV packet then we'll just get data back
+		}
+#ifdef DEBUG
+		else
+		{
+			debug.print(F("Packet didn't match CLS/ID"));
+			printPacket(&packetCfg);
+		}
+#endif
+	}
+
+	delay(1);
   }
 
 #ifdef DEBUG
@@ -570,6 +593,49 @@ boolean SFE_UBLOX_GPS::waitForResponse(uint16_t maxTime)
 	return (false);
 }
 
+//Save current configuration to flash and BBR (battery backed RAM)
+//This still works but it is the old way of configuring ublox modules. See getVal and setVal for the new methods
+boolean SFE_UBLOX_GPS::saveConfiguration(uint16_t maxWait)
+{
+	packetCfg.cls = UBX_CLASS_CFG;
+	packetCfg.id = UBX_CFG_CFG;
+	packetCfg.len = 12;
+	packetCfg.startingSpot = 0;
+  
+	//Clear packet payload
+	for(uint8_t x = 0 ; x < packetCfg.len ; x++)
+		packetCfg.payload[x] = 0;
+	
+	packetCfg.payload[4] = 0xFF; //Set any bit in the saveMask field to save current config to Flash and BBR
+
+	if(sendCommand(packetCfg, maxWait) == false)
+		return(false); //If command send fails then bail
+	
+	return(true);
+}
+
+//Reset module to factory defaults
+//This still works but it is the old way of configuring ublox modules. See getVal and setVal for the new methods
+boolean SFE_UBLOX_GPS::factoryDefault(uint16_t maxWait)
+{
+	packetCfg.cls = UBX_CLASS_CFG;
+	packetCfg.id = UBX_CFG_CFG;
+	packetCfg.len = 12;
+	packetCfg.startingSpot = 0;
+  
+	//Clear packet payload
+	for(uint8_t x = 0 ; x < packetCfg.len ; x++)
+		packetCfg.payload[x] = 0;
+	
+	packetCfg.payload[0] = 0xFF; //Set any bit in the clearMask field to clear saved config
+	packetCfg.payload[8] = 0xFF; //Set any bit in the loadMask field to discard current config and rebuild from lower non-volatile memory layers
+
+	if(sendCommand(packetCfg, maxWait) == false)
+		return(false); //If command send fails then bail
+	
+	return(true);
+}
+
 //Given a key, return its value
 //This is how the new Ublox modules are communicating, ie protocol v27 and above found on ZED-F9P
 uint8_t SFE_UBLOX_GPS::getVal(uint16_t group, uint16_t id, uint8_t size, uint8_t layer, uint16_t maxWait)

src/SparkFun_Ublox_Arduino_Library.h

@@ -94,6 +94,7 @@ const uint8_t UBX_CLASS_HNR = 0x28;
 
 const uint8_t UBX_CFG_PRT = 0x00; //Used to configure port specifics
 const uint8_t UBX_CFG_RATE = 0x08; //Used to set port baud rates
+const uint8_t UBX_CFG_CFG = 0x09; //Used to save current configuration
 const uint8_t UBX_CFG_VALSET = 0x8A; //Used for config of higher version Ublox modules (ie protocol v27 and above)
 const uint8_t UBX_CFG_VALGET = 0x8B; //Used for config of higher version Ublox modules (ie protocol v27 and above)
 const uint8_t UBX_CFG_VALDEL = 0x8C; //Used for config of higher version Ublox modules (ie protocol v27 and above)
@@ -189,7 +190,7 @@ class SFE_UBLOX_GPS
 	void processRTCM(uint8_t incoming) __attribute__((weak)); //Given rtcm byte, do something with it. User can overwrite if desired to pipe bytes to radio, internet, etc.
 
 	void processUBXpacket(ubxPacket *msg); //Once a packet has been received and validated, identify this packet's class/id and update internal flags
-	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 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
@@ -201,8 +202,10 @@ class SFE_UBLOX_GPS
 
 	boolean setNavigationFrequency(uint8_t navFreq, uint16_t maxWait = 250); //Set the number of nav solutions sent per second
 	uint8_t getNavigationFrequency(uint16_t maxWait = 250); //Get the number of nav solutions sent per second currently being output by module
+	boolean saveConfiguration(uint16_t maxWait = 250); //Save current configuration to flash and BBR (battery backed RAM)
+	boolean factoryDefault(uint16_t maxWait = 250); //Reset module to factory defaults
 
-	boolean waitForResponse(uint16_t maxTime = 250); //Poll the module until and ack is received
+	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. 
 	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.