Merge pull request #5 from sparkfun/master

Update

examples/Example16_Nanosecond_MaxOutput/Example16_Nanosecond_MaxOutput.ino

@@ -99,8 +99,8 @@ void loop()
     Serial.print(myGNSS.getMinute());
     Serial.print(":");
     Serial.print(myGNSS.getSecond());
-    Serial.print(".");
-    Serial.print(myGNSS.getNanosecond());
+    Serial.print(" nanoseconds: ");
+    Serial.print(myGNSS.getNanosecond()); // Nanoseconds can be negative
 
     myGNSS.flushPVT();
 

examples/Example16_PartialSecond_MaxOutput/Example16_PartialSecond_MaxOutput.ino

@@ -110,7 +110,7 @@ void loop()
       Serial.print("0");
     Serial.print(mseconds);
 
-    Serial.print(" nanoSeconds: ");
+    Serial.print(" nanoseconds: ");
     Serial.print(myGNSS.getNanosecond());
 
     Serial.println();

examples/Example24_GetUnixEpochAndMicros/Example24_GetUnixEpochAndMicros.ino

@@ -1,7 +1,7 @@
 /*
   Getting Unix Epoch Time and micros using u-blox commands
   By: UT2UH
-  Date: March 30th, 2021
+  Date: March 31th, 2021
   License: MIT. See license file for more information but you can
   basically do whatever you want with this code.
 
@@ -69,8 +69,11 @@ void loop()
     // getUnixEpoch marks the PVT data as stale so you will get Unix time and PVT time on alternate seconds
 
     uint32_t us;  //microseconds returned by getUnixEpoch()
-    uint32_t epoch = myGNSS.getUnixEpoch(us);
-    Serial.print("Unix Epoch: ");
+    uint32_t epoch = myGNSS.getUnixEpoch();
+    Serial.print("Unix Epoch rounded: ");
+    Serial.print(epoch, DEC);    
+    epoch = myGNSS.getUnixEpoch(us);
+    Serial.print("  Exact Unix Epoch: ");
     Serial.print(epoch, DEC);
     Serial.print("  micros: ");
     Serial.println(us, DEC);
@@ -105,4 +108,4 @@ void loop()
     Serial.print(F("  SIV: "));
     Serial.println(SIV);
   }
-}
+}

examples/Example26_End/Example26_End.ino

@@ -0,0 +1,91 @@
+/*
+  Demonstrating how to use "end"
+  By: Paul Clark
+  SparkFun Electronics
+  Date: April 1st, 2021
+  License: MIT. See license file for more information but you can
+  basically do whatever you want with this code.
+
+  This example shows how to use the end function.
+  End will stop all automatic message processing and free (nearly) all used RAM.
+  The file buffer is deleted (if it exists).
+  
+  Feel like supporting open source hardware?
+  Buy a board from SparkFun!
+  ZED-F9P RTK2: https://www.sparkfun.com/products/15136
+  NEO-M8P RTK: https://www.sparkfun.com/products/15005
+  SAM-M8Q: https://www.sparkfun.com/products/15106
+
+  Hardware Connections:
+  Plug a Qwiic cable into the GNSS and a BlackBoard
+  If you don't have a platform with a Qwiic connection use the SparkFun Qwiic Breadboard Jumper (https://www.sparkfun.com/products/14425)
+  Open the serial monitor at 115200 baud to see the output
+*/
+
+#include <Wire.h> //Needed for I2C to GNSS
+
+#include <SparkFun_u-blox_GNSS_Arduino_Library.h> //http://librarymanager/All#SparkFun_u-blox_GNSS
+SFE_UBLOX_GNSS myGNSS;
+
+void setup()
+{
+  Serial.begin(115200);
+  while (!Serial); //Wait for user to open terminal
+  Serial.println("SparkFun u-blox Example");
+
+  Wire.begin();
+
+  //myGNSS.enableDebugging(); // Uncomment this line to enable helpful debug messages on Serial
+  
+  if (myGNSS.begin() == false) //Connect to the u-blox module using Wire port
+  {
+    Serial.println(F("u-blox GNSS not detected at default I2C address. Please check wiring. Freezing."));
+    while (1);
+  }
+
+  myGNSS.setI2COutput(COM_TYPE_UBX); //Set the I2C port to output UBX only (turn off NMEA noise)
+  //myGNSS.saveConfiguration(); //Optional: Save the current settings to flash and BBR
+
+  myGNSS.end(); // Call end now just because we can - it won't do much as we haven't used any automatic messages
+}
+
+void loop()
+{
+  // Allocate 128 bytes for file storage - this checks that issue #20 has been resolved
+  // Allocating only 128 bytes will let this code run on the ATmega328P
+  // If your processor has plenty of RAM, you can increase this to something useful like 16KB
+  myGNSS.setFileBufferSize(128);
+  
+  if (myGNSS.begin() == false) //Connect to the u-blox module using Wire port
+  {
+    Serial.println(F("u-blox GNSS not detected. Freezing."));
+    while (1);
+  }
+
+  Serial.print(F("The file buffer size is: "));
+  Serial.println(myGNSS.getFileBufferSize());    
+
+  // Request Position, Velocity, Time
+  // RAM will be allocated for PVT message processing
+  // getPVT will return true is fresh PVT data was received and processed
+  if (myGNSS.getPVT())
+  {
+    long latitude = myGNSS.getLatitude();
+    Serial.print(F("Lat: "));
+    Serial.print(latitude);
+
+    long longitude = myGNSS.getLongitude();
+    Serial.print(F(" Long: "));
+    Serial.print(longitude);
+    Serial.print(F(" (degrees * 10^-7)"));
+
+    long altitude = myGNSS.getAltitude();
+    Serial.print(F(" Alt: "));
+    Serial.print(altitude);
+    Serial.println(F(" (mm)"));
+  }
+
+  // Calling end will free the RAM allocated for file storage and PVT processing
+  // Calling end is optional. You can comment the next line if you want to.
+  myGNSS.end();
+}

examples/Example27_MultipleRates/Example27_MultipleRates.ino

@@ -0,0 +1,106 @@
+/*
+  Configuring the GNSS to produce multiple messages at different rates
+  By: Paul Clark
+  SparkFun Electronics
+  Date: April 1st, 2021
+  License: MIT. See license file for more information but you can
+  basically do whatever you want with this code.
+
+  This example shows how to configure the U-Blox GNSS to output multiple messages at different rates:
+  PVT is output every second;
+  POSECEF is output every five seconds;
+  VELNED is output every ten seconds.
+
+  Feel like supporting open source hardware?
+  Buy a board from SparkFun!
+  ZED-F9P RTK2: https://www.sparkfun.com/products/15136
+  NEO-M8P RTK: https://www.sparkfun.com/products/15005
+  SAM-M8Q: https://www.sparkfun.com/products/15106
+
+  Hardware Connections:
+  Plug a Qwiic cable into the GNSS and a BlackBoard
+  If you don't have a platform with a Qwiic connection use the SparkFun Qwiic Breadboard Jumper (https://www.sparkfun.com/products/14425)
+  Open the serial monitor at 115200 baud to see the output
+*/
+
+#include <Wire.h> //Needed for I2C to GNSS
+
+#include <SparkFun_u-blox_GNSS_Arduino_Library.h> //http://librarymanager/All#SparkFun_u-blox_GNSS
+SFE_UBLOX_GNSS myGNSS;
+
+void setup()
+{
+  Serial.begin(115200);
+  while (!Serial); //Wait for user to open terminal
+  Serial.println("SparkFun u-blox Example");
+
+  Wire.begin();
+
+  if (myGNSS.begin() == false) //Connect to the u-blox module using Wire port
+  {
+    Serial.println(F("u-blox GNSS not detected at default I2C address. Please check wiring. Freezing."));
+    while (1);
+  }
+
+  myGNSS.setI2COutput(COM_TYPE_UBX); //Set the I2C port to output UBX only (turn off NMEA noise)
+  myGNSS.setMeasurementRate(1000); //Produce a measurement every 1000ms
+  myGNSS.setNavigationRate(1); //Produce a navigation solution every measurement
+  
+  myGNSS.setAutoPVTrate(1); //Tell the GNSS to send the PVT solution every measurement
+  myGNSS.setAutoNAVPOSECEFrate(5); //Tell the GNSS to send each POSECEF solution every 5th measurement
+  myGNSS.setAutoNAVVELNEDrate(10); //Tell the GNSS to send each VELNED solution every 10th measurement
+  //myGNSS.saveConfiguration(); //Optional: Save the current settings to flash and BBR
+}
+
+void loop()
+{
+  // Calling getPVT returns true if there actually is a fresh navigation solution available.
+  if (myGNSS.getPVT())
+  {
+    long latitude = myGNSS.getLatitude();
+    Serial.print(F("Lat: "));
+    Serial.print(latitude);
+
+    long longitude = myGNSS.getLongitude();
+    Serial.print(F(" Long: "));
+    Serial.print(longitude);
+    Serial.print(F(" (degrees * 10^-7)"));
+
+    long altitude = myGNSS.getAltitude();
+    Serial.print(F(" Alt: "));
+    Serial.print(altitude);
+    Serial.println(F(" (mm)"));
+  }
+
+  // Calling getNAVPOSECEF returns true if there actually is a fresh position solution available.
+  if (myGNSS.getNAVPOSECEF())
+  {
+    Serial.print(F("ecefX: "));
+    Serial.print((float)myGNSS.packetUBXNAVPOSECEF->data.ecefX / 100.0, 2); // convert ecefX to m
+
+    Serial.print(F(" ecefY: "));
+    Serial.print((float)myGNSS.packetUBXNAVPOSECEF->data.ecefY / 100.0, 2); // convert ecefY to m
+
+    Serial.print(F(" ecefZ: "));
+    Serial.print((float)myGNSS.packetUBXNAVPOSECEF->data.ecefZ / 100.0, 2); // convert ecefY to m
+    Serial.println(F(" (m)"));
+
+    myGNSS.flushNAVPOSECEF(); //Mark all the data as read/stale so we get fresh data next time
+  }
+
+  // Calling getNAVVELNED returns true if there actually is fresh velocity data available.
+  if (myGNSS.getNAVVELNED())
+  {
+    Serial.print(F("velN: "));
+    Serial.print((float)myGNSS.packetUBXNAVVELNED->data.velN / 100.0, 2); // convert velN to m/s
+
+    Serial.print(F(" velE: "));
+    Serial.print((float)myGNSS.packetUBXNAVVELNED->data.velE / 100.0, 2); // convert velE to m/s
+
+    Serial.print(F(" velD: "));
+    Serial.print((float)myGNSS.packetUBXNAVVELNED->data.velD / 100.0, 2); // convert velD to m/s
+    Serial.println(F(" (m/s)"));
+
+    myGNSS.flushNAVVELNED(); //Mark all the data as read/stale so we get fresh data next time
+  }
+}

examples/ZED-F9P/Example10_GetHighPrecisionPositionAndAccuracy/Example10_GetHighPrecisionPositionAndAccuracy.ino

@@ -115,11 +115,12 @@ void loop()
     Serial.print("Lat (deg): ");
     Serial.print(lat_int); // Print the integer part of the latitude
     Serial.print(".");
-    Serial.print(lat_frac); // Print the fractional part of the latitude
+    printFractional(lat_frac, 9); // Print the fractional part of the latitude with leading zeros
     Serial.print(", Lon (deg): ");
     Serial.print(lon_int); // Print the integer part of the latitude
     Serial.print(".");
-    Serial.println(lon_frac); // Print the fractional part of the latitude
+    printFractional(lon_frac, 9); // Print the fractional part of the latitude with leading zeros
+    Serial.println();
 
     // Now define float storage for the heights and accuracy
     float f_ellipsoid;
@@ -152,3 +153,20 @@ void loop()
     Serial.println(f_accuracy, 4); // Print the accuracy with 4 decimal places
   }
 }
+
+// Pretty-print the fractional part with leading zeros - without using printf
+// (Only works with positive numbers)
+void printFractional(int32_t fractional, uint8_t places)
+{
+  if (places > 1)
+  {
+    for (uint8_t place = places - 1; place > 0; place--)
+    {
+      if (fractional < pow(10, place))
+      {
+        Serial.print("0");
+      }
+    }
+  }
+  Serial.print(fractional);
+}

keywords.txt

@@ -50,6 +50,7 @@ UBX_HNR_INS_data_t	KEYWORD1
 
 setPacketCfgPayloadSize	KEYWORD2
 begin	KEYWORD2
+end	KEYWORD2
 setI2CpollingWait	KEYWORD2
 setI2CTransactionSize	KEYWORD2
 getI2CTransactionSize	KEYWORD2
@@ -81,6 +82,7 @@ checkCallbacks	KEYWORD2
 pushRawData	KEYWORD2
 
 setFileBufferSize	KEYWORD2
+getFileBufferSize	KEYWORD2
 extractFileBufferData	KEYWORD2
 fileBufferAvailable	KEYWORD2
 getMaxFileBufferAvail	KEYWORD2
@@ -164,7 +166,7 @@ sendCfgValset32	KEYWORD2
 
 getNAVPOSECEF	KEYWORD2
 setAutoNAVPOSECEF	KEYWORD2
-setAutoNAVPOSECEF	KEYWORD2
+setAutoNAVPOSECEFrate	KEYWORD2
 setAutoNAVPOSECEFcallback	KEYWORD2
 assumeAutoNAVPOSECEF	KEYWORD2
 initPacketUBXNAVPOSECEF	KEYWORD2
@@ -173,7 +175,7 @@ logNAVPOSECEF	KEYWORD2
 
 getNAVSTATUS	KEYWORD2
 setAutoNAVSTATUS	KEYWORD2
-setAutoNAVSTATUS	KEYWORD2
+setAutoNAVSTATUSrate	KEYWORD2
 setAutoNAVSTATUScallback	KEYWORD2
 assumeAutoNAVSTATUS	KEYWORD2
 initPacketUBXNAVSTATUS	KEYWORD2
@@ -182,7 +184,7 @@ logNAVSTATUS	KEYWORD2
 
 getDOP	KEYWORD2
 setAutoDOP	KEYWORD2
-setAutoDOP	KEYWORD2
+setAutoDOPrate	KEYWORD2
 setAutoDOPcallback	KEYWORD2
 assumeAutoDOP	KEYWORD2
 initPacketUBXNAVDOP	KEYWORD2
@@ -192,7 +194,7 @@ logNAVDOP	KEYWORD2
 getVehAtt	KEYWORD2
 getNAVATT	KEYWORD2
 setAutoNAVATT	KEYWORD2
-setAutoNAVATT	KEYWORD2
+setAutoNAVATTrate	KEYWORD2
 setAutoNAVATTcallback	KEYWORD2
 assumeAutoNAVATT	KEYWORD2
 initPacketUBXNAVATT	KEYWORD2
@@ -201,7 +203,7 @@ logNAVATT	KEYWORD2
 
 getPVT	KEYWORD2
 setAutoPVT	KEYWORD2
-setAutoPVT	KEYWORD2
+setAutoPVTrate	KEYWORD2
 setAutoPVTcallback	KEYWORD2
 assumeAutoPVT	KEYWORD2
 initPacketUBXNAVPVT	KEYWORD2
@@ -210,7 +212,7 @@ logNAVPVT	KEYWORD2
 
 getNAVODO	KEYWORD2
 setAutoNAVODO	KEYWORD2
-setAutoNAVODO	KEYWORD2
+setAutoNAVODOrate	KEYWORD2
 setAutoNAVODOcallback	KEYWORD2
 assumeAutoNAVODO	KEYWORD2
 initPacketUBXNAVODO	KEYWORD2
@@ -219,7 +221,7 @@ logNAVODO	KEYWORD2
 
 getNAVVELECEF	KEYWORD2
 setAutoNAVVELECEF	KEYWORD2
-setAutoNAVVELECEF	KEYWORD2
+setAutoNAVVELECEFrate	KEYWORD2
 setAutoNAVVELECEFcallback	KEYWORD2
 assumeAutoNAVVELECEF	KEYWORD2
 initPacketUBXNAVVELECEF	KEYWORD2
@@ -228,6 +230,7 @@ logNAVVELECEF	KEYWORD2
 
 getNAVVELNED	KEYWORD2
 setAutoNAVVELNED	KEYWORD2
+setAutoNAVVELNEDrate	KEYWORD2
 setAutoNAVVELNEDcallback	KEYWORD2
 assumeAutoNAVVELNED	KEYWORD2
 initPacketUBXNAVVELNED	KEYWORD2
@@ -236,7 +239,7 @@ logNAVVELNED	KEYWORD2
 
 getNAVHPPOSECEF	KEYWORD2
 setAutoNAVHPPOSECEF	KEYWORD2
-setAutoNAVHPPOSECEF	KEYWORD2
+setAutoNAVHPPOSECEFrate	KEYWORD2
 setAutoNAVHPPOSECEFcallback	KEYWORD2
 assumeAutoNAVHPPOSECEF	KEYWORD2
 initPacketUBXNAVHPPOSECEF	KEYWORD2
@@ -245,7 +248,7 @@ logNAVHPPOSECEF	KEYWORD2
 
 getHPPOSLLH	KEYWORD2
 setAutoHPPOSLLH	KEYWORD2
-setAutoHPPOSLLH	KEYWORD2
+setAutoHPPOSLLHrate	KEYWORD2
 setAutoHPPOSLLHcallback	KEYWORD2
 assumeAutoHPPOSLLH	KEYWORD2
 initPacketUBXNAVHPPOSLLH	KEYWORD2
@@ -254,7 +257,7 @@ logNAVHPPOSLLH	KEYWORD2
 
 getNAVCLOCK	KEYWORD2
 setAutoNAVCLOCK	KEYWORD2
-setAutoNAVCLOCK	KEYWORD2
+setAutoNAVCLOCKrate	KEYWORD2
 setAutoNAVCLOCKcallback	KEYWORD2
 assumeAutoNAVCLOCK	KEYWORD2
 initPacketUBXNAVCLOCK	KEYWORD2
@@ -266,6 +269,7 @@ initPacketUBXNAVSVIN	KEYWORD2
 
 getRELPOSNED	KEYWORD2
 setAutoRELPOSNED	KEYWORD2
+setAutoRELPOSNEDrate	KEYWORD2
 setAutoRELPOSNEDcallback	KEYWORD2
 assumeAutoRELPOSNED	KEYWORD2
 initPacketUBXNAVRELPOSNED	KEYWORD2
@@ -274,6 +278,7 @@ logNAVRELPOSNED	KEYWORD2
 
 getRXMSFRBX	KEYWORD2
 setAutoRXMSFRBX	KEYWORD2
+setAutoRXMSFRBXrate	KEYWORD2
 setAutoRXMSFRBXcallback	KEYWORD2
 assumeAutoRXMSFRBX	KEYWORD2
 initPacketUBXRXMSFRBX	KEYWORD2
@@ -282,7 +287,7 @@ logRXMSFRBX	KEYWORD2
 
 getRXMRAWX	KEYWORD2
 setAutoRXMRAWX	KEYWORD2
-setAutoRXMRAWX	KEYWORD2
+setAutoRXMRAWXrate	KEYWORD2
 setAutoRXMRAWXcallback	KEYWORD2
 assumeAutoRXMRAWX	KEYWORD2
 initPacketUBXRXMRAWX	KEYWORD2
@@ -291,6 +296,7 @@ logRXMRAWX	KEYWORD2
 
 getTIMTM2	KEYWORD2
 setAutoTIMTM2	KEYWORD2
+setAutoTIMTM2rate	KEYWORD2
 setAutoTIMTM2callback	KEYWORD2
 assumeAutoTIMTM2	KEYWORD2
 initPacketUBXTIMTM2	KEYWORD2
@@ -300,6 +306,7 @@ logTIMTM2	KEYWORD2
 getEsfAlignment	KEYWORD2
 getESFALG	KEYWORD2
 setAutoESFALG	KEYWORD2
+setAutoESFALGrate	KEYWORD2
 setAutoESFALGcallback	KEYWORD2
 assumeAutoESFALG	KEYWORD2
 initPacketUBXESFALG	KEYWORD2
@@ -309,6 +316,7 @@ logESFALG	KEYWORD2
 getEsfInfo	KEYWORD2
 getESFSTATUS	KEYWORD2
 setAutoESFSTATUS	KEYWORD2
+setAutoESFSTATUSrate	KEYWORD2
 setAutoESFSTATUScallback	KEYWORD2
 assumeAutoESFSTATUS	KEYWORD2
 initPacketUBXESFSTATUS	KEYWORD2
@@ -318,6 +326,7 @@ logESFSTATUS	KEYWORD2
 getEsfIns	KEYWORD2
 getESFINS	KEYWORD2
 setAutoESFINS	KEYWORD2
+setAutoESFINSrate	KEYWORD2
 setAutoESFINScallback	KEYWORD2
 assumeAutoESFINS	KEYWORD2
 initPacketUBXESFINS	KEYWORD2
@@ -327,6 +336,7 @@ logESFINS	KEYWORD2
 getEsfDataInfo	KEYWORD2
 getESFMEAS	KEYWORD2
 setAutoESFMEAS	KEYWORD2
+setAutoESFMEASrate	KEYWORD2
 setAutoESFMEAScallback	KEYWORD2
 assumeAutoESFMEAS	KEYWORD2
 initPacketUBXESFMEAS	KEYWORD2
@@ -336,6 +346,7 @@ logESFMEAS	KEYWORD2
 getEsfRawDataInfo	KEYWORD2
 getESFRAW	KEYWORD2
 setAutoESFRAW	KEYWORD2
+setAutoESFRAWrate	KEYWORD2
 setAutoESFRAWcallback	KEYWORD2
 assumeAutoESFRAW	KEYWORD2
 initPacketUBXESFRAW	KEYWORD2
@@ -345,6 +356,7 @@ logESFRAW	KEYWORD2
 getHNRAtt	KEYWORD2
 getHNRATT	KEYWORD2
 setAutoHNRATT	KEYWORD2
+setAutoHNRATTrate	KEYWORD2
 setAutoHNRATTcallback	KEYWORD2
 assumeAutoHNRATT	KEYWORD2
 initPacketUBXHNRATT	KEYWORD2
@@ -354,6 +366,7 @@ logHNRATT	KEYWORD2
 getHNRDyn	KEYWORD2
 getHNRINS	KEYWORD2
 setAutoHNRINS	KEYWORD2
+setAutoHNRINSrate	KEYWORD2
 setAutoHNRINScallback	KEYWORD2
 assumeAutoHNRINS	KEYWORD2
 initPacketUBXHNRINS	KEYWORD2
@@ -362,7 +375,7 @@ logHNRINS	KEYWORD2
 
 getHNRPVT	KEYWORD2
 setAutoHNRPVT	KEYWORD2
-setAutoHNRPVT	KEYWORD2
+setAutoHNRPVTrate	KEYWORD2
 setAutoHNRPVTcallback	KEYWORD2
 assumeAutoHNRPVT	KEYWORD2
 initPacketUBXHNRPVT	KEYWORD2

library.properties

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

src/SparkFun_u-blox_GNSS_Arduino_Library.h

@@ -482,6 +482,8 @@ public:
 	//serialPort needs to be perviously initialized to correct baud rate
 	boolean begin(Stream &serialPort); //Returns true if module is detected
 
+	void end(void); //Stop all automatic message processing. Free all used RAM
+
 	void setI2CpollingWait(uint8_t newPollingWait_ms); // Allow the user to change the I2C polling wait if required
 
 	//Control the size of the internal I2C transaction amount
@@ -564,6 +566,7 @@ public:
 
 	// Support for data logging
 	void setFileBufferSize(uint16_t bufferSize); // Set the size of the file buffer. This must be called _before_ .begin.
+	uint16_t getFileBufferSize(void); // Return the size of the file buffer
 	uint16_t extractFileBufferData(uint8_t *destination, uint16_t numBytes); // Extract numBytes of data from the file buffer. Copy it to destination. It is the user's responsibility to ensure destination is large enough.
 	uint16_t fileBufferAvailable(void);		// Returns the number of bytes available in file buffer which are waiting to be read
 	uint16_t getMaxFileBufferAvail(void);	// Returns the maximum number of bytes which the file buffer has contained. Handy for checking the buffer is large enough to handle all the incoming data.
@@ -697,6 +700,7 @@ public:
 	boolean getNAVPOSECEF(uint16_t maxWait = defaultMaxWait); // NAV POSECEF
 	boolean setAutoNAVPOSECEF(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic POSECEF reports at the navigation frequency
 	boolean setAutoNAVPOSECEF(boolean enabled, boolean 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
+	boolean setAutoNAVPOSECEFrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic POSECEF reports
 	boolean 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.
 	boolean assumeAutoNAVPOSECEF(boolean enabled, boolean 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
@@ -705,6 +709,7 @@ public:
 	boolean getNAVSTATUS(uint16_t maxWait = defaultMaxWait); // NAV STATUS
 	boolean setAutoNAVSTATUS(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic STATUS reports at the navigation frequency
 	boolean setAutoNAVSTATUS(boolean enabled, boolean 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
+	boolean setAutoNAVSTATUSrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic STATUS reports
 	boolean 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.
 	boolean assumeAutoNAVSTATUS(boolean enabled, boolean 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
@@ -713,6 +718,7 @@ public:
 	boolean getDOP(uint16_t maxWait = defaultMaxWait); //Query module for latest dilution of precision values and load global vars:. If autoDOP is disabled, performs an explicit poll and waits, if enabled does not block. Returns true if new DOP is available.
 	boolean setAutoDOP(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic DOP reports at the navigation frequency
 	boolean setAutoDOP(boolean enabled, boolean implicitUpdate, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic DOP reports at the navigation frequency, with implicitUpdate == false accessing stale data will not issue parsing of data in the rxbuffer of your interface, instead you have to call checkUblox when you want to perform an update
+	boolean setAutoDOPrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic DOP reports
 	boolean 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.
 	boolean assumeAutoDOP(boolean enabled, boolean 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
@@ -722,6 +728,7 @@ public:
 	boolean getNAVATT(uint16_t maxWait = defaultMaxWait); // NAV ATT
 	boolean setAutoNAVATT(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic vehicle attitude reports at the navigation frequency
 	boolean setAutoNAVATT(boolean enabled, boolean 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
+	boolean setAutoNAVATTrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic ATT reports
 	boolean 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.
 	boolean assumeAutoNAVATT(boolean enabled, boolean 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
@@ -730,6 +737,7 @@ public:
 	boolean getPVT(uint16_t maxWait = defaultMaxWait);	//Query module for latest group of datums and load global vars: lat, long, alt, speed, SIV, accuracies, etc. If autoPVT is disabled, performs an explicit poll and waits, if enabled does not block. Returns true if new PVT is available.
 	boolean setAutoPVT(boolean enabled, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic PVT reports at the navigation frequency
 	boolean setAutoPVT(boolean enabled, boolean 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
+	boolean setAutoPVTrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic PVT reports
 	boolean 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.
 	boolean assumeAutoPVT(boolean enabled, boolean 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
@@ -738,6 +746,7 @@ public:
 	boolean getNAVODO(uint16_t maxWait = defaultMaxWait); // NAV ODO
 	boolean setAutoNAVODO(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic ODO reports at the navigation frequency
 	boolean setAutoNAVODO(boolean enabled, boolean 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
+	boolean setAutoNAVODOrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic ODO reports
 	boolean 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.
 	boolean assumeAutoNAVODO(boolean enabled, boolean 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
@@ -746,6 +755,7 @@ public:
 	boolean getNAVVELECEF(uint16_t maxWait = defaultMaxWait); // NAV VELECEF
 	boolean setAutoNAVVELECEF(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic VELECEF reports at the navigation frequency
 	boolean setAutoNAVVELECEF(boolean enabled, boolean 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
+	boolean setAutoNAVVELECEFrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic VELECEF reports
 	boolean 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.
 	boolean assumeAutoNAVVELECEF(boolean enabled, boolean 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
@@ -754,6 +764,7 @@ public:
 	boolean getNAVVELNED(uint16_t maxWait = defaultMaxWait); // NAV VELNED
 	boolean setAutoNAVVELNED(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic VELNED reports at the navigation frequency
 	boolean setAutoNAVVELNED(boolean enabled, boolean 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
+	boolean setAutoNAVVELNEDrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic VELNED reports
 	boolean 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.
 	boolean assumeAutoNAVVELNED(boolean enabled, boolean 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
@@ -762,6 +773,7 @@ public:
 	boolean getNAVHPPOSECEF(uint16_t maxWait = defaultMaxWait); // NAV HPPOSECEF
 	boolean setAutoNAVHPPOSECEF(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic HPPOSECEF reports at the navigation frequency
 	boolean setAutoNAVHPPOSECEF(boolean enabled, boolean 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
+	boolean setAutoNAVHPPOSECEFrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic HPPOSECEF reports
 	boolean 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.
 	boolean assumeAutoNAVHPPOSECEF(boolean enabled, boolean 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
@@ -770,6 +782,7 @@ public:
 	boolean getHPPOSLLH(uint16_t maxWait = defaultMaxWait); //Query module for latest group of datums and load global vars: lat, long, alt, speed, SIV, accuracies, etc. If autoPVT is disabled, performs an explicit poll and waits, if enabled does not block. Returns true if new HPPOSLLH is available.
 	boolean setAutoHPPOSLLH(boolean enabled, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic HPPOSLLH reports at the navigation frequency
 	boolean setAutoHPPOSLLH(boolean enabled, boolean implicitUpdate, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic HPPOSLLH reports at the navigation frequency, with implicitUpdate == false accessing stale data will not issue parsing of data in the rxbuffer of your interface, instead you have to call checkUblox when you want to perform an update
+	boolean setAutoHPPOSLLHrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic HPPOSLLH reports
 	boolean 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.
 	boolean assumeAutoHPPOSLLH(boolean enabled, boolean 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
@@ -778,6 +791,7 @@ public:
 	boolean getNAVCLOCK(uint16_t maxWait = defaultMaxWait); // NAV CLOCK
 	boolean setAutoNAVCLOCK(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic clock reports at the navigation frequency
 	boolean setAutoNAVCLOCK(boolean enabled, boolean 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
+	boolean setAutoNAVCLOCKrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic CLOCK reports
 	boolean 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.
 	boolean assumeAutoNAVCLOCK(boolean enabled, boolean 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
@@ -789,6 +803,7 @@ public:
 	boolean getRELPOSNED(uint16_t maxWait = defaultMaxWait); //Get Relative Positioning Information of the NED frame
 	boolean setAutoRELPOSNED(boolean enabled, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic RELPOSNED reports
 	boolean setAutoRELPOSNED(boolean enabled, boolean 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
+	boolean setAutoRELPOSNEDrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic RELPOSNEDreports
 	boolean 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.
 	boolean assumeAutoRELPOSNED(boolean enabled, boolean 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
@@ -799,6 +814,7 @@ public:
 	boolean getRXMSFRBX(uint16_t maxWait = defaultMaxWait); // RXM SFRBX
 	boolean setAutoRXMSFRBX(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic RXM SFRBX reports at the navigation frequency
 	boolean setAutoRXMSFRBX(boolean enabled, boolean 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
+	boolean setAutoRXMSFRBXrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic SFRBX reports
 	boolean 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.
 	boolean assumeAutoRXMSFRBX(boolean enabled, boolean 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
@@ -807,6 +823,7 @@ public:
 	boolean getRXMRAWX(uint16_t maxWait = defaultMaxWait); // RXM RAWX
 	boolean setAutoRXMRAWX(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic RXM RAWX reports at the navigation frequency
 	boolean setAutoRXMRAWX(boolean enabled, boolean 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
+	boolean setAutoRXMRAWXrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic RAWX reports
 	boolean 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.
 	boolean assumeAutoRXMRAWX(boolean enabled, boolean 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
@@ -822,6 +839,7 @@ public:
 	boolean getTIMTM2(uint16_t maxWait = defaultMaxWait); // TIM TM2
 	boolean setAutoTIMTM2(boolean enabled, uint16_t maxWait = defaultMaxWait);  //Enable/disable automatic TIM TM2 reports at the navigation frequency
 	boolean setAutoTIMTM2(boolean enabled, boolean 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
+	boolean setAutoTIMTM2rate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic TIM TM2 reports
 	boolean 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.
 	boolean assumeAutoTIMTM2(boolean enabled, boolean 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
@@ -833,6 +851,7 @@ public:
 	boolean getESFALG(uint16_t maxWait = defaultMaxWait); // ESF ALG
 	boolean setAutoESFALG(boolean enabled, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic ESF ALG reports
 	boolean setAutoESFALG(boolean enabled, boolean 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
+	boolean setAutoESFALGrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic ALG reports
 	boolean 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.
 	boolean assumeAutoESFALG(boolean enabled, boolean 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
@@ -842,6 +861,7 @@ public:
 	boolean getESFSTATUS(uint16_t maxWait = defaultMaxWait); // ESF STATUS
 	boolean setAutoESFSTATUS(boolean enabled, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic ESF STATUS reports
 	boolean setAutoESFSTATUS(boolean enabled, boolean 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
+	boolean setAutoESFSTATUSrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic STATUS reports
 	boolean 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.
 	boolean assumeAutoESFSTATUS(boolean enabled, boolean 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
@@ -851,6 +871,7 @@ public:
 	boolean getESFINS(uint16_t maxWait = defaultMaxWait); // ESF INS
 	boolean setAutoESFINS(boolean enabled, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic ESF INS reports
 	boolean setAutoESFINS(boolean enabled, boolean 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
+	boolean setAutoESFINSrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic INS reports
 	boolean 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.
 	boolean assumeAutoESFINS(boolean enabled, boolean 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
@@ -860,6 +881,7 @@ public:
 	boolean getESFMEAS(uint16_t maxWait = defaultMaxWait); // ESF MEAS
 	boolean setAutoESFMEAS(boolean enabled, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic ESF MEAS reports
 	boolean setAutoESFMEAS(boolean enabled, boolean 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
+	boolean setAutoESFMEASrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic MEAS reports
 	boolean 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.
 	boolean assumeAutoESFMEAS(boolean enabled, boolean 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
@@ -869,6 +891,7 @@ public:
 	boolean getESFRAW(uint16_t maxWait = defaultMaxWait); // ESF RAW
 	boolean setAutoESFRAW(boolean enabled, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic ESF RAW reports
 	boolean setAutoESFRAW(boolean enabled, boolean 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
+	boolean setAutoESFRAWrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic RAW reports
 	boolean 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.
 	boolean assumeAutoESFRAW(boolean enabled, boolean 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
@@ -880,6 +903,7 @@ public:
 	boolean getHNRATT(uint16_t maxWait = defaultMaxWait); // Returns true if the get HNR attitude is successful
 	boolean setAutoHNRATT(boolean enabled, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic HNR Attitude reports at the HNR rate
 	boolean setAutoHNRATT(boolean enabled, boolean 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
+	boolean setAutoHNRATTrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic ATT reports
 	boolean 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.
 	boolean assumeAutoHNRATT(boolean enabled, boolean 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
@@ -889,6 +913,7 @@ public:
 	boolean getHNRINS(uint16_t maxWait = defaultMaxWait); // Returns true if the get HNR dynamics is successful
 	boolean setAutoHNRINS(boolean enabled, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic HNR dynamics reports at the HNR rate
 	boolean setAutoHNRINS(boolean enabled, boolean 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
+	boolean setAutoHNRINSrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic INS reports
 	boolean 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.
 	boolean assumeAutoHNRINS(boolean enabled, boolean 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
@@ -897,6 +922,7 @@ public:
 	boolean getHNRPVT(uint16_t maxWait = defaultMaxWait); // Returns true if the get HNR PVT is successful
 	boolean setAutoHNRPVT(boolean enabled, uint16_t maxWait = defaultMaxWait); //Enable/disable automatic HNR PVT reports at the HNR rate
 	boolean setAutoHNRPVT(boolean enabled, boolean 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
+	boolean setAutoHNRPVTrate(uint8_t rate, boolean implicitUpdate = true, uint16_t maxWait = defaultMaxWait); //Set the rate for automatic PVT reports
 	boolean 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.
 	boolean assumeAutoHNRPVT(boolean enabled, boolean 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
@@ -938,6 +964,7 @@ public:
 	uint8_t getSecond(uint16_t maxWait = defaultMaxWait);
 	uint16_t getMillisecond(uint16_t maxWait = defaultMaxWait);
 	int32_t getNanosecond(uint16_t maxWait = defaultMaxWait);
+	uint32_t getUnixEpoch(uint16_t maxWait = defaultMaxWait);
 	uint32_t getUnixEpoch(uint32_t& microsecond, uint16_t maxWait = defaultMaxWait);
 
 	bool getDateValid(uint16_t maxWait = defaultMaxWait);