Merge pull request #111 from sparkfun/release_candidate

v2.2.1

Adding_New_Messages.md

@@ -129,21 +129,23 @@ See [this commit](https://github.com/sparkfun/SparkFun_u-blox_GNSS_Arduino_Libra
 
 See [this commit](https://github.com/sparkfun/SparkFun_u-blox_GNSS_Arduino_Library/commit/b746d8e2742961ede95e2d06d5db3a3a557e571d) for the changes.
 
-#### Step 6.3: Update processUBXpacket()
+#### Step 6.3: Update getMaxPayloadSize()
+
+#### Step 6.4: Update processUBXpacket()
 
 Take time to double-check that you have used the correct data width, signed/unsigned and position for each field.
 
 See [this commit](https://github.com/sparkfun/SparkFun_u-blox_GNSS_Arduino_Library/commit/8eecdd5044f810b0e2b567150ff63a17c219fe8e) for the changes.
 
-#### Step 6.4: Update checkCallbacks()
+#### Step 6.5: Update checkCallbacks()
 
 See [this commit](https://github.com/sparkfun/SparkFun_u-blox_GNSS_Arduino_Library/commit/b53bffaa3ae12482cfb268f23796963d0b8519c9) for the changes.
 
-#### Step 6.5: Add the "auto" functions
+#### Step 6.6: Add the "auto" functions
 
 See [this commit](https://github.com/sparkfun/SparkFun_u-blox_GNSS_Arduino_Library/commit/e394ae003ad38117d150598774d0552059416473) for the changes.
 
-#### Step 6.6: Add the helper functions (if any)
+#### Step 6.7: Add the helper functions (if any)
 
 See [this commit](https://github.com/sparkfun/SparkFun_u-blox_GNSS_Arduino_Library/commit/318e76383e96d6676bbb57294c25e665c0d4a31f) for the changes.
 

README.md

@@ -21,9 +21,13 @@ u-blox makes some incredible GNSS receivers covering everything from low-cost, h
 
 This library can be installed via the Arduino Library manager. Search for **SparkFun u-blox GNSS**.
 
-## Automatic support for correction services like RTK2go, Emlid Caster and Skylark (Swift Navigation)
+## Automatic support for correction services like PointPerfect (u-blox), RTK2go, Emlid Caster and Skylark (Swift Navigation)
 
-RTK NTRIP corrections services often require you to send them your location in NMEA GPGGA format. v2.2 of the library makes this easy by providing get functions and automatic callbacks
+u-blox's PointPerfect GNSS augmentation service uses the secure MQTT protocol to download SPARTN format correction data, providing "3-6 cm accuracy and convergence within seconds". Please see the new [PointPerfect Client example](https://github.com/sparkfun/SparkFun_u-blox_GNSS_Arduino_Library/tree/main/examples/ZED-F9P/Example18_PointPerfectClient) for more details.
+
+v2.3 also supports L-band correction services using the new u-blox NEO-D9S correction data receiver. Please see the new [L-band Corrections example](https://github.com/sparkfun/SparkFun_u-blox_GNSS_Arduino_Library/tree/main/examples/ZED-F9P/Example19_LBand_Corrections_with_NEO-D9S) for more details.
+
+Other RTK NTRIP corrections services often require you to send them your location in NMEA GPGGA format. v2.2 of the library makes this easy by providing get functions and automatic callbacks
 for both GPGGA and GNGGA messages. You can now instruct your module to output GPGGA (e.g.) every 10 seconds and then push it to the correction server directly from the callback. No more polling, no more parsing!
 
 v2.2 also includes two new functions useful for correction services:

examples/AssistNow/AssistNow_Autonomous/Example1_AssistNowAutonomous/Example1_AssistNowAutonomous.ino

@@ -42,22 +42,22 @@ SFE_UBLOX_GNSS myGNSS;
 //        |                 /               _____ You can use any name you like for the struct
 //        |                 |              /
 //        |                 |              |
-void printSATdata(UBX_NAV_SAT_data_t ubxDataStruct)
+void printSATdata(UBX_NAV_SAT_data_t *ubxDataStruct)
 {
   //Serial.println();
   
   Serial.print(F("UBX-NAV-SAT contains data for "));
-  Serial.print(ubxDataStruct.header.numSvs);
+  Serial.print(ubxDataStruct->header.numSvs);
-  if (ubxDataStruct.header.numSvs == 1)
+  if (ubxDataStruct->header.numSvs == 1)
     Serial.println(F(" SV"));
   else
     Serial.println(F(" SVs"));
 
   uint16_t numAopAvail = 0; // Count how many SVs have AssistNow Autonomous data available
     
-  for (uint16_t block = 0; block < ubxDataStruct.header.numSvs; block++) // For each SV
+  for (uint16_t block = 0; block < ubxDataStruct->header.numSvs; block++) // For each SV
   {
-    if (ubxDataStruct.blocks[block].flags.bits.aopAvail == 1) // If the aopAvail bit is set
+    if (ubxDataStruct->blocks[block].flags.bits.aopAvail == 1) // If the aopAvail bit is set
       numAopAvail++; // Increment the number of SVs
   }
 
@@ -78,12 +78,12 @@ void printSATdata(UBX_NAV_SAT_data_t ubxDataStruct)
 //        |                 /               _____ You can use any name you like for the struct
 //        |                 |              /
 //        |                 |              |
-void printAOPstatus(UBX_NAV_AOPSTATUS_data_t ubxDataStruct)
+void printAOPstatus(UBX_NAV_AOPSTATUS_data_t *ubxDataStruct)
 {
   //Serial.println();
   
   Serial.print(F("AOPSTATUS status is "));
-  Serial.println(ubxDataStruct.status);
+  Serial.println(ubxDataStruct->status);
 }
 
 //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
@@ -95,27 +95,27 @@ void printAOPstatus(UBX_NAV_AOPSTATUS_data_t ubxDataStruct)
 //        |                 /               _____ You can use any name you like for the struct
 //        |                 |              /
 //        |                 |              |
-void printPVTdata(UBX_NAV_PVT_data_t ubxDataStruct)
+void printPVTdata(UBX_NAV_PVT_data_t *ubxDataStruct)
 {
   // Print the UBX-NAV-PVT data so we can see how quickly the fixType goes to 3D
   
   Serial.println();
 
-  long latitude = ubxDataStruct.lat; // Print the latitude
+  long latitude = ubxDataStruct->lat; // Print the latitude
   Serial.print(F("Lat: "));
   Serial.print(latitude);
 
-  long longitude = ubxDataStruct.lon; // Print the longitude
+  long longitude = ubxDataStruct->lon; // Print the longitude
   Serial.print(F(" Long: "));
   Serial.print(longitude);
   Serial.print(F(" (degrees * 10^-7)"));
 
-  long altitude = ubxDataStruct.hMSL; // Print the height above mean sea level
+  long altitude = ubxDataStruct->hMSL; // Print the height above mean sea level
   Serial.print(F(" Alt: "));
   Serial.print(altitude);
   Serial.print(F(" (mm)"));
 
-  byte fixType = ubxDataStruct.fixType; // Print the fix type
+  byte fixType = ubxDataStruct->fixType; // Print the fix type
   Serial.print(F(" Fix: "));
   if(fixType == 0) Serial.print(F("No fix"));
   else if(fixType == 1) Serial.print(F("Dead reckoning"));
@@ -171,9 +171,9 @@ void setup()
 
   myGNSS.setNavigationFrequency(1); //Produce one solution per second
 
-  myGNSS.setAutoNAVSATcallback(&printSATdata); // Enable automatic NAV SAT messages with callback to printSATdata
+  myGNSS.setAutoNAVSATcallbackPtr(&printSATdata); // Enable automatic NAV SAT messages with callback to printSATdata
-  myGNSS.setAutoAOPSTATUScallback(&printAOPstatus); // Enable automatic NAV AOPSTATUS messages with callback to printAOPstatus
+  myGNSS.setAutoAOPSTATUScallbackPtr(&printAOPstatus); // Enable automatic NAV AOPSTATUS messages with callback to printAOPstatus
-  myGNSS.setAutoPVTcallback(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata
+  myGNSS.setAutoPVTcallbackPtr(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata
 }
 
 //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

examples/AssistNow/AssistNow_Autonomous/Example2_AssistNowAutonomous_DatabaseRead/Example2_AssistNowAutonomous_DatabaseRead.ino

@@ -35,22 +35,22 @@ SFE_UBLOX_GNSS myGNSS;
 //        |                 /               _____ You can use any name you like for the struct
 //        |                 |              /
 //        |                 |              |
-void printSATdata(UBX_NAV_SAT_data_t ubxDataStruct)
+void printSATdata(UBX_NAV_SAT_data_t *ubxDataStruct)
 {
   Serial.println();
   
   Serial.print(F("UBX-NAV-SAT contains data for "));
-  Serial.print(ubxDataStruct.header.numSvs);
+  Serial.print(ubxDataStruct->header.numSvs);
-  if (ubxDataStruct.header.numSvs == 1)
+  if (ubxDataStruct->header.numSvs == 1)
     Serial.println(F(" SV"));
   else
     Serial.println(F(" SVs"));
 
   uint16_t numAopAvail = 0; // Count how many SVs have AssistNow Autonomous data available
     
-  for (uint16_t block = 0; block < ubxDataStruct.header.numSvs; block++) // For each SV
+  for (uint16_t block = 0; block < ubxDataStruct->header.numSvs; block++) // For each SV
   {
-    if (ubxDataStruct.blocks[block].flags.bits.aopAvail == 1) // If the aopAvail bit is set
+    if (ubxDataStruct->blocks[block].flags.bits.aopAvail == 1) // If the aopAvail bit is set
       numAopAvail++; // Increment the number of SVs
   }
 
@@ -71,12 +71,12 @@ void printSATdata(UBX_NAV_SAT_data_t ubxDataStruct)
 //        |                 /               _____ You can use any name you like for the struct
 //        |                 |              /
 //        |                 |              |
-void printAOPstatus(UBX_NAV_AOPSTATUS_data_t ubxDataStruct)
+void printAOPstatus(UBX_NAV_AOPSTATUS_data_t *ubxDataStruct)
 {
   //Serial.println();
   
   Serial.print(F("AOPSTATUS status is "));
-  Serial.println(ubxDataStruct.status);
+  Serial.println(ubxDataStruct->status);
 }
 
 //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
@@ -126,8 +126,8 @@ void setup()
 
   myGNSS.setNavigationFrequency(1); //Produce one solution per second
 
-  myGNSS.setAutoNAVSATcallback(&printSATdata); // Enable automatic NAV SAT messages with callback to printSATdata
+  myGNSS.setAutoNAVSATcallbackPtr(&printSATdata); // Enable automatic NAV SAT messages with callback to printSATdata
-  myGNSS.setAutoAOPSTATUScallback(&printAOPstatus); // Enable automatic NAV AOPSTATUS messages with callback to printAOPstatus
+  myGNSS.setAutoAOPSTATUScallbackPtr(&printAOPstatus); // Enable automatic NAV AOPSTATUS messages with callback to printAOPstatus
 
   //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   // Keep displaying NAV SAT and AOPSTATUS until the user presses a key

examples/Automatic_NMEA/Example2_NMEA_GGA_Callbacks/Example2_NMEA_GGA_Callbacks.ino

@@ -39,12 +39,12 @@ SFE_UBLOX_GNSS myGNSS;
 //        |              /           _____ You can use any name you like for the struct
 //        |              |          /
 //        |              |          |
-void printGPGGA(NMEA_GGA_data_t nmeaData)
+void printGPGGA(NMEA_GGA_data_t *nmeaData)
 {
     Serial.print(F("\r\nGPGGA: Length: "));
-    Serial.print(nmeaData.length);
+    Serial.print(nmeaData->length);
     Serial.print(F("\tData: "));
-    Serial.print((const char *)nmeaData.nmea); // .nmea is printable (NULL-terminated) and already has \r\n on the end
+    Serial.print((const char *)nmeaData->nmea); // .nmea is printable (NULL-terminated) and already has \r\n on the end
 }
 
 // Callback: printGNGGA will be called if new GNGGA NMEA data arrives
@@ -54,12 +54,12 @@ void printGPGGA(NMEA_GGA_data_t nmeaData)
 //        |              /           _____ You can use any name you like for the struct
 //        |              |          /
 //        |              |          |
-void printGNGGA(NMEA_GGA_data_t nmeaData)
+void printGNGGA(NMEA_GGA_data_t *nmeaData)
 {
     Serial.print(F("\r\nGNGGA: Length: "));
-    Serial.print(nmeaData.length);
+    Serial.print(nmeaData->length);
     Serial.print(F("\tData: "));
-    Serial.print((const char *)nmeaData.nmea); // .nmea is printable (NULL-terminated) and already has \r\n on the end
+    Serial.print((const char *)nmeaData->nmea); // .nmea is printable (NULL-terminated) and already has \r\n on the end
 }
 
 void setup()
@@ -101,10 +101,10 @@ void setup()
   //myGNSS.setNMEAOutputPort(Serial); // Uncomment this line to echo all NMEA data to Serial for debugging
 
   // Set up the callback for GPGGA
-  myGNSS.setNMEAGPGGAcallback(&printGPGGA);
+  myGNSS.setNMEAGPGGAcallbackPtr(&printGPGGA);
 
   // Set up the callback for GNGGA
-  myGNSS.setNMEAGNGGAcallback(&printGNGGA);
+  myGNSS.setNMEAGNGGAcallbackPtr(&printGNGGA);
 }
 
 void loop()

examples/Callbacks/CallbackExample1_NAV_PVT/CallbackExample1_NAV_PVT.ino

@@ -33,38 +33,38 @@ SFE_UBLOX_GNSS myGNSS;
 //        |                 /               _____ You can use any name you like for the struct
 //        |                 |              /
 //        |                 |              |
-void printPVTdata(UBX_NAV_PVT_data_t ubxDataStruct)
+void printPVTdata(UBX_NAV_PVT_data_t *ubxDataStruct)
 {
     Serial.println();
 
     Serial.print(F("Time: ")); // Print the time
-    uint8_t hms = ubxDataStruct.hour; // Print the hours
+    uint8_t hms = ubxDataStruct->hour; // Print the hours
     if (hms < 10) Serial.print(F("0")); // Print a leading zero if required
     Serial.print(hms);
     Serial.print(F(":"));
-    hms = ubxDataStruct.min; // Print the minutes
+    hms = ubxDataStruct->min; // Print the minutes
     if (hms < 10) Serial.print(F("0")); // Print a leading zero if required
     Serial.print(hms);
     Serial.print(F(":"));
-    hms = ubxDataStruct.sec; // Print the seconds
+    hms = ubxDataStruct->sec; // Print the seconds
     if (hms < 10) Serial.print(F("0")); // Print a leading zero if required
     Serial.print(hms);
     Serial.print(F("."));
-    unsigned long millisecs = ubxDataStruct.iTOW % 1000; // Print the milliseconds
+    unsigned long millisecs = ubxDataStruct->iTOW % 1000; // Print the milliseconds
     if (millisecs < 100) Serial.print(F("0")); // Print the trailing zeros correctly
     if (millisecs < 10) Serial.print(F("0"));
     Serial.print(millisecs);
 
-    long latitude = ubxDataStruct.lat; // Print the latitude
+    long latitude = ubxDataStruct->lat; // Print the latitude
     Serial.print(F(" Lat: "));
     Serial.print(latitude);
 
-    long longitude = ubxDataStruct.lon; // Print the longitude
+    long longitude = ubxDataStruct->lon; // Print the longitude
     Serial.print(F(" Long: "));
     Serial.print(longitude);
     Serial.print(F(" (degrees * 10^-7)"));
 
-    long altitude = ubxDataStruct.hMSL; // Print the height above mean sea level
+    long altitude = ubxDataStruct->hMSL; // Print the height above mean sea level
     Serial.print(F(" Height above MSL: "));
     Serial.print(altitude);
     Serial.println(F(" (mm)"));
@@ -91,7 +91,7 @@ void setup()
 
   myGNSS.setNavigationFrequency(2); //Produce two solutions per second
 
-  myGNSS.setAutoPVTcallback(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata
+  myGNSS.setAutoPVTcallbackPtr(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata
 }
 
 void loop()

examples/Callbacks/CallbackExample2_NAV_ODO/CallbackExample2_NAV_ODO.ino

@@ -33,22 +33,22 @@ SFE_UBLOX_GNSS myGNSS;
 //        |                 /                   _____ You can use any name you like for the struct
 //        |                 |                  /
 //        |                 |                  |
-void printODOdata(UBX_NAV_ODO_data_t ubxDataStruct)
+void printODOdata(UBX_NAV_ODO_data_t *ubxDataStruct)
 {
     Serial.println();
 
     Serial.print(F("TOW: ")); // Print the Time Of Week
-    unsigned long iTOW = ubxDataStruct.iTOW; // iTOW is in milliseconds
+    unsigned long iTOW = ubxDataStruct->iTOW; // iTOW is in milliseconds
     Serial.print(iTOW);
     Serial.print(F(" (ms)"));
 
     Serial.print(F(" Distance: "));
-    unsigned long distance = ubxDataStruct.distance; // Print the distance
+    unsigned long distance = ubxDataStruct->distance; // Print the distance
     Serial.print(distance);
     Serial.print(F(" (m)"));
 
     Serial.print(F(" Total Distance: "));
-    unsigned long totalDistance = ubxDataStruct.totalDistance; // Print the total distance
+    unsigned long totalDistance = ubxDataStruct->totalDistance; // Print the total distance
     Serial.print(totalDistance);
     Serial.println(F(" (m)"));
 }
@@ -76,7 +76,7 @@ void setup()
 
   //myGNSS.resetOdometer(); //Uncomment this line to reset the odometer
 
-  myGNSS.setAutoNAVODOcallback(&printODOdata); // Enable automatic NAV ODO messages with callback to printODOdata
+  myGNSS.setAutoNAVODOcallbackPtr(&printODOdata); // Enable automatic NAV ODO messages with callback to printODOdata
 }
 
 void loop()

examples/Callbacks/CallbackExample3_TIM_TM2/CallbackExample3_TIM_TM2.ino

@@ -48,30 +48,30 @@ int dotsPrinted = 0; // Print dots in rows of 50 while waiting for a TIM TM2 mes
 //        |                 /                   _____ You can use any name you like for the struct
 //        |                 |                  /
 //        |                 |                  |
-void printTIMTM2data(UBX_TIM_TM2_data_t ubxDataStruct)
+void printTIMTM2data(UBX_TIM_TM2_data_t *ubxDataStruct)
 {
     Serial.println();
 
     Serial.print(F("newFallingEdge: ")); // 1 if a new falling edge was detected
-    Serial.print(ubxDataStruct.flags.bits.newFallingEdge);
+    Serial.print(ubxDataStruct->flags.bits.newFallingEdge);
 
     Serial.print(F(" newRisingEdge: ")); // 1 if a new rising edge was detected
-    Serial.print(ubxDataStruct.flags.bits.newRisingEdge);
+    Serial.print(ubxDataStruct->flags.bits.newRisingEdge);
 
     Serial.print(F(" Rising Edge Counter: ")); // Rising edge counter
-    Serial.print(ubxDataStruct.count);
+    Serial.print(ubxDataStruct->count);
 
     Serial.print(F(" towMsR: ")); // Time Of Week of rising edge (ms)
-    Serial.print(ubxDataStruct.towMsR);
+    Serial.print(ubxDataStruct->towMsR);
 
     Serial.print(F(" towSubMsR: ")); // Millisecond fraction of Time Of Week of rising edge in nanoseconds
-    Serial.print(ubxDataStruct.towSubMsR);
+    Serial.print(ubxDataStruct->towSubMsR);
 
     Serial.print(F(" towMsF: ")); // Time Of Week of falling edge (ms)
-    Serial.print(ubxDataStruct.towMsF);
+    Serial.print(ubxDataStruct->towMsF);
 
     Serial.print(F(" towSubMsF: ")); // Millisecond fraction of Time Of Week of falling edge in nanoseconds
-    Serial.println(ubxDataStruct.towSubMsF);
+    Serial.println(ubxDataStruct->towSubMsF);
 
     dotsPrinted = 0; // Reset dotsPrinted
 }
@@ -97,7 +97,7 @@ void setup()
 
   myGNSS.setNavigationFrequency(1); //Produce one solution per second
 
-  myGNSS.setAutoTIMTM2callback(&printTIMTM2data); // Enable automatic TIM TM2 messages with callback to printTIMTM2data
+  myGNSS.setAutoTIMTM2callbackPtr(&printTIMTM2data); // Enable automatic TIM TM2 messages with callback to printTIMTM2data
 }
 
 void loop()

examples/Callbacks/CallbackExample4_HNR/CallbackExample4_HNR.ino

@@ -38,39 +38,39 @@ SFE_UBLOX_GNSS myGNSS;
 //        |                 /                   _____ You can use any name you like for the struct
 //        |                 |                  /
 //        |                 |                  |
-void printHNRATTdata(UBX_HNR_ATT_data_t ubxDataStruct)
+void printHNRATTdata(UBX_HNR_ATT_data_t *ubxDataStruct)
 {
   Serial.println();
   Serial.print(F("Roll: ")); // Print selected data
-  Serial.print((float)ubxDataStruct.roll / 100000.0, 2); // Convert roll to degrees
+  Serial.print((float)ubxDataStruct->roll / 100000.0, 2); // Convert roll to degrees
   Serial.print(F(" Pitch: "));
-  Serial.print((float)ubxDataStruct.pitch / 100000.0, 2); // Convert pitch to degrees
+  Serial.print((float)ubxDataStruct->pitch / 100000.0, 2); // Convert pitch to degrees
   Serial.print(F(" Heading: "));
-  Serial.println((float)ubxDataStruct.heading / 100000.0, 2); // Convert heading to degrees
+  Serial.println((float)ubxDataStruct->heading / 100000.0, 2); // Convert heading to degrees
 }
 
 // Callback: printHNRINSdata will be called when new HNR INS data arrives
 // See u-blox_structs.h for the full definition of UBX_HNR_INS_data_t
-void printHNRINSdata(UBX_HNR_INS_data_t ubxDataStruct)
+void printHNRINSdata(UBX_HNR_INS_data_t *ubxDataStruct)
 {
   Serial.print(F("xAccel: ")); // Print selected data
-  Serial.print(ubxDataStruct.xAccel);
+  Serial.print(ubxDataStruct->xAccel);
   Serial.print(F(" yAccel: "));
-  Serial.print(ubxDataStruct.yAccel);
+  Serial.print(ubxDataStruct->yAccel);
   Serial.print(F(" zAccel: "));
-  Serial.println(ubxDataStruct.zAccel);
+  Serial.println(ubxDataStruct->zAccel);
 }
 
 // Callback: printHNRPVTdata will be called when new HNR PVT data arrives
 // See u-blox_structs.h for the full definition of UBX_HNR_PVT_data_t
-void printHNRPVTdata(UBX_HNR_PVT_data_t ubxDataStruct)
+void printHNRPVTdata(UBX_HNR_PVT_data_t *ubxDataStruct)
 {
   Serial.print(F("ns: ")); // Print selected data
-  Serial.print(ubxDataStruct.nano);
+  Serial.print(ubxDataStruct->nano);
   Serial.print(F(" Lat: "));
-  Serial.print(ubxDataStruct.lat);
+  Serial.print(ubxDataStruct->lat);
   Serial.print(F(" Lon: "));
-  Serial.println(ubxDataStruct.lon);
+  Serial.println(ubxDataStruct->lon);
 }
 
 void setup()
@@ -97,13 +97,13 @@ void setup()
   else
     Serial.println(F("setHNRNavigationRate was NOT successful"));
 
-  if (myGNSS.setAutoHNRATTcallback(&printHNRATTdata) == true) // Enable automatic HNR ATT messages with callback to printHNRATTdata
+  if (myGNSS.setAutoHNRATTcallbackPtr(&printHNRATTdata) == true) // Enable automatic HNR ATT messages with callback to printHNRATTdata
     Serial.println(F("setAutoHNRATTcallback successful"));
 
-  if (myGNSS.setAutoHNRINScallback(&printHNRINSdata) == true) // Enable automatic HNR INS messages with callback to printHNRINSdata
+  if (myGNSS.setAutoHNRINScallbackPtr(&printHNRINSdata) == true) // Enable automatic HNR INS messages with callback to printHNRINSdata
     Serial.println(F("setAutoHNRINScallback successful"));
 
-  if (myGNSS.setAutoHNRPVTcallback(&printHNRPVTdata) == true) // Enable automatic HNR PVT messages with callback to printHNRPVTdata
+  if (myGNSS.setAutoHNRPVTcallbackPtr(&printHNRPVTdata) == true) // Enable automatic HNR PVT messages with callback to printHNRPVTdata
     Serial.println(F("setAutoHNRPVTcallback successful"));
 }
 

examples/Callbacks/CallbackExample5_ESF/CallbackExample5_ESF.ino

@@ -35,39 +35,39 @@ SFE_UBLOX_GNSS myGNSS;
 //        |                 /                   _____ You can use any name you like for the struct
 //        |                 |                  /
 //        |                 |                  |
-void printESFALGdata(UBX_ESF_ALG_data_t ubxDataStruct)
+void printESFALGdata(UBX_ESF_ALG_data_t *ubxDataStruct)
 {
   Serial.println();
 
   Serial.print(F("TOW: ")); // Print the Time Of Week
-  unsigned long iTOW = ubxDataStruct.iTOW; // iTOW is in milliseconds
+  unsigned long iTOW = ubxDataStruct->iTOW; // iTOW is in milliseconds
   Serial.print(iTOW);
   Serial.print(F(" (ms)"));
 
   Serial.print(F(" Roll: ")); // Print selected data
-  Serial.print((float)ubxDataStruct.roll / 100.0, 2); // Convert roll to degrees
+  Serial.print((float)ubxDataStruct->roll / 100.0, 2); // Convert roll to degrees
 
   Serial.print(F(" Pitch: "));
-  Serial.print((float)ubxDataStruct.pitch / 100.0, 2); // Convert pitch to degrees
+  Serial.print((float)ubxDataStruct->pitch / 100.0, 2); // Convert pitch to degrees
 
   Serial.print(F(" Yaw: "));
-  Serial.print((float)ubxDataStruct.yaw / 100.0, 2); // Convert yaw to degrees
+  Serial.print((float)ubxDataStruct->yaw / 100.0, 2); // Convert yaw to degrees
 
   Serial.println(F(" (Degrees)"));
 }
 
 // Callback: printESFINSdata will be called when new ESF INS data arrives
 // See u-blox_structs.h for the full definition of UBX_ESF_INS_data_t
-void printESFINSdata(UBX_ESF_INS_data_t ubxDataStruct)
+void printESFINSdata(UBX_ESF_INS_data_t *ubxDataStruct)
 {
   Serial.print(F("xAccel: ")); // Print selected data
-  Serial.print(ubxDataStruct.xAccel);
+  Serial.print(ubxDataStruct->xAccel);
 
   Serial.print(F(" yAccel: "));
-  Serial.print(ubxDataStruct.yAccel);
+  Serial.print(ubxDataStruct->yAccel);
 
   Serial.print(F(" zAccel: "));
-  Serial.print(ubxDataStruct.zAccel);
+  Serial.print(ubxDataStruct->zAccel);
 
   Serial.println(F(" (m/s^2)"));
 }
@@ -75,23 +75,23 @@ void printESFINSdata(UBX_ESF_INS_data_t ubxDataStruct)
 // Callback: printESFMEASdata will be called when new ESF MEAS data arrives
 // See u-blox_structs.h for the full definition of UBX_ESF_MEAS_data_t
 // and UBX_ESF_MEAS_sensorData_t
-void printESFMEASdata(UBX_ESF_MEAS_data_t ubxDataStruct)
+void printESFMEASdata(UBX_ESF_MEAS_data_t *ubxDataStruct)
 {
   Serial.println();
 
   Serial.print(F("id: ")); // Print selected data
-  Serial.print(ubxDataStruct.id);
+  Serial.print(ubxDataStruct->id);
 
   Serial.print(F(" numMeas: "));
-  Serial.println(ubxDataStruct.flags.bits.numMeas);
+  Serial.println(ubxDataStruct->flags.bits.numMeas);
 
-  for (uint8_t num = 0; num < ubxDataStruct.flags.bits.numMeas; num++) // For each sensor
+  for (uint8_t num = 0; num < ubxDataStruct->flags.bits.numMeas; num++) // For each sensor
   {
     Serial.print(F("Sensor "));
     Serial.print(num);
 
     UBX_ESF_MEAS_sensorData_t sensorData;
-    myGNSS.getSensorFusionMeasurement(&sensorData, ubxDataStruct, num); // Extract the data for one sensor
+    myGNSS.getSensorFusionMeasurement(&sensorData, *ubxDataStruct, num); // Extract the data for one sensor
 
     Serial.print(F(": Type: "));
     Serial.print(sensorData.data.bits.dataType);
@@ -103,21 +103,21 @@ void printESFMEASdata(UBX_ESF_MEAS_data_t ubxDataStruct)
 // Callback: printESFSTATUSdata will be called when new ESF STATUS data arrives
 // See u-blox_structs.h for the full definition of UBX_ESF_STATUS_data_t
 // and UBX_ESF_STATUS_sensorStatus_t
-void printESFSTATUSdata(UBX_ESF_STATUS_data_t ubxDataStruct)
+void printESFSTATUSdata(UBX_ESF_STATUS_data_t *ubxDataStruct)
 {
   Serial.print(F("fusionMode: ")); // Print selected data
-  Serial.print(ubxDataStruct.fusionMode);
+  Serial.print(ubxDataStruct->fusionMode);
 
   Serial.print(F(" numSens: "));
-  Serial.println(ubxDataStruct.numSens);
+  Serial.println(ubxDataStruct->numSens);
 
-  for (uint8_t num = 0; num < ubxDataStruct.numSens; num++) // For each sensor
+  for (uint8_t num = 0; num < ubxDataStruct->numSens; num++) // For each sensor
   {
     Serial.print(F("Sensor "));
     Serial.print(num);
 
     UBX_ESF_STATUS_sensorStatus_t sensorStatus;
-    myGNSS.getSensorFusionStatus(&sensorStatus, ubxDataStruct, num); // Extract the data for one sensor
+    myGNSS.getSensorFusionStatus(&sensorStatus, *ubxDataStruct, num); // Extract the data for one sensor
 
     Serial.print(F(": Type: "));
     Serial.print(sensorStatus.sensStatus1.bits.type);
@@ -156,16 +156,16 @@ void setup()
 
   myGNSS.setI2CpollingWait(50); //Allow checkUblox to poll I2C data every 50ms to keep up with the ESF MEAS messages
 
-  if (myGNSS.setAutoESFALGcallback(&printESFALGdata) == true) // Enable automatic ESF ALG messages with callback to printESFALGdata
+  if (myGNSS.setAutoESFALGcallbackPtr(&printESFALGdata) == true) // Enable automatic ESF ALG messages with callback to printESFALGdata
     Serial.println(F("setAutoESFALGcallback successful"));
 
-  if (myGNSS.setAutoESFINScallback(&printESFINSdata) == true) // Enable automatic ESF INS messages with callback to printESFINSdata
+  if (myGNSS.setAutoESFINScallbackPtr(&printESFINSdata) == true) // Enable automatic ESF INS messages with callback to printESFINSdata
     Serial.println(F("setAutoESFINScallback successful"));
 
-  if (myGNSS.setAutoESFMEAScallback(&printESFMEASdata) == true) // Enable automatic ESF MEAS messages with callback to printESFMEASdata
+  if (myGNSS.setAutoESFMEAScallbackPtr(&printESFMEASdata) == true) // Enable automatic ESF MEAS messages with callback to printESFMEASdata
     Serial.println(F("setAutoESFMEAScallback successful"));
 
-  if (myGNSS.setAutoESFSTATUScallback(&printESFSTATUSdata) == true) // Enable automatic ESF STATUS messages with callback to printESFSTATUSdata
+  if (myGNSS.setAutoESFSTATUScallbackPtr(&printESFSTATUSdata) == true) // Enable automatic ESF STATUS messages with callback to printESFSTATUSdata
     Serial.println(F("setAutoESFSTATUScallback successful"));
 }
 

examples/Callbacks/CallbackExample6_RAWX/CallbackExample6_RAWX.ino

@@ -31,38 +31,38 @@ SFE_UBLOX_GNSS myGNSS;
 //        |            /                _____ You can use any name you like for the struct
 //        |            |               /
 //        |            |               |
-void newRAWX(UBX_RXM_RAWX_data_t ubxDataStruct)
+void newRAWX(UBX_RXM_RAWX_data_t *ubxDataStruct)
 {
   Serial.println();
 
   Serial.print(F("New RAWX data received. It contains "));
-  Serial.print(ubxDataStruct.header.numMeas); // Print numMeas (Number of measurements / blocks)
+  Serial.print(ubxDataStruct->header.numMeas); // Print numMeas (Number of measurements / blocks)
   Serial.println(F(" data blocks:"));
 
-  for (uint8_t block = 0; block < ubxDataStruct.header.numMeas; block++) // For each block
+  for (uint8_t block = 0; block < ubxDataStruct->header.numMeas; block++) // For each block
   {
     Serial.print(F("GNSS ID: "));
-    if (ubxDataStruct.blocks[block].gnssId < 100) Serial.print(F(" ")); // Align the gnssId
+    if (ubxDataStruct->blocks[block].gnssId < 100) Serial.print(F(" ")); // Align the gnssId
-    if (ubxDataStruct.blocks[block].gnssId < 10) Serial.print(F(" ")); // Align the gnssId
+    if (ubxDataStruct->blocks[block].gnssId < 10) Serial.print(F(" ")); // Align the gnssId
-    Serial.print(ubxDataStruct.blocks[block].gnssId);
+    Serial.print(ubxDataStruct->blocks[block].gnssId);
     Serial.print(F("  SV ID: "));
-    if (ubxDataStruct.blocks[block].svId < 100) Serial.print(F(" ")); // Align the svId
+    if (ubxDataStruct->blocks[block].svId < 100) Serial.print(F(" ")); // Align the svId
-    if (ubxDataStruct.blocks[block].svId < 10) Serial.print(F(" ")); // Align the svId
+    if (ubxDataStruct->blocks[block].svId < 10) Serial.print(F(" ")); // Align the svId
-    Serial.print(ubxDataStruct.blocks[block].svId);
+    Serial.print(ubxDataStruct->blocks[block].svId);
 
     if (sizeof(double) == 8) // Check if our processor supports 64-bit double
     {
       // Convert prMes from uint8_t[8] to 64-bit double
       // prMes is little-endian
       double pseudorange;
-      memcpy(&pseudorange, &ubxDataStruct.blocks[block].prMes, 8);
+      memcpy(&pseudorange, &ubxDataStruct->blocks[block].prMes, 8);
       Serial.print(F("  PR: "));
       Serial.print(pseudorange, 3);
 
       // Convert cpMes from uint8_t[8] to 64-bit double
       // cpMes is little-endian
       double carrierPhase;
-      memcpy(&carrierPhase, &ubxDataStruct.blocks[block].cpMes, 8);
+      memcpy(&carrierPhase, &ubxDataStruct->blocks[block].cpMes, 8);
       Serial.print(F(" m  CP: "));
       Serial.print(carrierPhase, 3);
       Serial.print(F(" cycles"));
@@ -94,7 +94,7 @@ void setup()
 
   myGNSS.setNavigationFrequency(1); //Produce one solution per second (RAWX produces a _lot_ of data!)
 
-  myGNSS.setAutoRXMRAWXcallback(&newRAWX); // Enable automatic RXM RAWX messages with callback to newRAWX
+  myGNSS.setAutoRXMRAWXcallbackPtr(&newRAWX); // Enable automatic RXM RAWX messages with callback to newRAWX
 }
 
 void loop()

examples/Callbacks/CallbackExample7_NAV_SAT/CallbackExample7_NAV_SAT.ino

@@ -31,21 +31,21 @@ SFE_UBLOX_GNSS myGNSS;
 //        |            /                _____ You can use any name you like for the struct
 //        |            |               /
 //        |            |               |
-void newNAVSAT(UBX_NAV_SAT_data_t ubxDataStruct)
+void newNAVSAT(UBX_NAV_SAT_data_t *ubxDataStruct)
 {
   Serial.println();
 
   Serial.print(F("New NAV SAT data received. It contains data for "));
-  Serial.print(ubxDataStruct.header.numSvs);
+  Serial.print(ubxDataStruct->header.numSvs);
-  if (ubxDataStruct.header.numSvs == 1)
+  if (ubxDataStruct->header.numSvs == 1)
     Serial.println(F(" SV."));
   else
     Serial.println(F(" SVs."));
 
   // Just for giggles, print the signal strength for each SV as a barchart
-  for (uint16_t block = 0; block < ubxDataStruct.header.numSvs; block++) // For each SV
+  for (uint16_t block = 0; block < ubxDataStruct->header.numSvs; block++) // For each SV
   {
-    switch (ubxDataStruct.blocks[block].gnssId) // Print the GNSS ID
+    switch (ubxDataStruct->blocks[block].gnssId) // Print the GNSS ID
     {
       case 0:
         Serial.print(F("GPS     "));
@@ -73,14 +73,14 @@ void newNAVSAT(UBX_NAV_SAT_data_t ubxDataStruct)
       break;      
     }
     
-    Serial.print(ubxDataStruct.blocks[block].svId); // Print the SV ID
+    Serial.print(ubxDataStruct->blocks[block].svId); // Print the SV ID
     
-    if (ubxDataStruct.blocks[block].svId < 10) Serial.print(F("   "));
+    if (ubxDataStruct->blocks[block].svId < 10) Serial.print(F("   "));
-    else if (ubxDataStruct.blocks[block].svId < 100) Serial.print(F("  "));
+    else if (ubxDataStruct->blocks[block].svId < 100) Serial.print(F("  "));
     else Serial.print(F(" "));
 
     // Print the signal strength as a bar chart
-    for (uint8_t cno = 0; cno < ubxDataStruct.blocks[block].cno; cno++)
+    for (uint8_t cno = 0; cno < ubxDataStruct->blocks[block].cno; cno++)
       Serial.print(F("="));
 
     Serial.println();
@@ -108,7 +108,7 @@ void setup()
 
   myGNSS.setNavigationFrequency(1); //Produce one solution per second
 
-  myGNSS.setAutoNAVSATcallback(&newNAVSAT); // Enable automatic NAV SAT messages with callback to newNAVSAT
+  myGNSS.setAutoNAVSATcallbackPtr(&newNAVSAT); // Enable automatic NAV SAT messages with callback to newNAVSAT
 }
 
 void loop()

examples/Data_Logging/DataLoggingExample1_NAV_PVT/DataLoggingExample1_NAV_PVT.ino

@@ -22,9 +22,7 @@
   Insert a formatted micro-SD card into the socket on the Carrier Board.
   Connect the Carrier Board to your computer using a USB-C cable.
   Ensure you have the SparkFun Apollo3 boards installed: http://boardsmanager/All#SparkFun_Apollo3
-  This code has been tested using version 2.1.0 of the Apollo3 boards on Arduino IDE 1.8.13.
+  This code has been tested using version 2.2.0 of the Apollo3 boards on Arduino IDE 1.8.13.
-   - Version 2.1.1 of Apollo3 contains a feature which makes I2C communication with u-blox modules problematic
-   - We recommend using v2.1.0 of Apollo3 until v2.2.0 is released
   Select "Artemis MicroMod Processor" as the board type.
   Press upload to upload the code onto the Artemis.
   Open the Serial Monitor at 115200 baud to see the output.
@@ -69,6 +67,7 @@ File myFile; //File that all GNSS data is written to
 #endif
 
 #define packetLength 100 // NAV PVT is 92 + 8 bytes in length (including the sync chars, class, id, length and checksum bytes)
+uint8_t *myBuffer; // Use myBuffer to hold the data while we write it to SD card
 
 // Callback: printPVTdata will be called when new NAV PVT data arrives
 // See u-blox_structs.h for the full definition of UBX_NAV_PVT_data_t
@@ -77,38 +76,38 @@ File myFile; //File that all GNSS data is written to
 //        |                 /               _____ You can use any name you like for the struct
 //        |                 |              /
 //        |                 |              |
-void printPVTdata(UBX_NAV_PVT_data_t ubxDataStruct)
+void printPVTdata(UBX_NAV_PVT_data_t *ubxDataStruct)
 {
     Serial.println();
 
     Serial.print(F("Time: ")); // Print the time
-    uint8_t hms = ubxDataStruct.hour; // Print the hours
+    uint8_t hms = ubxDataStruct->hour; // Print the hours
     if (hms < 10) Serial.print(F("0")); // Print a leading zero if required
     Serial.print(hms);
     Serial.print(F(":"));
-    hms = ubxDataStruct.min; // Print the minutes
+    hms = ubxDataStruct->min; // Print the minutes
     if (hms < 10) Serial.print(F("0")); // Print a leading zero if required
     Serial.print(hms);
     Serial.print(F(":"));
-    hms = ubxDataStruct.sec; // Print the seconds
+    hms = ubxDataStruct->sec; // Print the seconds
     if (hms < 10) Serial.print(F("0")); // Print a leading zero if required
     Serial.print(hms);
     Serial.print(F("."));
-    unsigned long millisecs = ubxDataStruct.iTOW % 1000; // Print the milliseconds
+    unsigned long millisecs = ubxDataStruct->iTOW % 1000; // Print the milliseconds
     if (millisecs < 100) Serial.print(F("0")); // Print the trailing zeros correctly
     if (millisecs < 10) Serial.print(F("0"));
     Serial.print(millisecs);
 
-    long latitude = ubxDataStruct.lat; // Print the latitude
+    long latitude = ubxDataStruct->lat; // Print the latitude
     Serial.print(F(" Lat: "));
     Serial.print(latitude);
 
-    long longitude = ubxDataStruct.lon; // Print the longitude
+    long longitude = ubxDataStruct->lon; // Print the longitude
     Serial.print(F(" Long: "));
     Serial.print(longitude);
     Serial.print(F(" (degrees * 10^-7)"));
 
-    long altitude = ubxDataStruct.hMSL; // Print the height above mean sea level
+    long altitude = ubxDataStruct->hMSL; // Print the height above mean sea level
     Serial.print(F(" Height above MSL: "));
     Serial.print(altitude);
     Serial.println(F(" (mm)"));
@@ -200,10 +199,12 @@ void setup()
 
   myGNSS.setNavigationFrequency(1); //Produce one navigation solution per second
 
-  myGNSS.setAutoPVTcallback(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata
+  myGNSS.setAutoPVTcallbackPtr(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata
 
   myGNSS.logNAVPVT(); // Enable NAV PVT data logging
 
+  myBuffer = new uint8_t[packetLength]; // Create our own buffer to hold the data while we write it to SD card  
+
   Serial.println(F("Press any key to stop logging."));
 }
 
@@ -214,9 +215,7 @@ void loop()
 
   if (myGNSS.fileBufferAvailable() >= packetLength) // Check to see if a new packetLength-byte NAV PVT message has been stored
   {
-    uint8_t myBuffer[packetLength]; // Create our own buffer to hold the data while we write it to SD card
+    myGNSS.extractFileBufferData(myBuffer, packetLength); // Extract exactly packetLength bytes from the UBX file buffer and put them into myBuffer
-
-    myGNSS.extractFileBufferData((uint8_t *)&myBuffer, packetLength); // Extract exactly packetLength bytes from the UBX file buffer and put them into myBuffer
 
     myFile.write(myBuffer, packetLength); // Write exactly packetLength bytes from myBuffer to the ubxDataFile on the SD card
 

examples/Data_Logging/DataLoggingExample2_TIM_TM2/DataLoggingExample2_TIM_TM2.ino

@@ -22,9 +22,7 @@
   Insert a formatted micro-SD card into the socket on the Carrier Board.
   Connect the Carrier Board to your computer using a USB-C cable.
   Ensure you have the SparkFun Apollo3 boards installed: http://boardsmanager/All#SparkFun_Apollo3
-  This code has been tested using version 2.1.0 of the Apollo3 boards on Arduino IDE 1.8.13.
+  This code has been tested using version 2.2.0 of the Apollo3 boards on Arduino IDE 1.8.13.
-   - Version 2.1.1 of Apollo3 contains a feature which makes I2C communication with u-blox modules problematic
-   - We recommend using v2.1.0 of Apollo3 until v2.2.0 is released
   Select "Artemis MicroMod Processor" as the board type.
   Press upload to upload the code onto the Artemis.
   Open the Serial Monitor at 115200 baud to see the output.
@@ -82,6 +80,7 @@ File myFile; //File that all GNSS data is written to
 #endif
 
 #define packetLength 36 // TIM TM2 is 28 + 8 bytes in length (including the sync chars, class, id, length and checksum bytes)
+uint8_t *myBuffer; // Use myBuffer to hold the data while we write it to SD card
 
 int dotsPrinted = 0; // Print dots in rows of 50 while waiting for a TIM TM2 message
 
@@ -92,30 +91,30 @@ int dotsPrinted = 0; // Print dots in rows of 50 while waiting for a TIM TM2 mes
 //        |                 /                   _____ You can use any name you like for the struct
 //        |                 |                  /
 //        |                 |                  |
-void printTIMTM2data(UBX_TIM_TM2_data_t ubxDataStruct)
+void printTIMTM2data(UBX_TIM_TM2_data_t *ubxDataStruct)
 {
   Serial.println();
 
   Serial.print(F("newFallingEdge: ")); // 1 if a new falling edge was detected
-  Serial.print(ubxDataStruct.flags.bits.newFallingEdge);
+  Serial.print(ubxDataStruct->flags.bits.newFallingEdge);
 
   Serial.print(F(" newRisingEdge: ")); // 1 if a new rising edge was detected
-  Serial.print(ubxDataStruct.flags.bits.newRisingEdge);
+  Serial.print(ubxDataStruct->flags.bits.newRisingEdge);
 
   Serial.print(F(" Rising Edge Counter: ")); // Rising edge counter
-  Serial.print(ubxDataStruct.count);
+  Serial.print(ubxDataStruct->count);
 
   Serial.print(F(" towMsR: ")); // Time Of Week of rising edge (ms)
-  Serial.print(ubxDataStruct.towMsR);
+  Serial.print(ubxDataStruct->towMsR);
 
   Serial.print(F(" towSubMsR: ")); // Millisecond fraction of Time Of Week of rising edge in nanoseconds
-  Serial.print(ubxDataStruct.towSubMsR);
+  Serial.print(ubxDataStruct->towSubMsR);
 
   Serial.print(F(" towMsF: ")); // Time Of Week of falling edge (ms)
-  Serial.print(ubxDataStruct.towMsF);
+  Serial.print(ubxDataStruct->towMsF);
 
   Serial.print(F(" towSubMsF: ")); // Millisecond fraction of Time Of Week of falling edge in nanoseconds
-  Serial.println(ubxDataStruct.towSubMsF);
+  Serial.println(ubxDataStruct->towSubMsF);
 
   dotsPrinted = 0; // Reset dotsPrinted
 }
@@ -206,10 +205,12 @@ void setup()
 
   myGNSS.setNavigationFrequency(1); //Produce one navigation solution per second
 
-  myGNSS.setAutoTIMTM2callback(&printTIMTM2data); // Enable automatic TIM TM2 messages with callback to printTIMTM2data
+  myGNSS.setAutoTIMTM2callbackPtr(&printTIMTM2data); // Enable automatic TIM TM2 messages with callback to printTIMTM2data
 
   myGNSS.logTIMTM2(); // Enable TIM TM2 data logging
 
+  myBuffer = new uint8_t[packetLength]; // Create our own buffer to hold the data while we write it to SD card  
+
   Serial.println(F("Press any key to stop logging."));
 }
 
@@ -220,9 +221,7 @@ void loop()
 
   if (myGNSS.fileBufferAvailable() >= packetLength) // Check to see if a new packetLength-byte TIM TM2 message has been stored
   {
-    uint8_t myBuffer[packetLength]; // Create our own buffer to hold the data while we write it to SD card
+    myGNSS.extractFileBufferData(myBuffer, packetLength); // Extract exactly packetLength bytes from the UBX file buffer and put them into myBuffer
-
-    myGNSS.extractFileBufferData((uint8_t *)&myBuffer, packetLength); // Extract exactly packetLength bytes from the UBX file buffer and put them into myBuffer
 
     myFile.write(myBuffer, packetLength); // Write exactly packetLength bytes from myBuffer to the ubxDataFile on the SD card
 

examples/Data_Logging/DataLoggingExample3_RXM_SFRBX_and_RAWX/DataLoggingExample3_RXM_SFRBX_and_RAWX.ino

@@ -34,9 +34,7 @@
   Insert a formatted micro-SD card into the socket on the Carrier Board.
   Connect the Carrier Board to your computer using a USB-C cable.
   Ensure you have the SparkFun Apollo3 boards installed: http://boardsmanager/All#SparkFun_Apollo3
-  This code has been tested using version 2.1.0 of the Apollo3 boards on Arduino IDE 1.8.13.
+  This code has been tested using version 2.2.0 of the Apollo3 boards on Arduino IDE 1.8.13.
-   - Version 2.1.1 of Apollo3 contains a feature which makes I2C communication with u-blox modules problematic
-   - We recommend using v2.1.0 of Apollo3 until v2.2.0 is released
   Select "Artemis MicroMod Processor" as the board type.
   Press upload to upload the code onto the Artemis.
   Open the Serial Monitor at 115200 baud to see the output.
@@ -76,6 +74,7 @@ File myFile; //File that all GNSS data is written to
 
 #define sdWriteSize 512 // Write data to the SD card in blocks of 512 bytes
 #define fileBufferSize 16384 // Allocate 16KBytes of RAM for UBX message storage
+uint8_t *myBuffer; // Use myBuffer to hold the data while we write it to SD card
 
 unsigned long lastPrint; // Record when the last Serial print took place
 
@@ -93,7 +92,7 @@ int numRAWX = 0; // Keep count of how many RAWX message groups have been receive
 //        |                 /               _____ You can use any name you like for the struct
 //        |                 |              /
 //        |                 |              |
-void newSFRBX(UBX_RXM_SFRBX_data_t ubxDataStruct)
+void newSFRBX(UBX_RXM_SFRBX_data_t *ubxDataStruct)
 {
   numSFRBX++; // Increment the count
 }
@@ -105,7 +104,7 @@ void newSFRBX(UBX_RXM_SFRBX_data_t ubxDataStruct)
 //        |            /                _____ You can use any name you like for the struct
 //        |            |               /
 //        |            |               |
-void newRAWX(UBX_RXM_RAWX_data_t ubxDataStruct)
+void newRAWX(UBX_RXM_RAWX_data_t *ubxDataStruct)
 {
   numRAWX++; // Increment the count
 }
@@ -202,14 +201,16 @@ void setup()
 
   myGNSS.setNavigationFrequency(1); //Produce one navigation solution per second (that's plenty for Precise Point Positioning)
 
-  myGNSS.setAutoRXMSFRBXcallback(&newSFRBX); // Enable automatic RXM SFRBX messages with callback to newSFRBX
+  myGNSS.setAutoRXMSFRBXcallbackPtr(&newSFRBX); // Enable automatic RXM SFRBX messages with callback to newSFRBX
 
   myGNSS.logRXMSFRBX(); // Enable RXM SFRBX data logging
 
-  myGNSS.setAutoRXMRAWXcallback(&newRAWX); // Enable automatic RXM RAWX messages with callback to newRAWX
+  myGNSS.setAutoRXMRAWXcallbackPtr(&newRAWX); // Enable automatic RXM RAWX messages with callback to newRAWX
 
   myGNSS.logRXMRAWX(); // Enable RXM RAWX data logging
 
+  myBuffer = new uint8_t[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card  
+
   Serial.println(F("Press any key to stop logging."));
 
   lastPrint = millis(); // Initialize lastPrint
@@ -228,9 +229,7 @@ void loop()
   {
     digitalWrite(LED_BUILTIN, HIGH); // Flash LED_BUILTIN each time we write to the SD card
 
-    uint8_t myBuffer[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
+    myGNSS.extractFileBufferData(myBuffer, sdWriteSize); // Extract exactly sdWriteSize bytes from the UBX file buffer and put them into myBuffer
-
-    myGNSS.extractFileBufferData((uint8_t *)&myBuffer, sdWriteSize); // Extract exactly sdWriteSize bytes from the UBX file buffer and put them into myBuffer
 
     myFile.write(myBuffer, sdWriteSize); // Write exactly sdWriteSize bytes from myBuffer to the ubxDataFile on the SD card
 
@@ -273,15 +272,13 @@ void loop()
     {
       digitalWrite(LED_BUILTIN, HIGH); // Flash LED_BUILTIN while we write to the SD card
 
-      uint8_t myBuffer[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
-
       uint16_t bytesToWrite = remainingBytes; // Write the remaining bytes to SD card sdWriteSize bytes at a time
       if (bytesToWrite > sdWriteSize)
       {
         bytesToWrite = sdWriteSize;
       }
 
-      myGNSS.extractFileBufferData((uint8_t *)&myBuffer, bytesToWrite); // Extract bytesToWrite bytes from the UBX file buffer and put them into myBuffer
+      myGNSS.extractFileBufferData(myBuffer, bytesToWrite); // Extract bytesToWrite bytes from the UBX file buffer and put them into myBuffer
 
       myFile.write(myBuffer, bytesToWrite); // Write bytesToWrite bytes from myBuffer to the ubxDataFile on the SD card
 

examples/Data_Logging/DataLoggingExample4_RXM_without_Callbacks/DataLoggingExample4_RXM_without_Callbacks.ino

@@ -35,9 +35,7 @@
   Insert a formatted micro-SD card into the socket on the Carrier Board.
   Connect the Carrier Board to your computer using a USB-C cable.
   Ensure you have the SparkFun Apollo3 boards installed: http://boardsmanager/All#SparkFun_Apollo3
-  This code has been tested using version 2.1.0 of the Apollo3 boards on Arduino IDE 1.8.13.
+  This code has been tested using version 2.2.0 of the Apollo3 boards on Arduino IDE 1.8.13.
-   - Version 2.1.1 of Apollo3 contains a feature which makes I2C communication with u-blox modules problematic
-   - We recommend using v2.1.0 of Apollo3 until v2.2.0 is released
   Select "Artemis MicroMod Processor" as the board type.
   Press upload to upload the code onto the Artemis.
   Open the Serial Monitor at 115200 baud to see the output.
@@ -77,6 +75,7 @@ File myFile; //File that all GNSS data is written to
 
 #define sdWriteSize 512 // Write data to the SD card in blocks of 512 bytes
 #define fileBufferSize 16384 // Allocate 16KBytes of RAM for UBX message storage
+uint8_t *myBuffer; // A buffer to hold the data while we write it to SD card
 
 unsigned long lastPrint; // Record when the last Serial print took place
 unsigned long bytesWritten = 0; // Record how many bytes have been written to SD card
@@ -181,6 +180,8 @@ void setup()
   
   myGNSS.logRXMRAWX(); // Enable RXM RAWX data logging
 
+  myBuffer = new uint8_t[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
+
   Serial.println(F("Press any key to stop logging."));
 
   lastPrint = millis(); // Initialize lastPrint
@@ -198,9 +199,7 @@ void loop()
   {
     digitalWrite(LED_BUILTIN, HIGH); // Flash LED_BUILTIN each time we write to the SD card
   
-    uint8_t myBuffer[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
+    myGNSS.extractFileBufferData(myBuffer, sdWriteSize); // Extract exactly sdWriteSize bytes from the UBX file buffer and put them into myBuffer
-
-    myGNSS.extractFileBufferData((uint8_t *)&myBuffer, sdWriteSize); // Extract exactly sdWriteSize bytes from the UBX file buffer and put them into myBuffer
 
     myFile.write(myBuffer, sdWriteSize); // Write exactly sdWriteSize bytes from myBuffer to the ubxDataFile on the SD card
 
@@ -242,15 +241,13 @@ void loop()
     {
       digitalWrite(LED_BUILTIN, HIGH); // Flash LED_BUILTIN while we write to the SD card
       
-      uint8_t myBuffer[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
-
       uint16_t bytesToWrite = remainingBytes; // Write the remaining bytes to SD card sdWriteSize bytes at a time
       if (bytesToWrite > sdWriteSize)
       {
         bytesToWrite = sdWriteSize;
       }
   
-      myGNSS.extractFileBufferData((uint8_t *)&myBuffer, bytesToWrite); // Extract bytesToWrite bytes from the UBX file buffer and put them into myBuffer
+      myGNSS.extractFileBufferData(myBuffer, bytesToWrite); // Extract bytesToWrite bytes from the UBX file buffer and put them into myBuffer
 
       myFile.write(myBuffer, bytesToWrite); // Write bytesToWrite bytes from myBuffer to the ubxDataFile on the SD card
 

examples/Data_Logging/DataLoggingExample5_Fast_RXM/DataLoggingExample5_Fast_RXM.ino

@@ -35,9 +35,7 @@
   Insert a formatted micro-SD card into the socket on the Carrier Board.
   Connect the Carrier Board to your computer using a USB-C cable.
   Ensure you have the SparkFun Apollo3 boards installed: http://boardsmanager/All#SparkFun_Apollo3
-  This code has been tested using version 2.1.0 of the Apollo3 boards on Arduino IDE 1.8.13.
+  This code has been tested using version 2.2.0 of the Apollo3 boards on Arduino IDE 1.8.13.
-   - Version 2.1.1 of Apollo3 contains a feature which makes I2C communication with u-blox modules problematic
-   - We recommend using v2.1.0 of Apollo3 until v2.2.0 is released
   Select "Artemis MicroMod Processor" as the board type.
   Press upload to upload the code onto the Artemis.
   Open the Serial Monitor at 115200 baud to see the output.
@@ -77,6 +75,7 @@ File myFile; //File that all GNSS data is written to
 
 #define sdWriteSize 512 // Write data to the SD card in blocks of 512 bytes
 #define fileBufferSize 32768 // Allocate 32KBytes of RAM for UBX message storage
+uint8_t *myBuffer; // A buffer to hold the data while we write it to SD card
 
 unsigned long lastPrint; // Record when the last Serial print took place
 unsigned long bytesWritten = 0; // Record how many bytes have been written to SD card
@@ -196,6 +195,8 @@ void setup()
   
   myGNSS.logRXMRAWX(); // Enable RXM RAWX data logging
 
+  myBuffer = new uint8_t[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
+
   Serial.println(F("Press any key to stop logging."));
 
   lastPrint = millis(); // Initialize lastPrint
@@ -213,9 +214,7 @@ void loop()
   {
     digitalWrite(LED_BUILTIN, HIGH); // Flash LED_BUILTIN each time we write to the SD card
   
-    uint8_t myBuffer[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
+    myGNSS.extractFileBufferData(myBuffer, sdWriteSize); // Extract exactly sdWriteSize bytes from the UBX file buffer and put them into myBuffer
-
-    myGNSS.extractFileBufferData((uint8_t *)&myBuffer, sdWriteSize); // Extract exactly sdWriteSize bytes from the UBX file buffer and put them into myBuffer
 
     myFile.write(myBuffer, sdWriteSize); // Write exactly sdWriteSize bytes from myBuffer to the ubxDataFile on the SD card
 
@@ -263,15 +262,13 @@ void loop()
     {
       digitalWrite(LED_BUILTIN, HIGH); // Flash LED_BUILTIN while we write to the SD card
       
-      uint8_t myBuffer[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
-
       uint16_t bytesToWrite = remainingBytes; // Write the remaining bytes to SD card sdWriteSize bytes at a time
       if (bytesToWrite > sdWriteSize)
       {
         bytesToWrite = sdWriteSize;
       }
   
-      myGNSS.extractFileBufferData((uint8_t *)&myBuffer, bytesToWrite); // Extract bytesToWrite bytes from the UBX file buffer and put them into myBuffer
+      myGNSS.extractFileBufferData(myBuffer, bytesToWrite); // Extract bytesToWrite bytes from the UBX file buffer and put them into myBuffer
 
       myFile.write(myBuffer, bytesToWrite); // Write bytesToWrite bytes from myBuffer to the ubxDataFile on the SD card
 

examples/Data_Logging/DataLoggingExample6_NMEA/DataLoggingExample6_NMEA.ino

@@ -24,9 +24,7 @@
   Insert a formatted micro-SD card into the socket on the Carrier Board.
   Connect the Carrier Board to your computer using a USB-C cable.
   Ensure you have the SparkFun Apollo3 boards installed: http://boardsmanager/All#SparkFun_Apollo3
-  This code has been tested using version 2.1.0 of the Apollo3 boards on Arduino IDE 1.8.13.
+  This code has been tested using version 2.2.0 of the Apollo3 boards on Arduino IDE 1.8.13.
-   - Version 2.1.1 of Apollo3 contains a feature which makes I2C communication with u-blox modules problematic
-   - We recommend using v2.1.0 of Apollo3 until v2.2.0 is released
   Select "Artemis MicroMod Processor" as the board type.
   Press upload to upload the code onto the Artemis.
   Open the Serial Monitor at 115200 baud to see the output.
@@ -68,6 +66,7 @@ File myFile; //File that all GNSS data is written to
 
 #define sdWriteSize 512 // Write data to the SD card in blocks of 512 bytes
 #define fileBufferSize 16384 // Allocate 16KBytes of RAM for UBX message storage
+uint8_t *myBuffer; // A buffer to hold the data while we write it to SD card
 
 unsigned long lastPrint; // Record when the last Serial print took place
 unsigned long bytesWritten = 0; // Record how many bytes have been written to SD card
@@ -175,6 +174,8 @@ void setup()
   myGNSS.setNMEALoggingMask(SFE_UBLOX_FILTER_NMEA_ALL); // Enable logging of all enabled NMEA messages
   //myGNSS.setNMEALoggingMask(SFE_UBLOX_FILTER_NMEA_GGA | SFE_UBLOX_FILTER_NMEA_GSA); // Or we can, for example, log only GxGGA & GxGSA and ignore GxGSV
 
+  myBuffer = new uint8_t[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
+  
   Serial.println(F("Press any key to stop logging."));
 
   lastPrint = millis(); // Initialize lastPrint
@@ -192,9 +193,7 @@ void loop()
   {
     digitalWrite(LED_BUILTIN, HIGH); // Flash LED_BUILTIN each time we write to the SD card
   
-    uint8_t myBuffer[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
+    myGNSS.extractFileBufferData(myBuffer, sdWriteSize); // Extract exactly sdWriteSize bytes from the UBX file buffer and put them into myBuffer
-
-    myGNSS.extractFileBufferData((uint8_t *)&myBuffer, sdWriteSize); // Extract exactly sdWriteSize bytes from the UBX file buffer and put them into myBuffer
 
     myFile.write(myBuffer, sdWriteSize); // Write exactly sdWriteSize bytes from myBuffer to the ubxDataFile on the SD card
 
@@ -236,15 +235,13 @@ void loop()
     {
       digitalWrite(LED_BUILTIN, HIGH); // Flash LED_BUILTIN while we write to the SD card
       
-      uint8_t myBuffer[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
-
       uint16_t bytesToWrite = remainingBytes; // Write the remaining bytes to SD card sdWriteSize bytes at a time
       if (bytesToWrite > sdWriteSize)
       {
         bytesToWrite = sdWriteSize;
       }
   
-      myGNSS.extractFileBufferData((uint8_t *)&myBuffer, bytesToWrite); // Extract bytesToWrite bytes from the UBX file buffer and put them into myBuffer
+      myGNSS.extractFileBufferData(myBuffer, bytesToWrite); // Extract bytesToWrite bytes from the UBX file buffer and put them into myBuffer
 
       myFile.write(myBuffer, bytesToWrite); // Write bytesToWrite bytes from myBuffer to the ubxDataFile on the SD card
 

examples/ZED-F9P/Example13_autoHPPOSLLH_with_Callback/Example13_autoHPPOSLLH_with_Callback.ino

@@ -41,27 +41,27 @@ SFE_UBLOX_GNSS myGNSS;
 //        |                 /                   _____ You can use any name you like for the struct
 //        |                 |                  /
 //        |                 |                  |
-void printHPdata(UBX_NAV_HPPOSLLH_data_t ubxDataStruct)
+void printHPdata(UBX_NAV_HPPOSLLH_data_t *ubxDataStruct)
 {
   Serial.println();
 
-  long highResLatitude = ubxDataStruct.lat;
+  long highResLatitude = ubxDataStruct->lat;
   Serial.print(F("Hi Res Lat: "));
   Serial.print(highResLatitude);
 
-  int highResLatitudeHp = ubxDataStruct.latHp;
+  int highResLatitudeHp = ubxDataStruct->latHp;
   Serial.print(F(" "));
   Serial.print(highResLatitudeHp);
 
-  long highResLongitude = ubxDataStruct.lon;
+  long highResLongitude = ubxDataStruct->lon;
   Serial.print(F(" Hi Res Long: "));
   Serial.print(highResLongitude);
 
-  int highResLongitudeHp = ubxDataStruct.lonHp;
+  int highResLongitudeHp = ubxDataStruct->lonHp;
   Serial.print(F(" "));
   Serial.print(highResLongitudeHp);
 
-  float horizAccuracy = ((float)ubxDataStruct.hAcc) / 10000.0; // Convert hAcc from mm*0.1 to m
+  float horizAccuracy = ((float)ubxDataStruct->hAcc) / 10000.0; // Convert hAcc from mm*0.1 to m
   Serial.print(F(" Horiz accuracy: "));
   Serial.println(horizAccuracy);
 }
@@ -73,38 +73,38 @@ void printHPdata(UBX_NAV_HPPOSLLH_data_t ubxDataStruct)
 //        |                 /                _____ You can use any name you like for the struct
 //        |                 |               /
 //        |                 |               |
-void printPVTdata(UBX_NAV_PVT_data_t ubxDataStruct)
+void printPVTdata(UBX_NAV_PVT_data_t *ubxDataStruct)
 {
     Serial.println();
 
     Serial.print(F("Time: ")); // Print the time
-    uint8_t hms = ubxDataStruct.hour; // Print the hours
+    uint8_t hms = ubxDataStruct->hour; // Print the hours
     if (hms < 10) Serial.print(F("0")); // Print a leading zero if required
     Serial.print(hms);
     Serial.print(F(":"));
-    hms = ubxDataStruct.min; // Print the minutes
+    hms = ubxDataStruct->min; // Print the minutes
     if (hms < 10) Serial.print(F("0")); // Print a leading zero if required
     Serial.print(hms);
     Serial.print(F(":"));
-    hms = ubxDataStruct.sec; // Print the seconds
+    hms = ubxDataStruct->sec; // Print the seconds
     if (hms < 10) Serial.print(F("0")); // Print a leading zero if required
     Serial.print(hms);
     Serial.print(F("."));
-    unsigned long millisecs = ubxDataStruct.iTOW % 1000; // Print the milliseconds
+    unsigned long millisecs = ubxDataStruct->iTOW % 1000; // Print the milliseconds
     if (millisecs < 100) Serial.print(F("0")); // Print the trailing zeros correctly
     if (millisecs < 10) Serial.print(F("0"));
     Serial.print(millisecs);
 
-    long latitude = ubxDataStruct.lat; // Print the latitude
+    long latitude = ubxDataStruct->lat; // Print the latitude
     Serial.print(F(" Lat: "));
     Serial.print(latitude);
 
-    long longitude = ubxDataStruct.lon; // Print the longitude
+    long longitude = ubxDataStruct->lon; // Print the longitude
     Serial.print(F(" Long: "));
     Serial.print(longitude);
     Serial.print(F(" (degrees * 10^-7)"));
 
-    long altitude = ubxDataStruct.hMSL; // Print the height above mean sea level
+    long altitude = ubxDataStruct->hMSL; // Print the height above mean sea level
     Serial.print(F(" Height above MSL: "));
     Serial.print(altitude);
     Serial.println(F(" (mm)"));
@@ -135,9 +135,9 @@ void setup()
 
   myGNSS.setNavigationFrequency(2); //Produce two solutions per second
 
-  myGNSS.setAutoPVTcallback(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata
+  myGNSS.setAutoPVTcallbackPtr(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata
 
-  myGNSS.setAutoHPPOSLLHcallback(&printHPdata); // Enable automatic NAV HPPOSLLH messages with callback to printHPdata
+  myGNSS.setAutoHPPOSLLHcallbackPtr(&printHPdata); // Enable automatic NAV HPPOSLLH messages with callback to printHPdata
 }
 
 void loop()

examples/ZED-F9P/Example17_NTRIPClient_With_GGA_Callback/Example17_NTRIPClient_With_GGA_Callback.ino

@@ -69,16 +69,16 @@ WiFiClient ntripClient; // The WiFi connection to the NTRIP server. This is glob
 //        |              /           _____ You can use any name you like for the struct
 //        |              |          /
 //        |              |          |
-void pushGPGGA(NMEA_GGA_data_t nmeaData)
+void pushGPGGA(NMEA_GGA_data_t *nmeaData)
 {
   //Provide the caster with our current position as needed
   if ((ntripClient.connected() == true) && (transmitLocation == true))
   {
     Serial.print(F("Pushing GGA to server: "));
-    Serial.print((const char *)nmeaData.nmea); // .nmea is printable (NULL-terminated) and already has \r\n on the end
+    Serial.print((const char *)nmeaData->nmea); // .nmea is printable (NULL-terminated) and already has \r\n on the end
 
     //Push our current GGA sentence to caster
-    ntripClient.print((const char *)nmeaData.nmea);
+    ntripClient.print((const char *)nmeaData->nmea);
   }
 }
 
@@ -91,26 +91,21 @@ void pushGPGGA(NMEA_GGA_data_t nmeaData)
 //        |                 /               _____ You can use any name you like for the struct
 //        |                 |              /
 //        |                 |              |
-void printPVTdata(UBX_NAV_PVT_data_t ubxDataStruct)
+void printPVTdata(UBX_NAV_PVT_data_t *ubxDataStruct)
 {
-  long latitude = ubxDataStruct.lat; // Print the latitude
+  double latitude = ubxDataStruct->lat; // Print the latitude
   Serial.print(F("Lat: "));
-  Serial.print(latitude / 10000000L);
+  Serial.print(latitude / 10000000.0, 7);
-  Serial.print(F("."));
-  Serial.print(abs(latitude % 10000000L));
 
-  long longitude = ubxDataStruct.lon; // Print the longitude
+  double longitude = ubxDataStruct->lon; // Print the longitude
   Serial.print(F("  Long: "));
-  Serial.print(longitude / 10000000L);
+  Serial.print(longitude / 10000000.0, 7);
-  Serial.print(F("."));
-  Serial.print(abs(longitude % 10000000L));
 
-  long altitude = ubxDataStruct.hMSL; // Print the height above mean sea level
+  double altitude = ubxDataStruct->hMSL; // Print the height above mean sea level
   Serial.print(F("  Height: "));
-  Serial.print(altitude);
+  Serial.print(altitude / 1000.0, 3);
-  Serial.print(F(" (mm)"));
 
-  uint8_t fixType = ubxDataStruct.fixType; // Print the fix type
+  uint8_t fixType = ubxDataStruct->fixType; // Print the fix type
   Serial.print(F("  Fix: "));
   Serial.print(fixType);
   if (fixType == 0)
@@ -128,7 +123,7 @@ void printPVTdata(UBX_NAV_PVT_data_t ubxDataStruct)
   else
     Serial.print(F(" (UNKNOWN)"));
 
-  uint8_t carrSoln = ubxDataStruct.flags.bits.carrSoln; // Print the carrier solution
+  uint8_t carrSoln = ubxDataStruct->flags.bits.carrSoln; // Print the carrier solution
   Serial.print(F("  Carrier Solution: "));
   Serial.print(carrSoln);
   if (carrSoln == 0)
@@ -140,7 +135,7 @@ void printPVTdata(UBX_NAV_PVT_data_t ubxDataStruct)
   else
     Serial.print(F(" (UNKNOWN)"));
 
-  uint32_t hAcc = ubxDataStruct.hAcc; // Print the horizontal accuracy estimate
+  uint32_t hAcc = ubxDataStruct->hAcc; // Print the horizontal accuracy estimate
   Serial.print(F("  Horizontal Accuracy Estimate: "));
   Serial.print(hAcc);
   Serial.print(F(" (mm)"));
@@ -159,9 +154,8 @@ void setup()
 
   while (myGNSS.begin() == false) //Connect to the Ublox module using Wire port
   {
-    Serial.println(F("u-blox GPS not detected at default I2C address. Please check wiring. Freezing."));
+    Serial.println(F("u-blox GPS not detected at default I2C address. Please check wiring."));
     delay(2000);
-    //while (1);
   }
   Serial.println(F("u-blox module connected"));
 
@@ -175,11 +169,11 @@ void setup()
   // Set the Main Talker ID to "GP". The NMEA GGA messages will be GPGGA instead of GNGGA
   myGNSS.setMainTalkerID(SFE_UBLOX_MAIN_TALKER_ID_GP);
 
-  myGNSS.setNMEAGPGGAcallback(&pushGPGGA); // Set up the callback for GPGGA
+  myGNSS.setNMEAGPGGAcallbackPtr(&pushGPGGA); // Set up the callback for GPGGA
 
   myGNSS.enableNMEAMessage(UBX_NMEA_GGA, COM_PORT_I2C, 10); // Tell the module to output GGA every 10 seconds
 
-  myGNSS.setAutoPVTcallback(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata so we can watch the carrier solution go to fixed
+  myGNSS.setAutoPVTcallbackPtr(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata so we can watch the carrier solution go to fixed
 
   //myGNSS.saveConfiguration(VAL_CFG_SUBSEC_IOPORT | VAL_CFG_SUBSEC_MSGCONF); //Optional: Save the ioPort and message settings to NVM
 

examples/ZED-F9P/Example18_PointPerfectClient/Example18_PointPerfectClient.ino

@@ -10,9 +10,9 @@
   It's confusing, but the Arduino is acting as a 'client' to the PointPerfect SSR correction service.
 
   You will need to have a valid u-blox Thingstream account and have a PointPerfect Thing and payed plan. 
-  Thingstream offers SSR corrections to SPARTN cabalble RTK receivers such as the u-blox ZED-F9 series 
+  Thingstream offers SSR corrections to SPARTN capable RTK receivers such as the u-blox ZED-F9 series 
-  in continental Europ and US. There Network is planned to be expanded to ther regions over next years. 
+  in continental Europe and US. Their Network is planned to be expanded to other regions over the next years. 
-  To see sign up go to https://portal.thingstream.io/app/location-services/things
+  To sign up, go to: https://portal.thingstream.io/app/location-services/things
 
   This is a proof of concept to show how to connect via MQTT to get SPARTN SSR correction. 
   Using WiFi for a rover is generally a bad idea because of limited WiFi range in the field. 
@@ -38,10 +38,10 @@
 */
 #include <WiFi.h>
 #include <WiFiClientSecure.h>
-#include <ArduinoMqttClient.h>  
+#include <ArduinoMqttClient.h> // Click here to get the library: http://librarymanager/All#ArduinoMqttClient
 #include "secrets.h"
 
-#include <SparkFun_u-blox_GNSS_Arduino_Library.h> //http://librarymanager/All#SparkFun_u-blox_GNSS
+#include <SparkFun_u-blox_GNSS_Arduino_Library.h> // Click here to get the library: http://librarymanager/All#SparkFun_u-blox_GNSS
 SFE_UBLOX_GNSS myGNSS;
     
 //Global variables

examples/ZED-F9P/Example19_LBand_Corrections_with_NEO-D9S/Example19_LBand_Corrections_with_NEO-D9S.ino

@@ -0,0 +1,212 @@
+/*
+  Use the NEO-D9S L-Band receiver to provide corrections to a ZED-F9x via UBX-RXM-PMP messages
+  By: SparkFun Electronics / Paul Clark
+  Based on original code by: u-blox AG / Michael Ammann
+  Date: February 7th, 2022
+  License: MIT. See license file for more information but you can
+  basically do whatever you want with this code.
+
+  This example shows how to obtain SPARTN correction data from a NEO-D9S L-Band receiver and push it over I2C to a ZED-F9x.
+
+  This is a proof of concept to show how the UBX-RXM-PMP corrections control the accuracy.
+
+  You will need a Thingstream PointPerfect account to be able to access the SPARTN Credentials (IP Dynamic Keys).
+  Copy and paste the Current Key and Next Key into secrets.h.
+
+  Feel like supporting open source hardware?
+  Buy a board from SparkFun!
+  ZED-F9P RTK2: https://www.sparkfun.com/products/16481
+  NEO-D9S: Coming soon!
+
+  Hardware Connections:
+  Use Qwiic cables to connect the NEO-D9S and ZED-F9x GNSS to your board
+  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 "secrets.h" // <- Copy and paste the Current Key and Next Key into secrets.h
+
+#include <SparkFun_u-blox_GNSS_Arduino_Library.h> //http://librarymanager/All#SparkFun_u-blox_GNSS
+SFE_UBLOX_GNSS myGNSS; // ZED-F9x
+SFE_UBLOX_GNSS myLBand; // NEO-D9S
+
+const uint32_t myLBandFreq = 1556290000; // Uncomment this line to use the US SPARTN 1.8 service
+//const uint32_t myLBandFreq = 1545260000; // Uncomment this line to use the EU SPARTN 1.8 service
+
+#define OK(ok) (ok ? F("  ->  OK") : F("  ->  ERROR!")) // Convert uint8_t into OK/ERROR
+
+//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+// Callback: pushRXMPMP will be called when new PMP data arrives
+// See u-blox_structs.h for the full definition of UBX_RXM_PMP_message_data_t
+//         _____  You can use any name you like for the callback. Use the same name when you call setRXMPMPmessageCallbackPtr
+//        /               _____  This _must_ be UBX_RXM_PMP_message_data_t
+//        |              /              _____ You can use any name you like for the struct
+//        |              |             /
+//        |              |             |
+void pushRXMPMP(UBX_RXM_PMP_message_data_t *pmpData)
+{
+  //Extract the raw message payload length
+  uint16_t payloadLen = ((uint16_t)pmpData->lengthMSB << 8) | (uint16_t)pmpData->lengthLSB;
+  Serial.print(F("New RXM-PMP data received. Message payload length is "));
+  Serial.print(payloadLen);
+  Serial.println(F(" Bytes. Pushing it to the GNSS..."));
+  
+  //Push the PMP data to the GNSS
+  //The payload length could be variable, so we need to push the header and payload, then checksum
+  myGNSS.pushRawData(&pmpData->sync1, (size_t)payloadLen + 6); // Push the sync chars, class, ID, length and payload
+  myGNSS.pushRawData(&pmpData->checksumA, (size_t)2); // Push the checksum bytes
+}
+
+//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+// Callback: printPVTdata will be called when new NAV PVT data arrives
+// See u-blox_structs.h for the full definition of UBX_NAV_PVT_data_t
+//         _____  You can use any name you like for the callback. Use the same name when you call setAutoPVTcallbackPtr
+//        /                  _____  This _must_ be UBX_NAV_PVT_data_t
+//        |                 /               _____ You can use any name you like for the struct
+//        |                 |              /
+//        |                 |              |
+void printPVTdata(UBX_NAV_PVT_data_t *ubxDataStruct)
+{
+  double latitude = ubxDataStruct->lat; // Print the latitude
+  Serial.print(F("Lat: "));
+  Serial.print(latitude / 10000000.0, 7);
+
+  double longitude = ubxDataStruct->lon; // Print the longitude
+  Serial.print(F("  Long: "));
+  Serial.print(longitude / 10000000.0, 7);
+
+  double altitude = ubxDataStruct->hMSL; // Print the height above mean sea level
+  Serial.print(F("  Height: "));
+  Serial.print(altitude / 1000.0, 3);
+
+  uint8_t fixType = ubxDataStruct->fixType; // Print the fix type
+  Serial.print(F("  Fix: "));
+  Serial.print(fixType);
+  if (fixType == 0)
+    Serial.print(F(" (None)"));
+  else if (fixType == 1)
+    Serial.print(F(" (Dead Reckoning)"));
+  else if (fixType == 2)
+    Serial.print(F(" (2D)"));
+  else if (fixType == 3)
+    Serial.print(F(" (3D)"));
+  else if (fixType == 3)
+    Serial.print(F(" (GNSS + Dead Reckoning)"));
+  else if (fixType == 5)
+    Serial.print(F(" (Time Only)"));
+  else
+    Serial.print(F(" (UNKNOWN)"));
+
+  uint8_t carrSoln = ubxDataStruct->flags.bits.carrSoln; // Print the carrier solution
+  Serial.print(F("  Carrier Solution: "));
+  Serial.print(carrSoln);
+  if (carrSoln == 0)
+    Serial.print(F(" (None)"));
+  else if (carrSoln == 1)
+    Serial.print(F(" (Floating)"));
+  else if (carrSoln == 2)
+    Serial.print(F(" (Fixed)"));
+  else
+    Serial.print(F(" (UNKNOWN)"));
+
+  uint32_t hAcc = ubxDataStruct->hAcc; // Print the horizontal accuracy estimate
+  Serial.print(F("  Horizontal Accuracy Estimate: "));
+  Serial.print(hAcc);
+  Serial.print(F(" (mm)"));
+
+  Serial.println();    
+}
+
+//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println(F("NEO-D9S SPARTN Corrections"));
+
+  Wire.begin(); //Start I2C
+
+  //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+  // Begin and configure the ZED-F9x
+
+  //myGNSS.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+  while (myGNSS.begin() == false) //Connect to the u-blox module using Wire port
+  {
+    Serial.println(F("u-blox GNSS module not detected at default I2C address. Please check wiring."));
+    delay(2000);
+  }
+  Serial.println(F("u-blox GNSS module connected"));
+
+  uint8_t ok = myGNSS.setI2COutput(COM_TYPE_UBX); //Turn off NMEA noise
+  if (ok) ok = myGNSS.setPortInput(COM_PORT_I2C, COM_TYPE_UBX | COM_TYPE_NMEA | COM_TYPE_SPARTN); //Be sure SPARTN input is enabled
+
+  if (ok) ok = myGNSS.setDGNSSConfiguration(SFE_UBLOX_DGNSS_MODE_FIXED); // Set the differential mode - ambiguities are fixed whenever possible
+
+  if (ok) ok = myGNSS.setNavigationFrequency(1); //Set output in Hz.
+  
+  if (ok) ok = myGNSS.setVal8(UBLOX_CFG_SPARTN_USE_SOURCE, 1); // use LBAND PMP message
+  
+  //Configure the SPARTN IP Dynamic Keys
+  //"When the receiver boots, the host should send 'current' and 'next' keys in one message." - Use setDynamicSPARTNKeys for this.
+  //"Every time the 'current' key is expired, 'next' takes its place."
+  //"Therefore the host should then retrieve the new 'next' key and send only that." - Use setDynamicSPARTNKey for this.
+  // The key can be provided in binary (uint8_t) format or in ASCII Hex (char) format, but in both cases keyLengthBytes _must_ represent the binary key length in bytes.
+  if (ok) ok = myGNSS.setDynamicSPARTNKeys(currentKeyLengthBytes, currentKeyGPSWeek, currentKeyGPSToW, currentDynamicKey,
+                                           nextKeyLengthBytes, nextKeyGPSWeek, nextKeyGPSToW, nextDynamicKey);
+
+  //if (ok) ok = myGNSS.saveConfiguration(VAL_CFG_SUBSEC_IOPORT | VAL_CFG_SUBSEC_MSGCONF); //Optional: Save the ioPort and message settings to NVM
+  
+  Serial.print(F("GNSS: configuration "));
+  Serial.println(OK(ok));
+
+  myGNSS.setAutoPVTcallbackPtr(&printPVTdata); // Enable automatic NAV PVT messages with callback to printPVTdata so we can watch the carrier solution go to fixed
+
+  //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+  // Begin and configure the NEO-D9S L-Band receiver
+
+  //myLBand.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+
+  while (myLBand.begin(Wire, 0x43) == false) //Connect to the u-blox NEO-D9S using Wire port. The D9S default I2C address is 0x43 (not 0x42)
+  {
+    Serial.println(F("u-blox NEO-D9S not detected at default I2C address. Please check wiring."));
+    delay(2000);
+  }
+  Serial.println(F("u-blox NEO-D9S connected"));
+
+          ok = myLBand.setVal32(UBLOX_CFG_PMP_CENTER_FREQUENCY,   myLBandFreq); // Default 1539812500 Hz
+  if (ok) ok = myLBand.setVal16(UBLOX_CFG_PMP_SEARCH_WINDOW,      2200);        // Default 2200 Hz
+  if (ok) ok = myLBand.setVal8(UBLOX_CFG_PMP_USE_SERVICE_ID,      0);           // Default 1 
+  if (ok) ok = myLBand.setVal16(UBLOX_CFG_PMP_SERVICE_ID,         21845);       // Default 50821
+  if (ok) ok = myLBand.setVal16(UBLOX_CFG_PMP_DATA_RATE,          2400);        // Default 2400 bps
+  if (ok) ok = myLBand.setVal8(UBLOX_CFG_PMP_USE_DESCRAMBLER,     1);           // Default 1
+  if (ok) ok = myLBand.setVal16(UBLOX_CFG_PMP_DESCRAMBLER_INIT,   26969);       // Default 23560
+  if (ok) ok = myLBand.setVal8(UBLOX_CFG_PMP_USE_PRESCRAMBLING,   0);           // Default 0
+  if (ok) ok = myLBand.setVal64(UBLOX_CFG_PMP_UNIQUE_WORD,        16238547128276412563ull); 
+  if (ok) ok = myLBand.setVal(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_I2C,   1); // Ensure UBX-RXM-PMP is enabled on the I2C port 
+  if (ok) ok = myLBand.setVal(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART1, 1); // Output UBX-RXM-PMP on UART1
+  if (ok) ok = myLBand.setVal(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART2, 1); // Output UBX-RXM-PMP on UART2
+  if (ok) ok = myLBand.setVal32(UBLOX_CFG_UART1_BAUDRATE,         38400); // match baudrate with ZED default
+  if (ok) ok = myLBand.setVal32(UBLOX_CFG_UART2_BAUDRATE,         38400); // match baudrate with ZED default
+  
+  Serial.print(F("L-Band: configuration "));
+  Serial.println(OK(ok));
+
+  myLBand.softwareResetGNSSOnly(); // Do a restart
+
+  myLBand.setRXMPMPmessageCallbackPtr(&pushRXMPMP); // Call pushRXMPMP when new PMP data arrives. Push it to the GNSS
+
+}
+
+//=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+
+void loop()
+{
+  myGNSS.checkUblox(); // Check for the arrival of new GNSS data and process it.
+  myGNSS.checkCallbacks(); // Check if any GNSS callbacks are waiting to be processed.
+
+  myLBand.checkUblox(); // Check for the arrival of new PMP data and process it.
+  myLBand.checkCallbacks(); // Check if any LBand callbacks are waiting to be processed.
+}

examples/ZED-F9P/Example19_LBand_Corrections_with_NEO-D9S/secrets.h

@@ -0,0 +1,24 @@
+// You can set the information below after signing up with the u-blox Thingstream portal 
+// and adding a new New PointPerfect Thing
+// https://portal.thingstream.io/app/location-services/things
+// In the new PointPerfect Thing, you go to the credentials tab and copy and paste the IP Dynamic Keys here.
+//
+// The keys are valid from a particular GPS Week Number and Time of Week.
+// Looking at the credentials tab, the current key expires 23:59 Feb 11th 2022.
+// This means the next key is valid _from_ Midnight Feb 12th 2022.
+// That is GPS Week 2196. The GPS Time of Week in seconds is 518418.
+// Working backwards, the current key became valid exactly 4 weeks earlier (Midnight Jan 15th 2022).
+//
+// See: https://www.labsat.co.uk/index.php/en/gps-time-calculator
+//
+// The keys are given as: 32 hexadecimal digits = 128 bits = 16 Bytes
+
+const uint8_t currentKeyLengthBytes =   16; 
+const char currentDynamicKey[] =        "f742bd6b7248043177dd649141d8fb0b";
+const uint16_t currentKeyGPSWeek =      2192;
+const uint32_t currentKeyGPSToW =       518418;
+
+const uint8_t nextKeyLengthBytes =      16; 
+const char nextDynamicKey[] =           "8206........................29f4";
+const uint16_t nextKeyGPSWeek =         2196;
+const uint32_t nextKeyGPSToW =          518418;

keys/NEO-D9S_InterfaceDescription_UBX-19048765_keys_sorted.txt

@@ -0,0 +1,151 @@
+0x1041000d
+0x10410013
+0x10510002
+0x10510003
+0x10520005
+0x10530005
+0x10530006
+0x10640002
+0x10640003
+0x10640005
+0x10640006
+0x10650001
+0x10650002
+0x10710001
+0x10720001
+0x10730001
+0x10740001
+0x10750001
+0x10760001
+0x10770001
+0x10780001
+0x10790001
+0x107a0001
+0x10a20001
+0x10a20002
+0x10a3002e
+0x10a3002f
+0x10a30030
+0x10a30031
+0x10a30032
+0x10a30033
+0x10a30034
+0x10a30035
+0x10b10014
+0x10b10016
+0x10b10019
+0x10c70001
+0x10c70002
+0x10d0000c
+0x10d0000d
+0x10d0000e
+0x20210003
+0x20410001
+0x20410002
+0x20410010
+0x20510001
+0x20520002
+0x20520003
+0x20520004
+0x20530002
+0x20530003
+0x20530004
+0x20640001
+0x20910187
+0x20910188
+0x20910189
+0x2091018a
+0x2091018b
+0x20910196
+0x20910197
+0x20910198
+0x20910199
+0x2091019a
+0x2091019b
+0x2091019c
+0x2091019d
+0x2091019e
+0x2091019f
+0x209101a0
+0x209101a1
+0x209101a2
+0x209101a3
+0x209101a4
+0x209101a5
+0x209101a6
+0x209101a7
+0x209101a8
+0x209101a9
+0x209101b4
+0x209101b5
+0x209101b6
+0x209101b7
+0x209101b8
+0x209101b9
+0x209101ba
+0x209101bb
+0x209101bc
+0x209101bd
+0x20910231
+0x20910232
+0x20910233
+0x20910234
+0x20910235
+0x20910259
+0x2091025a
+0x2091025b
+0x2091025c
+0x2091025d
+0x2091031d
+0x2091031e
+0x2091031f
+0x20910320
+0x20910321
+0x20920001
+0x20920002
+0x20920003
+0x20920004
+0x20920005
+0x20920006
+0x20920007
+0x20920008
+0x20920009
+0x2092000a
+0x20a20003
+0x20a20005
+0x20a30036
+0x20a30037
+0x20a30038
+0x20c70003
+0x20d0000b
+0x30210001
+0x30210002
+0x3065000a
+0x3065000b
+0x3065000c
+0x30a20004
+0x30b10012
+0x30b10013
+0x30b10015
+0x30b10017
+0x40520001
+0x40530001
+0x40b10011
+0x40d0000f
+0x5065000d
+0x5065000e
+0x5065000f
+0x50650010
+0x50650011
+0x50650012
+0x50650013
+0x50650014
+0x50650015
+0x50650016
+0x50650017
+0x50650018
+0x50b1001a
+0x50c70004
+0x50c70005
+0x50c70006
+0x50c70007

keys/u-blox-F9-HPG-1.30_InterfaceDescription_UBX-21046737_keys_sorted.txt

@@ -6,6 +6,9 @@
 0x10110013
 0x10110025
 0x10110061
+0x101100d7
+0x10170001
+0x10170002
 0x10220001
 0x10220002
 0x10220003
@@ -47,7 +50,6 @@
 0x10510003
 0x10520005
 0x10530005
-0x10530006
 0x10640002
 0x10640003
 0x10640005
@@ -57,30 +59,35 @@
 0x10710001
 0x10710002
 0x10710004
+0x10710005
 0x10720001
 0x10720002
 0x10720004
 0x10730001
 0x10730002
 0x10730004
+0x10730005
 0x10740001
 0x10740002
 0x10740004
 0x10750001
 0x10750002
 0x10750004
+0x10750005
 0x10760001
 0x10760002
 0x10760004
 0x10770001
 0x10770002
 0x10770004
+0x10770005
 0x10780001
 0x10780002
 0x10780004
 0x10790001
 0x10790002
 0x10790004
+0x10790005
 0x107a0001
 0x107a0002
 0x107a0004
@@ -115,6 +122,7 @@
 0x10de0002
 0x10de0003
 0x10de0004
+0x10f60009
 0x20030001
 0x20030002
 0x20030006
@@ -126,6 +134,7 @@
 0x2005000c
 0x20050023
 0x20050030
+0x20050035
 0x20090009
 0x20110011
 0x2011001c
@@ -259,6 +268,11 @@
 0x20910080
 0x20910081
 0x20910082
+0x20910083
+0x20910084
+0x20910085
+0x20910086
+0x20910087
 0x20910088
 0x20910089
 0x2091008a
@@ -539,6 +553,176 @@
 0x20910402
 0x20910403
 0x20910404
+0x20910415
+0x20910416
+0x20910417
+0x20910418
+0x20910419
+0x20910430
+0x20910431
+0x20910432
+0x20910433
+0x20910434
+0x20910435
+0x20910436
+0x20910437
+0x20910438
+0x20910439
+0x20910465
+0x20910466
+0x20910467
+0x20910468
+0x20910469
+0x20910475
+0x20910476
+0x20910477
+0x20910478
+0x20910479
+0x20910480
+0x20910481
+0x20910482
+0x20910483
+0x20910484
+0x20910485
+0x20910486
+0x20910487
+0x20910488
+0x20910489
+0x20910490
+0x20910491
+0x20910492
+0x20910493
+0x20910494
+0x20910495
+0x20910496
+0x20910497
+0x20910498
+0x20910499
+0x20910500
+0x20910501
+0x20910502
+0x20910503
+0x20910504
+0x20910505
+0x20910506
+0x20910507
+0x20910508
+0x20910509
+0x20910510
+0x20910511
+0x20910512
+0x20910513
+0x20910514
+0x20910515
+0x20910516
+0x20910517
+0x20910518
+0x20910519
+0x20910520
+0x20910521
+0x20910522
+0x20910523
+0x20910524
+0x20910525
+0x20910526
+0x20910527
+0x20910528
+0x20910529
+0x20910530
+0x20910531
+0x20910532
+0x20910533
+0x20910534
+0x20910535
+0x20910536
+0x20910537
+0x20910538
+0x20910539
+0x20910540
+0x20910541
+0x20910542
+0x20910543
+0x20910544
+0x20910545
+0x20910546
+0x20910547
+0x20910548
+0x20910549
+0x20910550
+0x20910551
+0x20910552
+0x20910553
+0x20910554
+0x20910555
+0x20910556
+0x20910557
+0x20910558
+0x20910559
+0x20910560
+0x20910561
+0x20910562
+0x20910563
+0x20910564
+0x20910565
+0x20910566
+0x20910567
+0x20910568
+0x20910569
+0x20910575
+0x20910576
+0x20910577
+0x20910578
+0x20910579
+0x20910605
+0x20910606
+0x20910607
+0x20910608
+0x20910609
+0x20910652
+0x20910653
+0x20910654
+0x20910655
+0x20910656
+0x20910657
+0x20910658
+0x20910659
+0x2091065a
+0x2091065b
+0x2091065c
+0x2091065d
+0x2091065e
+0x2091065f
+0x20910660
+0x20910661
+0x20910662
+0x20910663
+0x20910664
+0x20910665
+0x20910666
+0x20910667
+0x20910668
+0x20910669
+0x2091066a
+0x20910670
+0x20910671
+0x20910672
+0x20910673
+0x20910674
+0x2091067f
+0x20910680
+0x20910681
+0x20910682
+0x20910683
+0x2091069d
+0x2091069e
+0x2091069f
+0x209106a0
+0x209106a1
+0x209106b6
+0x209106b7
+0x209106b8
+0x209106b9
+0x209106ba
 0x20920001
 0x20920002
 0x20920003
@@ -562,6 +746,7 @@
 0x20a30054
 0x20a30055
 0x20a30056
+0x20a70001
 0x20c70003
 0x30050001
 0x30090001
@@ -575,6 +760,7 @@
 0x30210001
 0x30210002
 0x3025003b
+0x30370008
 0x3065000a
 0x3065000b
 0x3065000c
@@ -583,6 +769,8 @@
 0x30de0005
 0x30de0006
 0x30de0007
+0x30f6000a
+0x30f6000b
 0x40030003
 0x40030004
 0x40030005

keys/u-blox_config_keys_sorted.txt

@@ -24,6 +24,7 @@
 0x10110019
 0x10110025
 0x10110061
+0x101100d7
 0x10170001
 0x10170002
 0x10220001
@@ -140,8 +141,14 @@
 0x10a30033
 0x10a30034
 0x10a30035
+0x10b10014
+0x10b10016
+0x10b10019
 0x10c70001
 0x10c70002
+0x10d0000c
+0x10d0000d
+0x10d0000e
 0x10de0002
 0x10de0003
 0x10de0004
@@ -567,6 +574,11 @@
 0x2091031a
 0x2091031b
 0x2091031c
+0x2091031d
+0x2091031e
+0x2091031f
+0x20910320
+0x20910321
 0x20910336
 0x20910337
 0x20910338
@@ -632,6 +644,11 @@
 0x20910402
 0x20910403
 0x20910404
+0x20910415
+0x20910416
+0x20910417
+0x20910418
+0x20910419
 0x20910430
 0x20910431
 0x20910432
@@ -682,11 +699,21 @@
 0x20910507
 0x20910508
 0x20910509
+0x20910510
+0x20910511
+0x20910512
+0x20910513
+0x20910514
 0x20910515
 0x20910516
 0x20910517
 0x20910518
 0x20910519
+0x20910520
+0x20910521
+0x20910522
+0x20910523
+0x20910524
 0x20910525
 0x20910526
 0x20910527
@@ -732,6 +759,11 @@
 0x20910567
 0x20910568
 0x20910569
+0x20910575
+0x20910576
+0x20910577
+0x20910578
+0x20910579
 0x20910590
 0x20910591
 0x20910592
@@ -797,6 +829,16 @@
 0x2091068b
 0x2091068c
 0x2091068d
+0x2091069d
+0x2091069e
+0x2091069f
+0x209106a0
+0x209106a1
+0x209106b6
+0x209106b7
+0x209106b8
+0x209106b9
+0x209106ba
 0x20920001
 0x20920002
 0x20920003
@@ -820,7 +862,9 @@
 0x20a30054
 0x20a30055
 0x20a30056
+0x20a70001
 0x20c70003
+0x20d0000b
 0x30050001
 0x30060007
 0x3006000a
@@ -842,11 +886,16 @@
 0x30210001
 0x30210002
 0x3025003b
+0x30370008
 0x3065000a
 0x3065000b
 0x3065000c
 0x30930033
 0x30a20004
+0x30b10012
+0x30b10013
+0x30b10015
+0x30b10017
 0x30de0005
 0x30de0006
 0x30de0007
@@ -902,6 +951,8 @@
 0x40240053
 0x40520001
 0x40530001
+0x40b10011
+0x40d0000f
 0x40de0008
 0x5005002a
 0x5005002b
@@ -922,6 +973,7 @@
 0x50650016
 0x50650017
 0x50650018
+0x50b1001a
 0x50c70004
 0x50c70005
 0x50c70006

keywords.txt

@@ -26,10 +26,15 @@ UBX_NAV_VELECEF_data_t	KEYWORD1
 UBX_NAV_VELNED_data_t	KEYWORD1
 UBX_NAV_HPPOSECEF_data_t	KEYWORD1
 UBX_NAV_HPPOSLLH_data_t	KEYWORD1
+UBX_NAV_PVAT_data_t	KEYWORD1
 UBX_NAV_CLOCK_data_t	KEYWORD1
+UBX_NAV_SAT_data_t	KEYWORD1
 UBX_NAV_RELPOSNED_data_t	KEYWORD1
 UBX_NAV_TIMELS_data_t	KEYWORD1
+UBX_NAV_AOPSTATUS_data_t	KEYWORD1
 
+UBX_RXM_PMP_data_t	KEYWORD1
+UBX_RXM_PMP_message_data_t	KEYWORD1
 UBX_RXM_SFRBX_data_t	KEYWORD1
 UBX_RXM_RAWX_data_t	KEYWORD1
 
@@ -45,6 +50,8 @@ UBX_HNR_PVT_data_t	KEYWORD1
 UBX_HNR_ATT_data_t	KEYWORD1
 UBX_HNR_INS_data_t	KEYWORD1
 
+NMEA_GGA_data_t	KEYWORD1
+
 #######################################
 # Methods and Functions (KEYWORD2)
 #######################################
@@ -118,6 +125,7 @@ setUART2Output	KEYWORD2
 setUSBOutput	KEYWORD2
 setSPIOutput	KEYWORD2
 setNMEAOutputPort	KEYWORD2
+setOutputPort	KEYWORD2
 
 factoryReset	KEYWORD2
 hardReset	KEYWORD2
@@ -178,29 +186,38 @@ setAckAiding	KEYWORD2
 getAopCfg	KEYWORD2
 setAopCfg	KEYWORD2
 
+setDynamicSPARTNKey	KEYWORD2
+setDynamicSPARTNKeys	KEYWORD2
+
 createKey	KEYWORD2
 getVal	KEYWORD2
 getVal8	KEYWORD2
 getVal16	KEYWORD2
 getVal32	KEYWORD2
+getVal64	KEYWORD2
 setVal	KEYWORD2
 setVal8	KEYWORD2
 setVal16	KEYWORD2
 setVal32	KEYWORD2
+setVal64	KEYWORD2
 newCfgValset8	KEYWORD2
 newCfgValset16	KEYWORD2
 newCfgValset32	KEYWORD2
+newCfgValset64	KEYWORD2
 addCfgValset8	KEYWORD2
 addCfgValset16	KEYWORD2
 addCfgValset32	KEYWORD2
+addCfgValset64	KEYWORD2
 sendCfgValset8	KEYWORD2
 sendCfgValset16	KEYWORD2
 sendCfgValset32	KEYWORD2
+sendCfgValset64	KEYWORD2
 
 getNAVPOSECEF	KEYWORD2
 setAutoNAVPOSECEF	KEYWORD2
 setAutoNAVPOSECEFrate	KEYWORD2
 setAutoNAVPOSECEFcallback	KEYWORD2
+setAutoNAVPOSECEFcallbackPtr	KEYWORD2
 assumeAutoNAVPOSECEF	KEYWORD2
 initPacketUBXNAVPOSECEF	KEYWORD2
 flushNAVPOSECEF	KEYWORD2
@@ -210,6 +227,7 @@ getNAVSTATUS	KEYWORD2
 setAutoNAVSTATUS	KEYWORD2
 setAutoNAVSTATUSrate	KEYWORD2
 setAutoNAVSTATUScallback	KEYWORD2
+setAutoNAVSTATUScallbackPtr	KEYWORD2
 assumeAutoNAVSTATUS	KEYWORD2
 initPacketUBXNAVSTATUS	KEYWORD2
 flushNAVSTATUS	KEYWORD2
@@ -219,6 +237,7 @@ getDOP	KEYWORD2
 setAutoDOP	KEYWORD2
 setAutoDOPrate	KEYWORD2
 setAutoDOPcallback	KEYWORD2
+setAutoDOPcallbackPtr	KEYWORD2
 assumeAutoDOP	KEYWORD2
 initPacketUBXNAVDOP	KEYWORD2
 flushDOP	KEYWORD2
@@ -229,6 +248,7 @@ getNAVATT	KEYWORD2
 setAutoNAVATT	KEYWORD2
 setAutoNAVATTrate	KEYWORD2
 setAutoNAVATTcallback	KEYWORD2
+setAutoNAVATTcallbackPtr	KEYWORD2
 assumeAutoNAVATT	KEYWORD2
 initPacketUBXNAVATT	KEYWORD2
 flushNAVATT	KEYWORD2
@@ -238,6 +258,7 @@ getPVT	KEYWORD2
 setAutoPVT	KEYWORD2
 setAutoPVTrate	KEYWORD2
 setAutoPVTcallback	KEYWORD2
+setAutoPVTcallbackPtr	KEYWORD2
 assumeAutoPVT	KEYWORD2
 initPacketUBXNAVPVT	KEYWORD2
 flushPVT	KEYWORD2
@@ -247,6 +268,7 @@ getNAVODO	KEYWORD2
 setAutoNAVODO	KEYWORD2
 setAutoNAVODOrate	KEYWORD2
 setAutoNAVODOcallback	KEYWORD2
+setAutoNAVODOcallbackPtr	KEYWORD2
 assumeAutoNAVODO	KEYWORD2
 initPacketUBXNAVODO	KEYWORD2
 flushNAVODO	KEYWORD2
@@ -256,6 +278,7 @@ getNAVVELECEF	KEYWORD2
 setAutoNAVVELECEF	KEYWORD2
 setAutoNAVVELECEFrate	KEYWORD2
 setAutoNAVVELECEFcallback	KEYWORD2
+setAutoNAVVELECEFcallbackPtr	KEYWORD2
 assumeAutoNAVVELECEF	KEYWORD2
 initPacketUBXNAVVELECEF	KEYWORD2
 flushNAVVELECEF	KEYWORD2
@@ -265,6 +288,7 @@ getNAVVELNED	KEYWORD2
 setAutoNAVVELNED	KEYWORD2
 setAutoNAVVELNEDrate	KEYWORD2
 setAutoNAVVELNEDcallback	KEYWORD2
+setAutoNAVVELNEDcallbackPtr	KEYWORD2
 assumeAutoNAVVELNED	KEYWORD2
 initPacketUBXNAVVELNED	KEYWORD2
 flushNAVVELNED	KEYWORD2
@@ -274,6 +298,7 @@ getNAVHPPOSECEF	KEYWORD2
 setAutoNAVHPPOSECEF	KEYWORD2
 setAutoNAVHPPOSECEFrate	KEYWORD2
 setAutoNAVHPPOSECEFcallback	KEYWORD2
+setAutoNAVHPPOSECEFcallbackPtr	KEYWORD2
 assumeAutoNAVHPPOSECEF	KEYWORD2
 initPacketUBXNAVHPPOSECEF	KEYWORD2
 flushNAVHPPOSECEF	KEYWORD2
@@ -283,6 +308,7 @@ getHPPOSLLH	KEYWORD2
 setAutoHPPOSLLH	KEYWORD2
 setAutoHPPOSLLHrate	KEYWORD2
 setAutoHPPOSLLHcallback	KEYWORD2
+setAutoHPPOSLLHcallbackPtr	KEYWORD2
 assumeAutoHPPOSLLH	KEYWORD2
 initPacketUBXNAVHPPOSLLH	KEYWORD2
 flushHPPOSLLH	KEYWORD2
@@ -293,6 +319,7 @@ setAutoNAVPVAT	KEYWORD2
 setAutoNAVPVAT	KEYWORD2
 setAutoNAVPVATrate	KEYWORD2
 setAutoNAVPVATcallback	KEYWORD2
+setAutoNAVPVATcallbackPtr	KEYWORD2
 assumeAutoNAVPVAT	KEYWORD2
 flushNAVPVAT	KEYWORD2
 logNAVPVAT	KEYWORD2
@@ -301,6 +328,7 @@ getNAVCLOCK	KEYWORD2
 setAutoNAVCLOCK	KEYWORD2
 setAutoNAVCLOCKrate	KEYWORD2
 setAutoNAVCLOCKcallback	KEYWORD2
+setAutoNAVCLOCKcallbackPtr	KEYWORD2
 assumeAutoNAVCLOCK	KEYWORD2
 initPacketUBXNAVCLOCK	KEYWORD2
 flushNAVCLOCK	KEYWORD2
@@ -318,6 +346,7 @@ getNAVSAT	KEYWORD2
 setAutoNAVSAT	KEYWORD2
 setAutoNAVSATrate	KEYWORD2
 setAutoNAVSATcallback	KEYWORD2
+setAutoNAVSATcallbackPtr	KEYWORD2
 assumeAutoNAVSAT	KEYWORD2
 initPacketUBXNAVSAT	KEYWORD2
 flushNAVSAT	KEYWORD2
@@ -327,6 +356,7 @@ getRELPOSNED	KEYWORD2
 setAutoRELPOSNED	KEYWORD2
 setAutoRELPOSNEDrate	KEYWORD2
 setAutoRELPOSNEDcallback	KEYWORD2
+setAutoRELPOSNEDcallbackPtr	KEYWORD2
 assumeAutoRELPOSNED	KEYWORD2
 initPacketUBXNAVRELPOSNED	KEYWORD2
 flushNAVRELPOSNED	KEYWORD2
@@ -336,15 +366,20 @@ getAOPSTATUS	KEYWORD2
 setAutoAOPSTATUS	KEYWORD2
 setAutoAOPSTATUSrate	KEYWORD2
 setAutoAOPSTATUScallback	KEYWORD2
+setAutoAOPSTATUScallbackPtr	KEYWORD2
 assumeAutoAOPSTATUS	KEYWORD2
 initPacketUBXAOPSTATUS	KEYWORD2
 flushAOPSTATUS	KEYWORD2
 logAOPSTATUS	KEYWORD2
 
+setRXMPMPcallbackPtr	KEYWORD2
+setRXMPMPmessageCallbackPtr	KEYWORD2
+
 getRXMSFRBX	KEYWORD2
 setAutoRXMSFRBX	KEYWORD2
 setAutoRXMSFRBXrate	KEYWORD2
 setAutoRXMSFRBXcallback	KEYWORD2
+setAutoRXMSFRBXcallbackPtr	KEYWORD2
 assumeAutoRXMSFRBX	KEYWORD2
 initPacketUBXRXMSFRBX	KEYWORD2
 flushRXMSFRBX	KEYWORD2
@@ -354,6 +389,7 @@ getRXMRAWX	KEYWORD2
 setAutoRXMRAWX	KEYWORD2
 setAutoRXMRAWXrate	KEYWORD2
 setAutoRXMRAWXcallback	KEYWORD2
+setAutoRXMRAWXcallbackPtr	KEYWORD2
 assumeAutoRXMRAWX	KEYWORD2
 initPacketUBXRXMRAWX	KEYWORD2
 flushRXMRAWX	KEYWORD2
@@ -363,6 +399,7 @@ getTIMTM2	KEYWORD2
 setAutoTIMTM2	KEYWORD2
 setAutoTIMTM2rate	KEYWORD2
 setAutoTIMTM2callback	KEYWORD2
+setAutoTIMTM2callbackPtr	KEYWORD2
 assumeAutoTIMTM2	KEYWORD2
 initPacketUBXTIMTM2	KEYWORD2
 flushTIMTM2	KEYWORD2
@@ -373,6 +410,7 @@ getESFALG	KEYWORD2
 setAutoESFALG	KEYWORD2
 setAutoESFALGrate	KEYWORD2
 setAutoESFALGcallback	KEYWORD2
+setAutoESFALGcallbackPtr	KEYWORD2
 assumeAutoESFALG	KEYWORD2
 initPacketUBXESFALG	KEYWORD2
 flushESFALG	KEYWORD2
@@ -383,6 +421,7 @@ getESFSTATUS	KEYWORD2
 setAutoESFSTATUS	KEYWORD2
 setAutoESFSTATUSrate	KEYWORD2
 setAutoESFSTATUScallback	KEYWORD2
+setAutoESFSTATUScallbackPtr	KEYWORD2
 assumeAutoESFSTATUS	KEYWORD2
 initPacketUBXESFSTATUS	KEYWORD2
 flushESFSTATUS	KEYWORD2
@@ -393,6 +432,7 @@ getESFINS	KEYWORD2
 setAutoESFINS	KEYWORD2
 setAutoESFINSrate	KEYWORD2
 setAutoESFINScallback	KEYWORD2
+setAutoESFINScallbackPtr	KEYWORD2
 assumeAutoESFINS	KEYWORD2
 initPacketUBXESFINS	KEYWORD2
 flushESFINS	KEYWORD2
@@ -403,6 +443,7 @@ getESFMEAS	KEYWORD2
 setAutoESFMEAS	KEYWORD2
 setAutoESFMEASrate	KEYWORD2
 setAutoESFMEAScallback	KEYWORD2
+setAutoESFMEAScallbackPtr	KEYWORD2
 assumeAutoESFMEAS	KEYWORD2
 initPacketUBXESFMEAS	KEYWORD2
 flushESFMEAS	KEYWORD2
@@ -413,6 +454,7 @@ getESFRAW	KEYWORD2
 setAutoESFRAW	KEYWORD2
 setAutoESFRAWrate	KEYWORD2
 setAutoESFRAWcallback	KEYWORD2
+setAutoESFRAWcallbackPtr	KEYWORD2
 assumeAutoESFRAW	KEYWORD2
 initPacketUBXESFRAW	KEYWORD2
 flushESFRAW	KEYWORD2
@@ -423,6 +465,7 @@ getHNRATT	KEYWORD2
 setAutoHNRATT	KEYWORD2
 setAutoHNRATTrate	KEYWORD2
 setAutoHNRATTcallback	KEYWORD2
+setAutoHNRATTcallbackPtr	KEYWORD2
 assumeAutoHNRATT	KEYWORD2
 initPacketUBXHNRATT	KEYWORD2
 flushHNRATT	KEYWORD2
@@ -433,6 +476,7 @@ getHNRINS	KEYWORD2
 setAutoHNRINS	KEYWORD2
 setAutoHNRINSrate	KEYWORD2
 setAutoHNRINScallback	KEYWORD2
+setAutoHNRINScallbackPtr	KEYWORD2
 assumeAutoHNRINS	KEYWORD2
 initPacketUBXHNRINS	KEYWORD2
 flushHNRINS	KEYWORD2
@@ -442,6 +486,7 @@ getHNRPVT	KEYWORD2
 setAutoHNRPVT	KEYWORD2
 setAutoHNRPVTrate	KEYWORD2
 setAutoHNRPVTcallback	KEYWORD2
+setAutoHNRPVTcallbackPtr	KEYWORD2
 assumeAutoHNRPVT	KEYWORD2
 initPacketUBXHNRPVT	KEYWORD2
 flushHNRPVT	KEYWORD2
@@ -565,8 +610,10 @@ setHighPrecisionMode	KEYWORD2
 
 getLatestNMEAGPGGA	KEYWORD2
 setNMEAGPGGAcallback	KEYWORD2
+setNMEAGPGGAcallbackPtr	KEYWORD2
 getLatestNMEAGNGGA	KEYWORD2
 setNMEAGNGGAcallback	KEYWORD2
+setNMEAGNGGAcallbackPtr	KEYWORD2
 
 extractLong	KEYWORD2
 extractSignedLong	KEYWORD2

library.properties

@@ -1,5 +1,5 @@
 name=SparkFun u-blox GNSS Arduino Library
-version=2.2.0
+version=2.2.1
 author=SparkFun Electronics <techsupport@sparkfun.com>
 maintainer=SparkFun Electronics <sparkfun.com>
 sentence=Library for I2C, Serial and SPI Communication with u-blox GNSS modules<br/><br/>

src/SparkFun_u-blox_GNSS_Arduino_Library.h

@@ -338,6 +338,8 @@ const uint8_t UBX_MON_PATCH = 0x27; //Output information about installed patches
 const uint8_t UBX_MON_RF = 0x38;    // RF information
 const uint8_t UBX_MON_RXBUF = 0x07; // Receiver Buffer Status
 const uint8_t UBX_MON_RXR = 0x21;   // Receiver Status Information
+const uint8_t UBX_MON_SPAN = 0x31;  // Signal characteristics
+const uint8_t UBX_MON_SYS = 0x39;   // Current system performance information
 const uint8_t UBX_MON_TXBUF = 0x08; // Transmitter Buffer Status. Used for query tx buffer size/state.
 const uint8_t UBX_MON_VER = 0x04;   // Receiver/Software Version. Used for obtaining Protocol Version.
 
@@ -352,6 +354,7 @@ const uint8_t UBX_NAV_HPPOSECEF = 0x13; //High Precision Position Solution in EC
 const uint8_t UBX_NAV_HPPOSLLH = 0x14;  // High Precision Geodetic Position Solution. Used for obtaining lat/long/alt in high precision
 const uint8_t UBX_NAV_ODO = 0x09;       // Odometer Solution
 const uint8_t UBX_NAV_ORB = 0x34;       // GNSS Orbit Database Info
+const uint8_t UBX_NAV_PL = 0x62;        // Protection Level Information
 const uint8_t UBX_NAV_POSECEF = 0x01;   // Position Solution in ECEF
 const uint8_t UBX_NAV_POSLLH = 0x02;    // Geodetic Position Solution
 const uint8_t UBX_NAV_PVT = 0x07;       // All the things! Position, velocity, time, PDOP, height, h/v accuracies, number of satellites. Navigation Position Velocity Time Solution.
@@ -374,13 +377,16 @@ const uint8_t UBX_NAV_AOPSTATUS = 0x60; //AssistNow Autonomous status
 
 // Class: RXM
 // The following are used to configure the RXM UBX messages (receiver manager messages). Descriptions from UBX messages overview (ZED_F9P Interface Description Document page 36)
+const uint8_t UBX_RXM_COR = 0x34;       // Differential correction input status
 const uint8_t UBX_RXM_MEASX = 0x14;     // Satellite Measurements for RRLP
-const uint8_t UBX_RXM_PMREQ = 0x41; //Requests a Power Management task (two differenent packet sizes)
+const uint8_t UBX_RXM_PMP = 0x72;       // PMP raw data (NEO-D9S) (two different versions) (packet size for version 0x01 is variable)
+const uint8_t UBX_RXM_PMREQ = 0x41;     // Requests a Power Management task (two different packet sizes)
 const uint8_t UBX_RXM_RAWX = 0x15;      // Multi-GNSS Raw Measurement Data
 const uint8_t UBX_RXM_RLM = 0x59;       // Galileo SAR Short-RLM report (two different packet sizes)
 const uint8_t UBX_RXM_RTCM = 0x32;      // RTCM input status
 const uint8_t UBX_RXM_SFRBX = 0x13;     // Broadcast Navigation Data Subframe
 const uint8_t UBX_RXM_SPARTN = 0x33;    // SPARTN input status
+const uint8_t UBX_RXM_SPARTNKEY = 0x36; // Poll/transfer dynamic SPARTN keys
 
 // Class: SEC
 // The following are used to configure the SEC UBX messages (security feature messages). Descriptions from UBX messages overview (ZED_F9P Interface Description Document page 36)
@@ -620,7 +626,7 @@ public:
 #endif
 
   // New in v2.0: allow the payload size for packetCfg to be changed
-	void setPacketCfgPayloadSize(size_t payloadSize); // Set packetCfgPayloadSize
+  bool setPacketCfgPayloadSize(size_t payloadSize); // Set packetCfgPayloadSize
 
   // Begin communication with the GNSS. Advanced users can assume success if required. Useful if the port is already outputting messages at high navigation rate.
   // Begin will then return true if "signs of life" have been seen: reception of _any_ valid UBX packet or _any_ valid NMEA header.
@@ -803,6 +809,7 @@ public:
   bool setUSBOutput(uint8_t comSettings, uint16_t maxWait = defaultMaxWait);   // Configure USB port to output UBX, NMEA, RTCM3, SPARTN or a combination thereof
   bool setSPIOutput(uint8_t comSettings, uint16_t maxWait = defaultMaxWait);   // Configure SPI port to output UBX, NMEA, RTCM3, SPARTN or a combination thereof
   void setNMEAOutputPort(Stream &nmeaOutputPort);                              // Sets the internal variable for the port to direct NMEA characters to
+  void setOutputPort(Stream &outputPort);                                      // Sets the internal variable for the port to direct ALL characters to
 
   // Reset to defaults
 
@@ -891,6 +898,18 @@ public:
   uint8_t getAopCfg(uint16_t maxWait = defaultMaxWait);                                         // Get the AssistNow Autonomous configuration (aopCfg) - returns 255 if the sendCommand fails
   bool setAopCfg(uint8_t aopCfg, uint16_t aopOrbMaxErr = 0, uint16_t maxWait = defaultMaxWait); // Set the aopCfg byte and the aopOrdMaxErr word
 
+  // SPARTN dynamic keys
+  //"When the receiver boots, the host should send 'current' and 'next' keys in one message." - Use setDynamicSPARTNKeys for this.
+  //"Every time the 'current' key is expired, 'next' takes its place."
+  //"Therefore the host should then retrieve the new 'next' key and send only that." - Use setDynamicSPARTNKey for this.
+  // The key can be provided in binary (uint8_t) format or in ASCII Hex (char) format, but in both cases keyLengthBytes _must_ represent the binary key length in bytes.
+  bool setDynamicSPARTNKey(uint8_t keyLengthBytes, uint16_t validFromWno, uint32_t validFromTow, const char *key);
+  bool setDynamicSPARTNKey(uint8_t keyLengthBytes, uint16_t validFromWno, uint32_t validFromTow, const uint8_t *key);
+  bool setDynamicSPARTNKeys(uint8_t keyLengthBytes1, uint16_t validFromWno1, uint32_t validFromTow1, const char *key1,
+                            uint8_t keyLengthBytes2, uint16_t validFromWno2, uint32_t validFromTow2, const char *key2);
+  bool setDynamicSPARTNKeys(uint8_t keyLengthBytes1, uint16_t validFromWno1, uint32_t validFromTow1, const uint8_t *key1,
+                            uint8_t keyLengthBytes2, uint16_t validFromWno2, uint32_t validFromTow2, const uint8_t *key2);
+
   // General configuration (used only on protocol v27 and higher - ie, ZED-F9P)
 
   // It is probably safe to assume that users of the ZED-F9P will be using I2C / Qwiic.
@@ -900,22 +919,28 @@ public:
   uint8_t getVal8(uint32_t keyID, uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = 250);                              // Returns the value at a given key location
   uint16_t getVal16(uint32_t keyID, uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = 250);                            // Returns the value at a given key location
   uint32_t getVal32(uint32_t keyID, uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = 250);                            // Returns the value at a given key location
+  uint64_t getVal64(uint32_t keyID, uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = 250);                            // Returns the value at a given key location
   uint8_t getVal8(uint16_t group, uint16_t id, uint8_t size, uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = 250);   // Returns the value at a given group/id/size location
   uint16_t getVal16(uint16_t group, uint16_t id, uint8_t size, uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = 250); // Returns the value at a given group/id/size location
   uint32_t getVal32(uint16_t group, uint16_t id, uint8_t size, uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = 250); // Returns the value at a given group/id/size location
+  uint64_t getVal64(uint16_t group, uint16_t id, uint8_t size, uint8_t layer = VAL_LAYER_RAM, uint16_t maxWait = 250); // Returns the value at a given group/id/size location
   uint8_t setVal(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 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 setVal64(uint32_t keyID, uint64_t value, uint8_t layer = VAL_LAYER_ALL, uint16_t maxWait = 250);             // Sets the 64-bit value at a given group/id/size location
   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 newCfgValset64(uint32_t keyID, uint64_t value, uint8_t layer = VAL_LAYER_ALL);                               // Define a new UBX-CFG-VALSET with the given KeyID and 64-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
+  uint8_t addCfgValset64(uint32_t keyID, uint64_t value);                                                              // Add a new KeyID and 64-bit value to an existing UBX-CFG-VALSET ubxPacket
   uint8_t sendCfgValset8(uint32_t keyID, uint8_t value, uint16_t maxWait = 250);                                       // Add the final KeyID and 8-bit value to an existing UBX-CFG-VALSET ubxPacket and send it
   uint8_t sendCfgValset16(uint32_t keyID, uint16_t value, uint16_t maxWait = 250);                                     // Add the final KeyID and 16-bit value to an existing UBX-CFG-VALSET ubxPacket and send it
   uint8_t sendCfgValset32(uint32_t keyID, uint32_t value, uint16_t maxWait = 250);                                     // Add the final KeyID and 32-bit value to an existing UBX-CFG-VALSET ubxPacket and send it
+  uint8_t sendCfgValset64(uint32_t keyID, uint64_t value, uint16_t maxWait = 250);                                     // Add the final KeyID and 64-bit value to an existing UBX-CFG-VALSET ubxPacket and send it
 
   // get and set functions for all of the "automatic" message processing
 
@@ -931,6 +956,7 @@ public:
   bool setAutoNAVPOSECEF(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                               // Enable/disable automatic POSECEF 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
   bool setAutoNAVPOSECEFrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                    // Set the rate for automatic POSECEF reports
   bool setAutoNAVPOSECEFcallback(void (*callbackPointer)(UBX_NAV_POSECEF_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic POSECEF reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoNAVPOSECEFcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_POSECEF_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic POSECEF reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoNAVPOSECEF(bool enabled, bool implicitUpdate = true);                                                        // In case no config access to the GPS is possible and POSECEF is send cyclically already
   void flushNAVPOSECEF();                                                                                                     // Mark all the data as read/stale
   void logNAVPOSECEF(bool enabled = true);                                                                                    // Log data to file buffer
@@ -940,6 +966,7 @@ public:
   bool setAutoNAVSTATUS(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                              // Enable/disable automatic STATUS 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
   bool setAutoNAVSTATUSrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                   // Set the rate for automatic STATUS reports
   bool setAutoNAVSTATUScallback(void (*callbackPointer)(UBX_NAV_STATUS_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic STATUS reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoNAVSTATUScallbackPtr(void (*callbackPointerPtr)(UBX_NAV_STATUS_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic STATUS reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoNAVSTATUS(bool enabled, bool implicitUpdate = true);                                                       // In case no config access to the GPS is possible and STATUS is send cyclically already
   void flushNAVSTATUS();                                                                                                    // Mark all the data as read/stale
   void logNAVSTATUS(bool enabled = true);                                                                                   // Log data to file buffer
@@ -949,6 +976,7 @@ public:
   bool setAutoDOP(bool enabled, bool 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
   bool setAutoDOPrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic DOP reports
   bool setAutoDOPcallback(void (*callbackPointer)(UBX_NAV_DOP_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic DOP reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoDOPcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_DOP_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic DOP reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoDOP(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and DOP is send cyclically already
   void flushDOP();                                                                                                 // Mark all the DOP data as read/stale
   void logNAVDOP(bool enabled = true);                                                                             // Log data to file buffer
@@ -959,6 +987,7 @@ public:
   bool setAutoNAVATT(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic vehicle attitude 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
   bool setAutoNAVATTrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic ATT reports
   bool setAutoNAVATTcallback(void (*callbackPointer)(UBX_NAV_ATT_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic ATT reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoNAVATTcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_ATT_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic ATT reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoNAVATT(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and vehicle attitude is send cyclically already
   void flushNAVATT();                                                                                                 // Mark all the data as read/stale
   void logNAVATT(bool enabled = true);                                                                                // Log data to file buffer
@@ -968,6 +997,7 @@ public:
   bool setAutoPVT(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic PVT 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
   bool setAutoPVTrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic PVT reports
   bool setAutoPVTcallback(void (*callbackPointer)(UBX_NAV_PVT_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic PVT reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoPVTcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_PVT_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic PVT reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoPVT(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and PVT is send cyclically already
   void flushPVT();                                                                                                 // Mark all the PVT data as read/stale
   void logNAVPVT(bool enabled = true);                                                                             // Log data to file buffer
@@ -977,6 +1007,7 @@ public:
   bool setAutoNAVODO(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic ODO 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
   bool setAutoNAVODOrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic ODO reports
   bool setAutoNAVODOcallback(void (*callbackPointer)(UBX_NAV_ODO_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic ODO reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoNAVODOcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_ODO_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic ODO reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoNAVODO(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and ODO is send cyclically already
   void flushNAVODO();                                                                                                 // Mark all the data as read/stale
   void logNAVODO(bool enabled = true);                                                                                // Log data to file buffer
@@ -986,6 +1017,7 @@ public:
   bool setAutoNAVVELECEF(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                               // Enable/disable automatic VELECEF 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
   bool setAutoNAVVELECEFrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                    // Set the rate for automatic VELECEF reports
   bool setAutoNAVVELECEFcallback(void (*callbackPointer)(UBX_NAV_VELECEF_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic VELECEF reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoNAVVELECEFcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_VELECEF_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic VELECEF reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoNAVVELECEF(bool enabled, bool implicitUpdate = true);                                                        // In case no config access to the GPS is possible and VELECEF is send cyclically already
   void flushNAVVELECEF();                                                                                                     // Mark all the data as read/stale
   void logNAVVELECEF(bool enabled = true);                                                                                    // Log data to file buffer
@@ -995,6 +1027,7 @@ public:
   bool setAutoNAVVELNED(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                              // Enable/disable automatic VELNED 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
   bool setAutoNAVVELNEDrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                   // Set the rate for automatic VELNED reports
   bool setAutoNAVVELNEDcallback(void (*callbackPointer)(UBX_NAV_VELNED_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic VELNED reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoNAVVELNEDcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_VELNED_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic VELNED reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoNAVVELNED(bool enabled, bool implicitUpdate = true);                                                       // In case no config access to the GPS is possible and VELNED is send cyclically already
   void flushNAVVELNED();                                                                                                    // Mark all the data as read/stale
   void logNAVVELNED(bool enabled = true);                                                                                   // Log data to file buffer
@@ -1004,6 +1037,7 @@ public:
   bool setAutoNAVHPPOSECEF(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                                 // Enable/disable automatic HPPOSECEF 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
   bool setAutoNAVHPPOSECEFrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                      // Set the rate for automatic HPPOSECEF reports
   bool setAutoNAVHPPOSECEFcallback(void (*callbackPointer)(UBX_NAV_HPPOSECEF_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic HPPOSECEF reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoNAVHPPOSECEFcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_HPPOSECEF_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic HPPOSECEF reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoNAVHPPOSECEF(bool enabled, bool implicitUpdate = true);                                                          // In case no config access to the GPS is possible and HPPOSECEF is send cyclically already
   void flushNAVHPPOSECEF();                                                                                                       // Mark all the data as read/stale
   void logNAVHPPOSECEF(bool enabled = true);                                                                                      // Log data to file buffer
@@ -1013,6 +1047,7 @@ public:
   bool setAutoHPPOSLLH(bool enabled, bool 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
   bool setAutoHPPOSLLHrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                     // Set the rate for automatic HPPOSLLH reports
   bool setAutoHPPOSLLHcallback(void (*callbackPointer)(UBX_NAV_HPPOSLLH_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic HPPOSLLH reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoHPPOSLLHcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_HPPOSLLH_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic HPPOSLLH reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoHPPOSLLH(bool enabled, bool implicitUpdate = true);                                                         // In case no config access to the GPS is possible and HPPOSLLH is send cyclically already
   void flushHPPOSLLH();                                                                                                      // Mark all the HPPPOSLLH data as read/stale. This is handy to get data alignment after CRC failure
   void logNAVHPPOSLLH(bool enabled = true);                                                                                  // Log data to file buffer
@@ -1022,6 +1057,7 @@ public:
   bool setAutoNAVPVAT(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                            // Enable/disable automatic PVAT 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
   bool setAutoNAVPVATrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                 // Set the rate for automatic PVAT reports
   bool setAutoNAVPVATcallback(void (*callbackPointer)(UBX_NAV_PVAT_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic PVAT reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoNAVPVATcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_PVAT_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic PVAT reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoNAVPVAT(bool enabled, bool implicitUpdate = true);                                                     // In case no config access to the GPS is possible and PVAT is send cyclically already
   void flushNAVPVAT();                                                                                                  // Mark all the PVAT data as read/stale
   void logNAVPVAT(bool enabled = true);                                                                                 // Log data to file buffer
@@ -1031,6 +1067,7 @@ public:
   bool setAutoNAVCLOCK(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                             // Enable/disable automatic clock 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
   bool setAutoNAVCLOCKrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                  // Set the rate for automatic CLOCK reports
   bool setAutoNAVCLOCKcallback(void (*callbackPointer)(UBX_NAV_CLOCK_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic CLOCK reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoNAVCLOCKcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_CLOCK_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic CLOCK reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoNAVCLOCK(bool enabled, bool implicitUpdate = true);                                                      // In case no config access to the GPS is possible and clock is send cyclically already
   void flushNAVCLOCK();                                                                                                   // Mark all the data as read/stale
   void logNAVCLOCK(bool enabled = true);                                                                                  // Log data to file buffer
@@ -1046,6 +1083,7 @@ public:
   bool setAutoNAVSAT(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic NAVSAT 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
   bool setAutoNAVSATrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic NAVSAT reports
   bool setAutoNAVSATcallback(void (*callbackPointer)(UBX_NAV_SAT_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic NAVSAT reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoNAVSATcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_SAT_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic NAVSAT reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoNAVSAT(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and NAVSAT is send cyclically already
   void flushNAVSAT();                                                                                                 // Mark all the NAVSAT data as read/stale
   void logNAVSAT(bool enabled = true);                                                                                // Log data to file buffer
@@ -1055,6 +1093,7 @@ public:
   bool setAutoRELPOSNED(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                                 // Enable/disable automatic RELPOSNED, 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
   bool setAutoRELPOSNEDrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                      // Set the rate for automatic RELPOSNEDreports
   bool setAutoRELPOSNEDcallback(void (*callbackPointer)(UBX_NAV_RELPOSNED_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic RELPOSNED reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoRELPOSNEDcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_RELPOSNED_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic RELPOSNED reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoRELPOSNED(bool enabled, bool implicitUpdate = true);                                                          // In case no config access to the GPS is possible and RELPOSNED is send cyclically already
   void flushNAVRELPOSNED();                                                                                                    // Mark all the data as read/stale
   void logNAVRELPOSNED(bool enabled = true);                                                                                   // Log data to file buffer
@@ -1064,17 +1103,26 @@ public:
   bool setAutoAOPSTATUS(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                                 // Enable/disable automatic AOPSTATUS 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
   bool setAutoAOPSTATUSrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                      // Set the rate for automatic AOPSTATUS reports
   bool setAutoAOPSTATUScallback(void (*callbackPointer)(UBX_NAV_AOPSTATUS_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic AOPSTATUS reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoAOPSTATUScallbackPtr(void (*callbackPointerPtr)(UBX_NAV_AOPSTATUS_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic AOPSTATUS reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoAOPSTATUS(bool enabled, bool implicitUpdate = true);                                                          // In case no config access to the GPS is possible and AOPSTATUS is send cyclically already
   void flushAOPSTATUS();                                                                                                       // Mark all the AOPSTATUS data as read/stale
   void logAOPSTATUS(bool enabled = true);                                                                                      // Log data to file buffer
 
   // Receiver Manager Messages (RXM)
 
+  // Configure a callback for the UBX-RXM-PMP messages produced by the NEO-D9S
+  // Note: on the NEO-D9S, the UBX-RXM-PMP messages are enabled by default on all ports.
+  //       You can disable them by calling (e.g.) setVal8(UBLOX_CFG_MSGOUT_UBX_RXM_PMP_I2C, 0)
+  //       The NEO-D9S does not support UBX-CFG-MSG
+  bool setRXMPMPcallbackPtr(void (*callbackPointerPtr)(UBX_RXM_PMP_data_t *));                // Callback receives a pointer to the data, instead of _all_ the data. Much kinder on the stack!
+  bool setRXMPMPmessageCallbackPtr(void (*callbackPointerPtr)(UBX_RXM_PMP_message_data_t *)); // Use this if you want all of the PMP message (including sync chars, checksum, etc.) to push to a GNSS
+
   bool getRXMSFRBX(uint16_t maxWait = defaultMaxWait);                                                                    // RXM SFRBX
   bool setAutoRXMSFRBX(bool enabled, uint16_t maxWait = defaultMaxWait);                                                  // Enable/disable automatic RXM SFRBX reports at the navigation frequency
   bool setAutoRXMSFRBX(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                             // Enable/disable automatic RXM SFRBX 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
   bool setAutoRXMSFRBXrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                  // Set the rate for automatic SFRBX reports
   bool setAutoRXMSFRBXcallback(void (*callbackPointer)(UBX_RXM_SFRBX_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic SFRBX reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoRXMSFRBXcallbackPtr(void (*callbackPointerPtr)(UBX_RXM_SFRBX_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic SFRBX reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoRXMSFRBX(bool enabled, bool implicitUpdate = true);                                                      // In case no config access to the GPS is possible and RXM SFRBX is send cyclically already
   void flushRXMSFRBX();                                                                                                   // Mark all the data as read/stale
   void logRXMSFRBX(bool enabled = true);                                                                                  // Log data to file buffer
@@ -1084,13 +1132,15 @@ public:
   bool setAutoRXMRAWX(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                            // Enable/disable automatic RXM RAWX 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
   bool setAutoRXMRAWXrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                 // Set the rate for automatic RAWX reports
   bool setAutoRXMRAWXcallback(void (*callbackPointer)(UBX_RXM_RAWX_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic RAWX reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoRXMRAWXcallbackPtr(void (*callbackPointerPtr)(UBX_RXM_RAWX_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic RAWX reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoRXMRAWX(bool enabled, bool implicitUpdate = true);                                                     // In case no config access to the GPS is possible and RXM RAWX is send cyclically already
   void flushRXMRAWX();                                                                                                  // Mark all the data as read/stale
   void logRXMRAWX(bool enabled = true);                                                                                 // Log data to file buffer
 
   // Configuration (CFG)
 
-	// Add "auto" support for CFG RATE - because we use it for isConnected (to stop it being mugged by other messages)
+  // Add "auto" support for CFG PRT - because we use it for isConnected (to stop it being mugged by other messages)
+  bool getPortSettingsInternal(uint8_t portID, uint16_t maxWait = defaultMaxWait); // Read the port configuration for a given port using UBX-CFG-PRT
   bool getNavigationFrequencyInternal(uint16_t maxWait = defaultMaxWait);          // Get the number of nav solutions sent per second currently being output by module
 
   // Timing messages (TIM)
@@ -1100,6 +1150,7 @@ public:
   bool setAutoTIMTM2(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic TIM TM2 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
   bool setAutoTIMTM2rate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic TIM TM2 reports
   bool setAutoTIMTM2callback(void (*callbackPointer)(UBX_TIM_TM2_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic TM2 reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoTIMTM2callbackPtr(void (*callbackPointerPtr)(UBX_TIM_TM2_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic TM2 reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoTIMTM2(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and TIM TM2 is send cyclically already
   void flushTIMTM2();                                                                                                 // Mark all the data as read/stale
   void logTIMTM2(bool enabled = true);                                                                                // Log data to file buffer
@@ -1112,6 +1163,7 @@ public:
   bool setAutoESFALG(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic ESF ALG reports, 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
   bool setAutoESFALGrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic ALG reports
   bool setAutoESFALGcallback(void (*callbackPointer)(UBX_ESF_ALG_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic ALG reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoESFALGcallbackPtr(void (*callbackPointerPtr)(UBX_ESF_ALG_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic ALG reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoESFALG(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and ESF ALG is send cyclically already
   void flushESFALG();                                                                                                 // Mark all the data as read/stale
   void logESFALG(bool enabled = true);                                                                                // Log data to file buffer
@@ -1122,6 +1174,7 @@ public:
   bool setAutoESFSTATUS(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                              // Enable/disable automatic ESF STATUS reports, 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
   bool setAutoESFSTATUSrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                   // Set the rate for automatic STATUS reports
   bool setAutoESFSTATUScallback(void (*callbackPointer)(UBX_ESF_STATUS_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic STATUS reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoESFSTATUScallbackPtr(void (*callbackPointerPtr)(UBX_ESF_STATUS_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic STATUS reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoESFSTATUS(bool enabled, bool implicitUpdate = true);                                                       // In case no config access to the GPS is possible and ESF STATUS is send cyclically already
   void flushESFSTATUS();                                                                                                    // Mark all the data as read/stale
   void logESFSTATUS(bool enabled = true);                                                                                   // Log data to file buffer
@@ -1132,6 +1185,7 @@ public:
   bool setAutoESFINS(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic ESF INS reports, 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
   bool setAutoESFINSrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic INS reports
   bool setAutoESFINScallback(void (*callbackPointer)(UBX_ESF_INS_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic INS reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoESFINScallbackPtr(void (*callbackPointerPtr)(UBX_ESF_INS_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic INS reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoESFINS(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and ESF INS is send cyclically already
   void flushESFINS();                                                                                                 // Mark all the data as read/stale
   void logESFINS(bool enabled = true);                                                                                // Log data to file buffer
@@ -1142,6 +1196,7 @@ public:
   bool setAutoESFMEAS(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                            // Enable/disable automatic ESF MEAS reports, 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
   bool setAutoESFMEASrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                 // Set the rate for automatic MEAS reports
   bool setAutoESFMEAScallback(void (*callbackPointer)(UBX_ESF_MEAS_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic MEAS reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoESFMEAScallbackPtr(void (*callbackPointerPtr)(UBX_ESF_MEAS_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic MEAS reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoESFMEAS(bool enabled, bool implicitUpdate = true);                                                     // In case no config access to the GPS is possible and ESF MEAS is send cyclically already
   void flushESFMEAS();                                                                                                  // Mark all the data as read/stale
   void logESFMEAS(bool enabled = true);                                                                                 // Log data to file buffer
@@ -1152,6 +1207,7 @@ public:
   bool setAutoESFRAW(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic ESF RAW reports, 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
   bool setAutoESFRAWrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic RAW reports
   bool setAutoESFRAWcallback(void (*callbackPointer)(UBX_ESF_RAW_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic RAW reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoESFRAWcallbackPtr(void (*callbackPointerPtr)(UBX_ESF_RAW_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic RAW reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoESFRAW(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and ESF RAW is send cyclically already
   void flushESFRAW();                                                                                                 // Mark all the data as read/stale
   void logESFRAW(bool enabled = true);                                                                                // Log data to file buffer
@@ -1164,6 +1220,7 @@ public:
   bool setAutoHNRATT(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic HNR Attitude reports at the HNR rate, 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
   bool setAutoHNRATTrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic ATT reports
   bool setAutoHNRATTcallback(void (*callbackPointer)(UBX_HNR_ATT_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic ATT reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoHNRATTcallbackPtr(void (*callbackPointerPtr)(UBX_HNR_ATT_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic ATT reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoHNRATT(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and HNR Attitude is send cyclically already
   void flushHNRATT();                                                                                                 // Mark all the data as read/stale
   void logHNRATT(bool enabled = true);                                                                                // Log data to file buffer
@@ -1174,6 +1231,7 @@ public:
   bool setAutoHNRINS(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic HNR dynamics reports at the HNR rate, 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
   bool setAutoHNRINSrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic INS reports
   bool setAutoHNRINScallback(void (*callbackPointer)(UBX_HNR_INS_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic INS reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoHNRINScallbackPtr(void (*callbackPointerPtr)(UBX_HNR_INS_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic INS reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoHNRINS(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and HNR dynamics is send cyclically already
   void flushHNRINS();                                                                                                 // Mark all the data as read/stale
   void logHNRINS(bool enabled = true);                                                                                // Log data to file buffer
@@ -1183,6 +1241,7 @@ public:
   bool setAutoHNRPVT(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic HNR PVT reports at the HNR rate, 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
   bool setAutoHNRPVTrate(uint8_t rate, bool implicitUpdate = true, uint16_t maxWait = defaultMaxWait);                // Set the rate for automatic PVT reports
   bool setAutoHNRPVTcallback(void (*callbackPointer)(UBX_HNR_PVT_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic PVT reports at the navigation frequency. Data is accessed from the callback.
+  bool setAutoHNRPVTcallbackPtr(void (*callbackPointerPtr)(UBX_HNR_PVT_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic PVT reports at the navigation frequency. Data is accessed from the callback.
   bool assumeAutoHNRPVT(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and HNR PVT is send cyclically already
   void flushHNRPVT();                                                                                                 // Mark all the data as read/stale
   void logHNRPVT(bool enabled = true);                                                                                // Log data to file buffer
@@ -1352,17 +1411,20 @@ public:
   // Support for "auto" storage of NMEA messages
   uint8_t getLatestNMEAGPGGA(NMEA_GGA_data_t *data);                           // Return the most recent GPGGA: 0 = no data, 1 = stale data, 2 = fresh data
   bool setNMEAGPGGAcallback(void (*callbackPointer)(NMEA_GGA_data_t));         // Enable a callback on the arrival of a GPGGA message
+  bool setNMEAGPGGAcallbackPtr(void (*callbackPointerPtr)(NMEA_GGA_data_t *)); // Enable a callback on the arrival of a GPGGA message
   uint8_t getLatestNMEAGNGGA(NMEA_GGA_data_t *data);                           // Return the most recent GNGGA: 0 = no data, 1 = stale data, 2 = fresh data
   bool setNMEAGNGGAcallback(void (*callbackPointer)(NMEA_GGA_data_t));         // Enable a callback on the arrival of a GNGGA message
+  bool setNMEAGNGGAcallbackPtr(void (*callbackPointerPtr)(NMEA_GGA_data_t *)); // Enable a callback on the arrival of a GNGGA message
 
   // Functions to extract signed and unsigned 8/16/32-bit data from a ubxPacket
   // From v2.0: These are public. The user can call these to extract data from custom packets
-	uint32_t extractLong(ubxPacket *msg, uint8_t spotToStart); //Combine four bytes from payload into long
+  uint64_t extractLongLong(ubxPacket *msg, uint16_t spotToStart);  // Combine eight bytes from payload into uint64_t
-	int32_t extractSignedLong(ubxPacket *msg, uint8_t spotToStart); //Combine four bytes from payload into signed long (avoiding any ambiguity caused by casting)
+  uint32_t extractLong(ubxPacket *msg, uint16_t spotToStart);      // Combine four bytes from payload into long
-	uint16_t extractInt(ubxPacket *msg, uint8_t spotToStart); //Combine two bytes from payload into int
+  int32_t extractSignedLong(ubxPacket *msg, uint16_t spotToStart); // Combine four bytes from payload into signed long (avoiding any ambiguity caused by casting)
-	int16_t extractSignedInt(ubxPacket *msg, int8_t spotToStart);
+  uint16_t extractInt(ubxPacket *msg, uint16_t spotToStart);       // Combine two bytes from payload into int
-	uint8_t extractByte(ubxPacket *msg, uint8_t spotToStart); //Get byte from payload
+  int16_t extractSignedInt(ubxPacket *msg, uint16_t spotToStart);
-	int8_t extractSignedChar(ubxPacket *msg, uint8_t spotToStart); //Get signed 8-bit value from payload
+  uint8_t extractByte(ubxPacket *msg, uint16_t spotToStart);      // Get byte from payload
+  int8_t extractSignedChar(ubxPacket *msg, uint16_t spotToStart); // Get signed 8-bit value from payload
 
   // Pointers to storage for the "automatic" messages
   // RAM is allocated for these if/when required.
@@ -1385,9 +1447,12 @@ public:
   UBX_NAV_RELPOSNED_t *packetUBXNAVRELPOSNED = NULL; // Pointer to struct. RAM will be allocated for this if/when necessary
   UBX_NAV_AOPSTATUS_t *packetUBXNAVAOPSTATUS = NULL; // Pointer to struct. RAM will be allocated for this if/when necessary
 
+  UBX_RXM_PMP_t *packetUBXRXMPMP = NULL;                // Pointer to struct. RAM will be allocated for this if/when necessary
+  UBX_RXM_PMP_message_t *packetUBXRXMPMPmessage = NULL; // Pointer to struct. RAM will be allocated for this if/when necessary
   UBX_RXM_SFRBX_t *packetUBXRXMSFRBX = NULL;            // Pointer to struct. RAM will be allocated for this if/when necessary
   UBX_RXM_RAWX_t *packetUBXRXMRAWX = NULL;              // Pointer to struct. RAM will be allocated for this if/when necessary
 
+  UBX_CFG_PRT_t *packetUBXCFGPRT = NULL;   // Pointer to struct. RAM will be allocated for this if/when necessary
   UBX_CFG_RATE_t *packetUBXCFGRATE = NULL; // Pointer to struct. RAM will be allocated for this if/when necessary
 
   UBX_TIM_TM2_t *packetUBXTIMTM2 = NULL; // Pointer to struct. RAM will be allocated for this if/when necessary
@@ -1472,8 +1537,11 @@ private:
   bool initPacketUBXNAVSAT();        // Allocate RAM for packetUBXNAVSAT and initialize it
   bool initPacketUBXNAVRELPOSNED();  // Allocate RAM for packetUBXNAVRELPOSNED and initialize it
   bool initPacketUBXNAVAOPSTATUS();  // Allocate RAM for packetUBXNAVAOPSTATUS and initialize it
+  bool initPacketUBXRXMPMP();        // Allocate RAM for packetUBXRXMPMP and initialize it
+  bool initPacketUBXRXMPMPmessage(); // Allocate RAM for packetUBXRXMPMPRaw and initialize it
   bool initPacketUBXRXMSFRBX();      // Allocate RAM for packetUBXRXMSFRBX and initialize it
   bool initPacketUBXRXMRAWX();       // Allocate RAM for packetUBXRXMRAWX and initialize it
+  bool initPacketUBXCFGPRT();        // Allocate RAM for packetUBXCFGPRT and initialize it
   bool initPacketUBXCFGRATE();       // Allocate RAM for packetUBXCFGRATE and initialize it
   bool initPacketUBXTIMTM2();        // Allocate RAM for packetUBXTIMTM2 and initialize it
   bool initPacketUBXESFALG();        // Allocate RAM for packetUBXESFALG and initialize it
@@ -1495,7 +1563,7 @@ private:
   Stream *_serialPort;            // The generic connection to user's chosen Serial hardware
   Stream *_nmeaOutputPort = NULL; // The user can assign an output port to print NMEA sentences if they wish
   Stream *_debugSerial;           // The stream to send debug messages to if enabled
-
+  Stream *_outputPort = NULL;
   SPIClass *_spiPort; // The instance of SPIClass
   uint8_t _csPin;     // The chip select pin
   uint32_t _spiSpeed; // The speed to use for SPI (Hz)
@@ -1606,7 +1674,6 @@ private:
   // .begin will return true if the assumeSuccess parameter is true and if _signsOfLife is true
   // _signsOfLife is set to true when: a valid UBX message is seen; a valig NMEA header is seen.
   bool _signsOfLife;
-
 };
 
 #endif

src/u-blox_config_keys.h

@@ -381,6 +381,11 @@ const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_SPAN_SPI = 0x2091038f;			// Output rate
 const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_SPAN_UART1 = 0x2091038c;       // Output rate of the UBX-MON-SPAN message on port UART1
 const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_SPAN_UART2 = 0x2091038d;       // Output rate of the UBX-MON-SPAN message on port UART2
 const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_SPAN_USB = 0x2091038e;         // Output rate of the UBX-MON-SPAN message on port USB
+const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_SYS_I2C = 0x2091069d;          // Output rate of the UBX-MON-SYS message on port I2C
+const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_SYS_SPI = 0x209106a1;          // Output rate of the UBX-MON-SYS message on port SPI
+const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_SYS_UART1 = 0x2091069e;        // Output rate of the UBX-MON-SYS message on port UART1
+const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_SYS_UART2 = 0x2091069f;        // Output rate of the UBX-MON-SYS message on port UART2
+const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_SYS_USB = 0x209106a0;          // Output rate of the UBX-MON-SYS message on port USB
 const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_TXBUF_I2C = 0x2091019b;        // Output rate of the UBX-MON-TXBUF message on port I2C
 const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_TXBUF_SPI = 0x2091019f;        // Output rate of the UBX-MON-TXBUF message on port SPI
 const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_TXBUF_UART1 = 0x2091019c;      // Output rate of the UBX-MON-TXBUF message on port UART1
@@ -431,6 +436,11 @@ const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_ORB_SPI = 0x20910014;				// Output rate
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_ORB_UART1 = 0x20910011;        // Output rate of the UBX-NAV-ORB message on port UART1
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_ORB_UART2 = 0x20910012;        // Output rate of the UBX-NAV-ORB message on port UART2
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_ORB_USB = 0x20910013;          // Output rate of the UBX-NAV-ORB message on port USB
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_PL_I2C = 0x20910415;           // Output rate of the UBX-NAV-PL message on port I2C
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_PL_SPI = 0x20910419;           // Output rate of the UBX-NAV-PL message on port SPI
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_PL_UART1 = 0x20910416;         // Output rate of the UBX-NAV-PL message on port UART1
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_PL_UART2 = 0x20910417;         // Output rate of the UBX-NAV-PL message on port UART2
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_PL_USB = 0x20910418;           // Output rate of the UBX-NAV-PL message on port USB
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_POSECEF_I2C = 0x20910024;      // Output rate of the UBX-NAV-POSECEF message on port I2C
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_POSECEF_SPI = 0x20910028;      // Output rate of the UBX-NAV-POSECEF message on port SPI
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_POSECEF_UART1 = 0x20910025;    // Output rate of the UBX-NAV-POSECEF message on port UART1
@@ -526,6 +536,11 @@ const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_VELNED_SPI = 0x20910046;	// Output rate
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_VELNED_UART1 = 0x20910043;     // Output rate of the UBX-NAV-VELNED message on port UART1
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_VELNED_UART2 = 0x20910044;     // Output rate of the UBX-NAV-VELNED message on port UART2
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_VELNED_USB = 0x20910045;       // Output rate of the UBX-NAV-VELNED message on port USB
+const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_COR_I2C = 0x209106b6;          // Output rate of the UBX-RXM-COR message on port I2C
+const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_COR_SPI = 0x209106ba;          // Output rate of the UBX-RXM-COR message on port SPI
+const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_COR_UART1 = 0x209106b7;        // Output rate of the UBX-RXM-COR message on port UART1
+const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_COR_UART2 = 0x209106b8;        // Output rate of the UBX-RXM-COR message on port UART2
+const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_COR_USB = 0x209106b9;          // Output rate of the UBX-RXM-COR message on port USB
 const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_MEASX_I2C = 0x20910204;        // Output rate of the UBX-RXM-MEASX message on port I2C
 const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_MEASX_SPI = 0x20910208;        // Output rate of the UBX-RXM-MEASX message on port SPI
 const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_MEASX_UART1 = 0x20910205;      // Output rate of the UBX-RXM-MEASX message on port UART1
@@ -625,7 +640,6 @@ const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_PVAT_UART2 = 0x2091062c; // Output rate
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_PVAT_USB = 0x2091062d;     // Output rate of the UBX-NAV-PVAT message on port USB
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV_PVAT_SPI = 0x2091062e;     // Output rate of the UBX-NAV-PVAT message on port SPI
 
-
 // Additional CFG_MSGOUT keys for the ZED-F9T
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 const uint32_t UBLOX_CFG_MSGOUT_NMEA_NAV2_ID_GGA_I2C = 0x20910661;    // Output rate of the NMEA-NAV2-GX-GGA message on port I2C
@@ -718,11 +732,21 @@ const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_SPI = 0x20910509; // Output rate of
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_UART1 = 0x20910506;      // Output rate of the UBX-NAV2-SIG message onport UART1
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_UART2 = 0x20910507;      // Output rate of the UBX-NAV2-SIG message onport UART2
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SIG_USB = 0x20910508;        // Output rate of the UBX-NAV2-SIG message on port USB
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_I2C = 0x20910510;       // Output rate of the UBX-NAV2-SLAS message on port I2C
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_SPI = 0x20910514;       // Output rate of the UBX-NAV2-SLAS message on port SPI
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_UART1 = 0x20910511;     // Output rate of the UBX-NAV2-SLAS message on port UART1
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_UART2 = 0x20910512;     // Output rate of the UBX-NAV2-SLAS message on port UART2
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SLAS_USB = 0x20910513;       // Output rate of the UBX-NAV2-SLAS message on port USB
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_I2C = 0x20910515;     // Output rate of the UBX-NAV2-STATUS message on port I2C
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_SPI = 0x20910519;     // Output rate of the UBX-NAV2-STATUS message on port SPI
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_UART1 = 0x20910516;   // Output rate of the UBX-NAV2-STATUS message on port UART1
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_UART2 = 0x20910517;   // Output rate of the UBX-NAV2-STATUS message on port UART2
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_STATUS_USB = 0x20910518;     // Output rate of the UBX-NAV2-STATUS message on port USB
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_I2C = 0x20910520;       // Output rate of the UBX-NAV2-SVIN message on port I2C
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_SPI = 0x20910524;       // Output rate of the UBX-NAV2-SVIN message on port SPI
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_UART1 = 0x20910521;     // Output rate of the UBX-NAV2-SVIN message on port UART1
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_UART2 = 0x20910522;     // Output rate of the UBX-NAV2-SVIN message on port UART2
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_SVIN_USB = 0x20910523;       // Output rate of the UBX-NAV2-SVIN message on port USB
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_I2C = 0x20910525;    // Output rate of the UBX-NAV2-TIMEBDS message on port I2C
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_SPI = 0x20910529;    // Output rate of the UBX-NAV2-TIMEBDS message on port SPI
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEBDS_UART1 = 0x20910526;  // Output rate of the UBX-NAV2-TIMEBDS message on port UART1
@@ -748,6 +772,11 @@ const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_SPI = 0x20910549; // Output rate
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_UART1 = 0x20910546;   // Output rate of the UBX-NAV2-TIMELS message on port UART1
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_UART2 = 0x20910547;   // Output rate of the UBX-NAV2-TIMELS message on port UART2
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMELS_USB = 0x20910548;     // Output rate of the UBX-NAV2-TIMELS message on port USB
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_I2C = 0x20910575;   // Output rate of the UBX-NAV2-TIMEQZSS message on port I2C
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_SPI = 0x20910579;   // Output rate of the UBX-NAV2-TIMEQZSS message on port SPI
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_UART1 = 0x20910576; // Output rate of the UBX-NAV2-TIMEQZSS message on port UART1
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_UART2 = 0x20910577; // Output rate of the UBX-NAV2-TIMEQZSS message on port UART2
+const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEQZSS_USB = 0x20910578;   // Output rate of the UBX-NAV2-TIMEQZSS message on port USB
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_I2C = 0x20910550;    // Output rate of the UBX-NAV2-TIMEUTC message on port I2C
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_SPI = 0x20910554;    // Output rate of the UBX-NAV2-TIMEUTC message on port SPI
 const uint32_t UBLOX_CFG_MSGOUT_UBX_NAV2_TIMEUTC_UART1 = 0x20910551;  // Output rate of the UBX-NAV2-TIMEUTC message on port UART1
@@ -784,6 +813,19 @@ const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_UART1 = 0x20910098; // Output rate
 const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_UART2 = 0x20910099;      // Output rate of the UBX-TIM-SVIN message on port UART2
 const uint32_t UBLOX_CFG_MSGOUT_UBX_TIM_SVIN_USB = 0x2091009a;        // Output rate of the UBX-TIM-SVIN message on port USB
 
+// Additional CFG_MSGOUT keys for the NEO-D9S
+//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_I2C = 0x2091031d;   // Output rate of the UBX_RXM_PMP message on port I2C
+const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_SPI = 0x20910321;   // Output rate of the UBX_RXM_PMP message on port SPI
+const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART1 = 0x2091031e; // Output rate of the UBX_RXM_PMP message on port UART1
+const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_UART2 = 0x2091031f; // Output rate of the UBX_RXM_PMP message on port UART2
+const uint32_t UBLOX_CFG_MSGOUT_UBX_RXM_PMP_USB = 0x20910320;   // Output rate of the UBX_RXM_PMP message on port USB
+const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_I2C = 0x20910322;   // Output rate of the UBX_MON_PMP message on port I2C
+const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_SPI = 0x20910326;   // Output rate of the UBX_MON_PMP message on port SPI
+const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_UART1 = 0x20910323; // Output rate of the UBX_MON_PMP message on port UART1
+const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_UART2 = 0x20910324; // Output rate of the UBX_MON_PMP message on port UART2
+const uint32_t UBLOX_CFG_MSGOUT_UBX_MON_PMP_USB = 0x20910325;   // Output rate of the UBX_MON_PMP message on port USB
+
 // CFG-NAV2: Secondary output configuration
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 const uint32_t UBLOX_CFG_NAV2_OUT_ENABLED = 0x10170001;        // Enable secondary (NAV2) output
@@ -827,6 +869,7 @@ const uint32_t UBLOX_CFG_NAVSPG_CONSTR_ALT = 0x401100c1;	// Fixed altitude (mean
 const uint32_t UBLOX_CFG_NAVSPG_CONSTR_ALTVAR = 0x401100c2;  // Fixed altitude variance for 2D mode
 const uint32_t UBLOX_CFG_NAVSPG_CONSTR_DGNSSTO = 0x201100c4; // DGNSS timeout
 const uint32_t UBLOX_CFG_NAVSPG_SIGATTCOMP = 0x201100d6;     // Permanently attenuated signal compensation mode
+const uint32_t UBLOX_CFG_NAVSPG_PL_ENA = 0x101100d7;         // Enable Protection level. If enabled, protection level computing will be on.
 
 // CFG-NMEA: NMEA protocol configuration
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
@@ -865,11 +908,32 @@ const uint32_t UBLOX_CFG_ODO_COGMAXPOSACC = 0x20220022;	// Maximum acceptable po
 const uint32_t UBLOX_CFG_ODO_VELLPGAIN = 0x20220031;    // Velocity low-pass filter level
 const uint32_t UBLOX_CFG_ODO_COGLPGAIN = 0x20220032;    // Course over ground low-pass filter level (at speed < 8 m/s)
 
+// CFG-PM: Configuration for receiver power management (NEO-D9S)
+//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+const uint32_t UBLOX_CFG_PM_EXTINTSEL = 0x20d0000b;        // EXTINT pin select
+const uint32_t UBLOX_CFG_PM_EXTINTWAKE = 0x10d0000c;       // EXTINT pin control (Wake). Enable to keep receiver awake as long as selected EXTINT pin is "high".
+const uint32_t UBLOX_CFG_PM_EXTINTBACKUP = 0x10d0000d;     // EXTINT pin control (Backup). Enable to force receiver into BACKUP mode when selected EXTINT pin is "low".
+const uint32_t UBLOX_CFG_PM_EXTINTINACTIVE = 0x10d0000e;   // EXTINT pin control (Inactive). Enable to force backup in case EXTINT Pin is inactive for time longer than CFG-PM-EXTINTINACTIVITY.
+const uint32_t UBLOX_CFG_PM_EXTINTINACTIVITY = 0x40d0000f; // Inactivity time out on EXTINT pin if enabled
+
+// CFG-PMP: Point to multipoint (PMP) configuration (NEO-D9S)
+//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+const uint32_t UBLOX_CFG_PMP_CENTER_FREQUENCY = 0x40b10011;  // Center frequency. The center frequency for the receiver can be set from 1525000000 to 1559000000 Hz.
+const uint32_t UBLOX_CFG_PMP_SEARCH_WINDOW = 0x30b10012;     // Search window. Search window can be set from 0 to 65535 Hz. It is +/- this value from the center frequency set by CENTER_FREQUENCY.
+const uint32_t UBLOX_CFG_PMP_USE_SERVICE_ID = 0x10b10016;    // Use service ID. Enable/disable service ID check to confirm the correct service is received.
+const uint32_t UBLOX_CFG_PMP_SERVICE_ID = 0x30b10017;        // Service identifier. Defines the expected service ID.
+const uint32_t UBLOX_CFG_PMP_DATA_RATE = 0x30b10013;         // bps Data rate. The data rate of the received data.
+const uint32_t UBLOX_CFG_PMP_USE_DESCRAMBLER = 0x10b10014;   // Use descrambler. Enables/disables the descrambler.
+const uint32_t UBLOX_CFG_PMP_DESCRAMBLER_INIT = 0x30b10015;  // Descrambler initialization. Set the intialisation value for the descrambler.
+const uint32_t UBLOX_CFG_PMP_USE_PRESCRAMBLING = 0x10b10019; // Use prescrambling. Enables/disables the prescrambling.
+const uint32_t UBLOX_CFG_PMP_UNIQUE_WORD = 0x50b1001a;       // Unique word. Defines value of unique word.
+
 // CFG-QZSS: QZSS system configuration
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 const uint32_t UBLOX_CFG_QZSS_USE_SLAS_DGNSS = 0x10370005;       // Apply QZSS SLAS DGNSS corrections
 const uint32_t UBLOX_CFG_QZSS_USE_SLAS_TESTMODE = 0x10370006;    // Use QZSS SLAS data when it is in test mode (SLAS msg 0)
 const uint32_t UBLOX_CFG_QZSS_USE_SLAS_RAIM_UNCORR = 0x10370007; // Raim out measurements that are not corrected by QZSS SLAS, if at least 5 measurements are corrected
+const uint32_t UBLOX_CFG_QZSS_SLAS_MAX_BASELINE = 0x30370008;    // Maximum baseline distance to closest Ground Monitoring Station: km
 
 // CFG-RATE: Navigation and measurement rate configuration
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
@@ -975,6 +1039,10 @@ const uint32_t UBLOX_CFG_SIGNAL_GLO_ENA = 0x10310025;	// GLONASS enable
 const uint32_t UBLOX_CFG_SIGNAL_GLO_L1_ENA = 0x10310018;    // GLONASS L1
 const uint32_t UBLOX_CFG_SIGNAL_GLO_L2_ENA = 0x1031001a;    // GLONASS L2 (only on u-blox F9 platform products)
 
+// CFG-SPARTN: Configuration of the SPARTN interface
+//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+const uint32_t UBLOX_CFG_SPARTN_USE_SOURCE = 0x20a70001;
+
 // CFG-SPI: Configuration of the SPI interface
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
 const uint32_t UBLOX_CFG_SPI_MAXFF = 0x20640001;           // Number of bytes containing 0xFF to receive before switching off reception. Range: 0 (mechanism off) - 63

src/u-blox_structs.h

@@ -103,6 +103,7 @@ typedef struct
   UBX_NAV_POSECEF_data_t data;
   UBX_NAV_POSECEF_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_POSECEF_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_POSECEF_data_t *);
   UBX_NAV_POSECEF_data_t *callbackData;
 } UBX_NAV_POSECEF_t;
 
@@ -146,6 +147,7 @@ typedef struct
   UBX_NAV_POSLLH_data_t data;
   UBX_NAV_POSLLH_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_POSLLH_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_POSLLH_data_t *);
   UBX_NAV_POSLLH_data_t *callbackData;
 } UBX_NAV_POSLLH_t;
 
@@ -246,6 +248,7 @@ typedef struct
   UBX_NAV_STATUS_data_t data;
   UBX_NAV_STATUS_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_STATUS_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_STATUS_data_t *);
   UBX_NAV_STATUS_data_t *callbackData;
 } UBX_NAV_STATUS_t;
 
@@ -291,6 +294,7 @@ typedef struct
   UBX_NAV_DOP_data_t data;
   UBX_NAV_DOP_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_DOP_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_DOP_data_t *);
   UBX_NAV_DOP_data_t *callbackData;
 } UBX_NAV_DOP_t;
 
@@ -337,6 +341,7 @@ typedef struct
   UBX_NAV_ATT_data_t data;
   UBX_NAV_ATT_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_ATT_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_ATT_data_t *);
   UBX_NAV_ATT_data_t *callbackData;
 } UBX_NAV_ATT_t;
 
@@ -500,6 +505,7 @@ typedef struct
   UBX_NAV_PVT_data_t data;
   UBX_NAV_PVT_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_PVT_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_PVT_data_t *);
   UBX_NAV_PVT_data_t *callbackData;
 } UBX_NAV_PVT_t;
 
@@ -540,6 +546,7 @@ typedef struct
   UBX_NAV_ODO_data_t data;
   UBX_NAV_ODO_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_ODO_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_ODO_data_t *);
   UBX_NAV_ODO_data_t *callbackData;
 } UBX_NAV_ODO_t;
 
@@ -579,6 +586,7 @@ typedef struct
   UBX_NAV_VELECEF_data_t data;
   UBX_NAV_VELECEF_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_VELECEF_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_VELECEF_data_t *);
   UBX_NAV_VELECEF_data_t *callbackData;
 } UBX_NAV_VELECEF_t;
 
@@ -626,6 +634,7 @@ typedef struct
   UBX_NAV_VELNED_data_t data;
   UBX_NAV_VELNED_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_VELNED_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_VELNED_data_t *);
   UBX_NAV_VELNED_data_t *callbackData;
 } UBX_NAV_VELNED_t;
 
@@ -685,6 +694,7 @@ typedef struct
   UBX_NAV_HPPOSECEF_data_t data;
   UBX_NAV_HPPOSECEF_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_HPPOSECEF_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_HPPOSECEF_data_t *);
   UBX_NAV_HPPOSECEF_data_t *callbackData;
 } UBX_NAV_HPPOSECEF_t;
 
@@ -750,6 +760,7 @@ typedef struct
   UBX_NAV_HPPOSLLH_data_t data;
   UBX_NAV_HPPOSLLH_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_HPPOSLLH_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_HPPOSLLH_data_t *);
   UBX_NAV_HPPOSLLH_data_t *callbackData;
 } UBX_NAV_HPPOSLLH_t;
 
@@ -924,6 +935,7 @@ typedef struct
   UBX_NAV_PVAT_data_t data;
   UBX_NAV_PVAT_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_PVAT_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_PVAT_data_t *);
   UBX_NAV_PVAT_data_t *callbackData;
 } UBX_NAV_PVAT_t;
 
@@ -988,6 +1000,7 @@ typedef struct
   UBX_NAV_TIMEUTC_data_t data;
   UBX_NAV_TIMEUTC_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_TIMEUTC_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_TIMEUTC_data_t *);
   UBX_NAV_TIMEUTC_data_t *callbackData;
 } UBX_NAV_TIMEUTC_t;
 
@@ -1027,6 +1040,7 @@ typedef struct
   UBX_NAV_CLOCK_data_t data;
   UBX_NAV_CLOCK_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_CLOCK_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_CLOCK_data_t *);
   UBX_NAV_CLOCK_data_t *callbackData;
 } UBX_NAV_CLOCK_t;
 
@@ -1087,6 +1101,7 @@ typedef struct
   UBX_NAV_TIMELS_data_t data;
   UBX_NAV_TIMELS_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_TIMELS_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_TIMELS_data_t *);
   UBX_NAV_TIMELS_data_t *callbackData;
 } UBX_NAV_TIMELS_t;
 
@@ -1160,6 +1175,7 @@ typedef struct
   UBX_NAV_SAT_data_t data;
   bool moduleQueried;
   void (*callbackPointer)(UBX_NAV_SAT_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_SAT_data_t *);
   UBX_NAV_SAT_data_t *callbackData;
 } UBX_NAV_SAT_t;
 
@@ -1218,6 +1234,7 @@ typedef struct
   UBX_NAV_SVIN_data_t data;
   UBX_NAV_SVIN_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_SVIN_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_SVIN_data_t *);
   UBX_NAV_SVIN_data_t *callbackData;
 } UBX_NAV_SVIN_t;
 
@@ -1317,6 +1334,7 @@ typedef struct
   UBX_NAV_RELPOSNED_data_t data;
   UBX_NAV_RELPOSNED_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_RELPOSNED_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_RELPOSNED_data_t *);
   UBX_NAV_RELPOSNED_data_t *callbackData;
 } UBX_NAV_RELPOSNED_t;
 
@@ -1362,6 +1380,7 @@ typedef struct
   UBX_NAV_AOPSTATUS_data_t data;
   UBX_NAV_AOPSTATUS_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_NAV_AOPSTATUS_data_t);
+  void (*callbackPointerPtr)(UBX_NAV_AOPSTATUS_data_t *);
   UBX_NAV_AOPSTATUS_data_t *callbackData;
 } UBX_NAV_AOPSTATUS_t;
 
@@ -1393,6 +1412,7 @@ typedef struct
   UBX_RXM_SFRBX_data_t data;
   bool moduleQueried;
   void (*callbackPointer)(UBX_RXM_SFRBX_data_t);
+  void (*callbackPointerPtr)(UBX_RXM_SFRBX_data_t *);
   UBX_RXM_SFRBX_data_t *callbackData;
 } UBX_RXM_SFRBX_t;
 
@@ -1460,38 +1480,125 @@ typedef struct
   UBX_RXM_RAWX_data_t data;
   bool moduleQueried;
   void (*callbackPointer)(UBX_RXM_RAWX_data_t);
+  void (*callbackPointerPtr)(UBX_RXM_RAWX_data_t *);
   UBX_RXM_RAWX_data_t *callbackData;
 } UBX_RXM_RAWX_t;
 
 // UBX-RXM-PMP (0x02 0x72): PMP raw data (D9 modules)
-const uint16_t UBX_RXM_PMP_MAX_LEN = 528;
+// There are two versions of this message but, fortunately, both have a max len of 528
+const uint16_t UBX_RXM_PMP_MAX_USER_DATA = 504;
+const uint16_t UBX_RXM_PMP_MAX_LEN = UBX_RXM_PMP_MAX_USER_DATA + 24;
 
 typedef struct
 {
-  uint8_t version; // Message version (0x00 for this version)
+  uint8_t version;             // Message version (0x00 / 0x01)
-  uint8_t reserved0[3]; // Reserved
+  uint8_t reserved0;           // Reserved
+  uint16_t numBytesUserData;   // version 0x00: reserved0 ; version 0x01: Number of bytes the userData block has in this frame (0...504)
   uint32_t timeTag;            // Time since startup when frame started : ms
   uint32_t uniqueWord[2];      // Received unique words
   uint16_t serviceIdentifier;  // Received service identifier
   uint8_t spare;               // Received spare data
   uint8_t uniqueWordBitErrors; // Number of bit errors in both unique words
-  uint8_t userData[504]; // Received user data
+
+  // The position of fecBits, ebno and reserved1 depends on the message version
   uint16_t fecBits;  // Number of bits corrected by FEC (forward error correction)
   uint8_t ebno;      // Energy per bit to noise power spectral density ratio : 2^-3 dB
   uint8_t reserved1; // Reserved
+
+  uint8_t userData[UBX_RXM_PMP_MAX_USER_DATA]; // Received user data: version 0x00 : starts at byte 20 ; version 0x01 : starts at byte 24
+
 } UBX_RXM_PMP_data_t;
 
+// The PMP data can only be accessed via a callback. PMP cannot be polled.
 typedef struct
 {
   ubxAutomaticFlags automaticFlags;
-  UBX_RXM_PMP_data_t data;
+  void (*callbackPointerPtr)(UBX_RXM_PMP_data_t *);
-  bool moduleQueried;
-  void (*callbackPointer)(UBX_RXM_PMP_data_t);
   UBX_RXM_PMP_data_t *callbackData;
 } UBX_RXM_PMP_t;
 
+// Define a struct to hold the entire PMP message so the whole thing can be pushed to a GNSS.
+// Remember that the length of the payload could be variable (with version 1 messages).
+typedef struct
+{
+  uint8_t sync1; // 0xB5
+  uint8_t sync2; // 0x62
+  uint8_t cls;
+  uint8_t ID;
+  uint8_t lengthLSB;
+  uint8_t lengthMSB;
+  uint8_t payload[UBX_RXM_PMP_MAX_LEN];
+  uint8_t checksumA;
+  uint8_t checksumB;
+} UBX_RXM_PMP_message_data_t;
+
+// The PMP data can only be accessed via a callback. PMP cannot be polled.
+typedef struct
+{
+  ubxAutomaticFlags automaticFlags;
+  void (*callbackPointerPtr)(UBX_RXM_PMP_message_data_t *);
+  UBX_RXM_PMP_message_data_t *callbackData;
+} UBX_RXM_PMP_message_t;
+
 // CFG-specific structs
 
+// UBX-CFG-PRT (0x06 0x00): Port configuration
+// The content changes depending on which port type is being configured
+// This struct defines the common structure
+const uint16_t UBX_CFG_PRT_LEN = 20;
+
+typedef struct
+{
+  uint8_t portID;    // Port identifier number
+  uint8_t reserved0; // Reserved
+  union
+  {
+    uint16_t all;
+    struct
+    {
+      uint16_t en : 1;    // Enable TX ready feature for this port
+      uint16_t pol : 1;   // Polarity: 0 High-active; 1 Low-active
+      uint16_t pin : 5;   // PIO to be used (must not be in use by another function)
+      uint16_t thres : 9; // Threshold
+    } bits;
+  } txReady;
+  uint32_t mode;     // Content changes depending on the port type
+  uint32_t baudRate; // Content changes depending on the port type
+  union
+  {
+    uint16_t all;
+    struct
+    {
+      uint16_t inUbx : 1;  // UBX protocol
+      uint16_t inNmea : 1; // NMEA protocol
+      uint16_t inRtcm : 1; // RTCM2 protocol
+      uint16_t reserved : 2;
+      uint16_t inRtcm3 : 1; // RTCM3 protocol (not supported for protocol versions less than 20.00)
+      uint16_t inSPARTN : 1;
+    } bits;
+  } inProtoMask;
+  union
+  {
+    uint16_t all;
+    struct
+    {
+      uint16_t outUbx : 1;  // UBX protocol
+      uint16_t outNmea : 1; // NMEA protocol
+      uint16_t reserved : 3;
+      uint16_t outRtcm3 : 1; // RTCM3 protocol (not supported for protocol versions less than 20.00)
+      uint16_t outSPARTN : 1;
+    } bits;
+  } outProtoMask;
+  uint16_t flags; // Content changes depending on the port type
+  uint16_t reserved1;
+} UBX_CFG_PRT_data_t;
+
+typedef struct
+{
+  UBX_CFG_PRT_data_t data;
+  bool dataValid;
+} UBX_CFG_PRT_t;
+
 // UBX-CFG-RATE (0x06 0x08): Navigation/measurement rate settings
 const uint16_t UBX_CFG_RATE_LEN = 6;
 
@@ -1523,8 +1630,6 @@ typedef struct
   ubxAutomaticFlags automaticFlags;
   UBX_CFG_RATE_data_t data;
   UBX_CFG_RATE_moduleQueried_t moduleQueried;
-  void (*callbackPointer)(UBX_CFG_RATE_data_t);
-  UBX_CFG_RATE_data_t  *callbackData;
 } UBX_CFG_RATE_t;
 
 // UBX-CFG-TP5 (0x06 0x31): Time pulse parameters
@@ -1630,6 +1735,7 @@ typedef struct
   UBX_TIM_TM2_data_t data;
   UBX_TIM_TM2_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_TIM_TM2_data_t);
+  void (*callbackPointerPtr)(UBX_TIM_TM2_data_t *);
   UBX_TIM_TM2_data_t *callbackData;
 } UBX_TIM_TM2_t;
 
@@ -1704,6 +1810,7 @@ typedef struct
   UBX_ESF_ALG_data_t data;
   UBX_ESF_ALG_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_ESF_ALG_data_t);
+  void (*callbackPointerPtr)(UBX_ESF_ALG_data_t *);
   UBX_ESF_ALG_data_t *callbackData;
 } UBX_ESF_ALG_t;
 
@@ -1770,6 +1877,7 @@ typedef struct
   UBX_ESF_INS_data_t data;
   UBX_ESF_INS_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_ESF_INS_data_t);
+  void (*callbackPointerPtr)(UBX_ESF_INS_data_t *);
   UBX_ESF_INS_data_t *callbackData;
 } UBX_ESF_INS_t;
 
@@ -1840,6 +1948,7 @@ typedef struct
   UBX_ESF_MEAS_data_t data;
   UBX_ESF_MEAS_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_ESF_MEAS_data_t);
+  void (*callbackPointerPtr)(UBX_ESF_MEAS_data_t *);
   UBX_ESF_MEAS_data_t *callbackData;
 } UBX_ESF_MEAS_t;
 
@@ -1887,6 +1996,7 @@ typedef struct
   UBX_ESF_RAW_data_t data;
   UBX_ESF_RAW_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_ESF_RAW_data_t);
+  void (*callbackPointerPtr)(UBX_ESF_RAW_data_t *);
   UBX_ESF_RAW_data_t *callbackData;
 } UBX_ESF_RAW_t;
 
@@ -1974,6 +2084,7 @@ typedef struct
   UBX_ESF_STATUS_data_t data;
   UBX_ESF_STATUS_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_ESF_STATUS_data_t);
+  void (*callbackPointerPtr)(UBX_ESF_STATUS_data_t *);
   UBX_ESF_STATUS_data_t *callbackData;
 } UBX_ESF_STATUS_t;
 
@@ -2144,6 +2255,7 @@ typedef struct
   UBX_HNR_PVT_data_t data;
   UBX_HNR_PVT_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_HNR_PVT_data_t);
+  void (*callbackPointerPtr)(UBX_HNR_PVT_data_t *);
   UBX_HNR_PVT_data_t *callbackData;
 } UBX_HNR_PVT_t;
 
@@ -2190,6 +2302,7 @@ typedef struct
   UBX_HNR_ATT_data_t data;
   UBX_HNR_ATT_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_HNR_ATT_data_t);
+  void (*callbackPointerPtr)(UBX_HNR_ATT_data_t *);
   UBX_HNR_ATT_data_t *callbackData;
 } UBX_HNR_ATT_t;
 
@@ -2256,6 +2369,7 @@ typedef struct
   UBX_HNR_INS_data_t data;
   UBX_HNR_INS_moduleQueried_t moduleQueried;
   void (*callbackPointer)(UBX_HNR_INS_data_t);
+  void (*callbackPointerPtr)(UBX_HNR_INS_data_t *);
   UBX_HNR_INS_data_t *callbackData;
 } UBX_HNR_INS_t;
 
@@ -2295,6 +2409,7 @@ typedef struct
   NMEA_GGA_data_t workingCopy;  // Incoming data is added to the working copy
   NMEA_GGA_data_t completeCopy; // The working copy is copied into the complete copy when all data has been received and the checksum is valid
   void (*callbackPointer)(NMEA_GGA_data_t);
+  void (*callbackPointerPtr)(NMEA_GGA_data_t *);
   NMEA_GGA_data_t *callbackCopy; // The callback gets its own preserved copy of the complete copy
 } NMEA_GPGGA_t;
 
@@ -2304,6 +2419,7 @@ typedef struct
   NMEA_GGA_data_t workingCopy;  // Incoming data is added to the working copy
   NMEA_GGA_data_t completeCopy; // The working copy is copied into the complete copy when all data has been received and the checksum is valid
   void (*callbackPointer)(NMEA_GGA_data_t);
+  void (*callbackPointerPtr)(NMEA_GGA_data_t *);
   NMEA_GGA_data_t *callbackCopy; // The callback gets its own preserved copy of the complete copy
 } NMEA_GNGGA_t;