Adding support for multiple message rates

examples/Example27_MultipleRates/Example27_MultipleRates.ino

@@ -7,9 +7,9 @@
   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 once per measurement;
+  PVT is output every second;
-  POS_ECEF is output every second measurement;
+  POSECEF is output every five seconds;
-  VEL_NED is output every third measurement.
+  VELNED is output every ten seconds.
 
   Feel like supporting open source hardware?
   Buy a board from SparkFun!
@@ -46,9 +46,9 @@ void setup()
   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" each PVT solution every measurement
+  myGNSS.setAutoPVTrate(1); //Tell the GNSS to send the PVT solution every measurement
-  //myGNSS.setAutoPOSECEFrate(2); //Tell the GNSS to "send" each POS_ECEF solution every second measurement
+  myGNSS.setAutoNAVPOSECEFrate(5); //Tell the GNSS to send each POSECEF solution every 5th measurement
-  myGNSS.setAutoNAVVELNEDrate(3); //Tell the GNSS to "send" each VEL_NED solution every third 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
 }
 
@@ -72,7 +72,23 @@ void loop()
     Serial.println(F(" (mm)"));
   }
 
-  // Calling getVELNED returns true if there actually is fresh velocity data available.
+  // 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: "));

keywords.txt

@@ -166,7 +166,7 @@ sendCfgValset32	KEYWORD2
 
 getNAVPOSECEF	KEYWORD2
 setAutoNAVPOSECEF	KEYWORD2
-setAutoNAVPOSECEF	KEYWORD2
+setAutoNAVPOSECEFrate	KEYWORD2
 setAutoNAVPOSECEFcallback	KEYWORD2
 assumeAutoNAVPOSECEF	KEYWORD2
 initPacketUBXNAVPOSECEF	KEYWORD2
@@ -175,7 +175,7 @@ logNAVPOSECEF	KEYWORD2
 
 getNAVSTATUS	KEYWORD2
 setAutoNAVSTATUS	KEYWORD2
-setAutoNAVSTATUS	KEYWORD2
+setAutoNAVSTATUSrate	KEYWORD2
 setAutoNAVSTATUScallback	KEYWORD2
 assumeAutoNAVSTATUS	KEYWORD2
 initPacketUBXNAVSTATUS	KEYWORD2
@@ -184,7 +184,7 @@ logNAVSTATUS	KEYWORD2
 
 getDOP	KEYWORD2
 setAutoDOP	KEYWORD2
-setAutoDOP	KEYWORD2
+setAutoDOPrate	KEYWORD2
 setAutoDOPcallback	KEYWORD2
 assumeAutoDOP	KEYWORD2
 initPacketUBXNAVDOP	KEYWORD2
@@ -194,7 +194,7 @@ logNAVDOP	KEYWORD2
 getVehAtt	KEYWORD2
 getNAVATT	KEYWORD2
 setAutoNAVATT	KEYWORD2
-setAutoNAVATT	KEYWORD2
+setAutoNAVATTrate	KEYWORD2
 setAutoNAVATTcallback	KEYWORD2
 assumeAutoNAVATT	KEYWORD2
 initPacketUBXNAVATT	KEYWORD2
@@ -203,7 +203,7 @@ logNAVATT	KEYWORD2
 
 getPVT	KEYWORD2
 setAutoPVT	KEYWORD2
-setAutoPVT	KEYWORD2
+setAutoPVTrate	KEYWORD2
 setAutoPVTcallback	KEYWORD2
 assumeAutoPVT	KEYWORD2
 initPacketUBXNAVPVT	KEYWORD2
@@ -212,7 +212,7 @@ logNAVPVT	KEYWORD2
 
 getNAVODO	KEYWORD2
 setAutoNAVODO	KEYWORD2
-setAutoNAVODO	KEYWORD2
+setAutoNAVODOrate	KEYWORD2
 setAutoNAVODOcallback	KEYWORD2
 assumeAutoNAVODO	KEYWORD2
 initPacketUBXNAVODO	KEYWORD2
@@ -221,7 +221,7 @@ logNAVODO	KEYWORD2
 
 getNAVVELECEF	KEYWORD2
 setAutoNAVVELECEF	KEYWORD2
-setAutoNAVVELECEF	KEYWORD2
+setAutoNAVVELECEFrate	KEYWORD2
 setAutoNAVVELECEFcallback	KEYWORD2
 assumeAutoNAVVELECEF	KEYWORD2
 initPacketUBXNAVVELECEF	KEYWORD2
@@ -230,6 +230,7 @@ logNAVVELECEF	KEYWORD2
 
 getNAVVELNED	KEYWORD2
 setAutoNAVVELNED	KEYWORD2
+setAutoNAVVELNEDrate	KEYWORD2
 setAutoNAVVELNEDcallback	KEYWORD2
 assumeAutoNAVVELNED	KEYWORD2
 initPacketUBXNAVVELNED	KEYWORD2
@@ -238,7 +239,7 @@ logNAVVELNED	KEYWORD2
 
 getNAVHPPOSECEF	KEYWORD2
 setAutoNAVHPPOSECEF	KEYWORD2
-setAutoNAVHPPOSECEF	KEYWORD2
+setAutoNAVHPPOSECEFrate	KEYWORD2
 setAutoNAVHPPOSECEFcallback	KEYWORD2
 assumeAutoNAVHPPOSECEF	KEYWORD2
 initPacketUBXNAVHPPOSECEF	KEYWORD2
@@ -247,7 +248,7 @@ logNAVHPPOSECEF	KEYWORD2
 
 getHPPOSLLH	KEYWORD2
 setAutoHPPOSLLH	KEYWORD2
-setAutoHPPOSLLH	KEYWORD2
+setAutoHPPOSLLHrate	KEYWORD2
 setAutoHPPOSLLHcallback	KEYWORD2
 assumeAutoHPPOSLLH	KEYWORD2
 initPacketUBXNAVHPPOSLLH	KEYWORD2
@@ -256,7 +257,7 @@ logNAVHPPOSLLH	KEYWORD2
 
 getNAVCLOCK	KEYWORD2
 setAutoNAVCLOCK	KEYWORD2
-setAutoNAVCLOCK	KEYWORD2
+setAutoNAVCLOCKrate	KEYWORD2
 setAutoNAVCLOCKcallback	KEYWORD2
 assumeAutoNAVCLOCK	KEYWORD2
 initPacketUBXNAVCLOCK	KEYWORD2
@@ -268,6 +269,7 @@ initPacketUBXNAVSVIN	KEYWORD2
 
 getRELPOSNED	KEYWORD2
 setAutoRELPOSNED	KEYWORD2
+setAutoRELPOSNEDrate	KEYWORD2
 setAutoRELPOSNEDcallback	KEYWORD2
 assumeAutoRELPOSNED	KEYWORD2
 initPacketUBXNAVRELPOSNED	KEYWORD2
@@ -276,6 +278,7 @@ logNAVRELPOSNED	KEYWORD2
 
 getRXMSFRBX	KEYWORD2
 setAutoRXMSFRBX	KEYWORD2
+setAutoRXMSFRBXrate	KEYWORD2
 setAutoRXMSFRBXcallback	KEYWORD2
 assumeAutoRXMSFRBX	KEYWORD2
 initPacketUBXRXMSFRBX	KEYWORD2
@@ -284,7 +287,7 @@ logRXMSFRBX	KEYWORD2
 
 getRXMRAWX	KEYWORD2
 setAutoRXMRAWX	KEYWORD2
-setAutoRXMRAWX	KEYWORD2
+setAutoRXMRAWXrate	KEYWORD2
 setAutoRXMRAWXcallback	KEYWORD2
 assumeAutoRXMRAWX	KEYWORD2
 initPacketUBXRXMRAWX	KEYWORD2
@@ -293,6 +296,7 @@ logRXMRAWX	KEYWORD2
 
 getTIMTM2	KEYWORD2
 setAutoTIMTM2	KEYWORD2
+setAutoTIMTM2rate	KEYWORD2
 setAutoTIMTM2callback	KEYWORD2
 assumeAutoTIMTM2	KEYWORD2
 initPacketUBXTIMTM2	KEYWORD2
@@ -302,6 +306,7 @@ logTIMTM2	KEYWORD2
 getEsfAlignment	KEYWORD2
 getESFALG	KEYWORD2
 setAutoESFALG	KEYWORD2
+setAutoESFALGrate	KEYWORD2
 setAutoESFALGcallback	KEYWORD2
 assumeAutoESFALG	KEYWORD2
 initPacketUBXESFALG	KEYWORD2
@@ -311,6 +316,7 @@ logESFALG	KEYWORD2
 getEsfInfo	KEYWORD2
 getESFSTATUS	KEYWORD2
 setAutoESFSTATUS	KEYWORD2
+setAutoESFSTATUSrate	KEYWORD2
 setAutoESFSTATUScallback	KEYWORD2
 assumeAutoESFSTATUS	KEYWORD2
 initPacketUBXESFSTATUS	KEYWORD2
@@ -320,6 +326,7 @@ logESFSTATUS	KEYWORD2
 getEsfIns	KEYWORD2
 getESFINS	KEYWORD2
 setAutoESFINS	KEYWORD2
+setAutoESFINSrate	KEYWORD2
 setAutoESFINScallback	KEYWORD2
 assumeAutoESFINS	KEYWORD2
 initPacketUBXESFINS	KEYWORD2
@@ -329,6 +336,7 @@ logESFINS	KEYWORD2
 getEsfDataInfo	KEYWORD2
 getESFMEAS	KEYWORD2
 setAutoESFMEAS	KEYWORD2
+setAutoESFMEASrate	KEYWORD2
 setAutoESFMEAScallback	KEYWORD2
 assumeAutoESFMEAS	KEYWORD2
 initPacketUBXESFMEAS	KEYWORD2
@@ -338,6 +346,7 @@ logESFMEAS	KEYWORD2
 getEsfRawDataInfo	KEYWORD2
 getESFRAW	KEYWORD2
 setAutoESFRAW	KEYWORD2
+setAutoESFRAWrate	KEYWORD2
 setAutoESFRAWcallback	KEYWORD2
 assumeAutoESFRAW	KEYWORD2
 initPacketUBXESFRAW	KEYWORD2
@@ -347,6 +356,7 @@ logESFRAW	KEYWORD2
 getHNRAtt	KEYWORD2
 getHNRATT	KEYWORD2
 setAutoHNRATT	KEYWORD2
+setAutoHNRATTrate	KEYWORD2
 setAutoHNRATTcallback	KEYWORD2
 assumeAutoHNRATT	KEYWORD2
 initPacketUBXHNRATT	KEYWORD2
@@ -356,6 +366,7 @@ logHNRATT	KEYWORD2
 getHNRDyn	KEYWORD2
 getHNRINS	KEYWORD2
 setAutoHNRINS	KEYWORD2
+setAutoHNRINSrate	KEYWORD2
 setAutoHNRINScallback	KEYWORD2
 assumeAutoHNRINS	KEYWORD2
 initPacketUBXHNRINS	KEYWORD2
@@ -364,7 +375,7 @@ logHNRINS	KEYWORD2
 
 getHNRPVT	KEYWORD2
 setAutoHNRPVT	KEYWORD2
-setAutoHNRPVT	KEYWORD2
+setAutoHNRPVTrate	KEYWORD2
 setAutoHNRPVTcallback	KEYWORD2
 assumeAutoHNRPVT	KEYWORD2
 initPacketUBXHNRPVT	KEYWORD2

src/SparkFun_u-blox_GNSS_Arduino_Library.cpp

@@ -5112,29 +5112,38 @@ boolean SFE_UBLOX_GNSS::getNAVPOSECEF(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVPOSECEF(boolean enable, uint16_t maxWait)
 {
-  return setAutoNAVPOSECEF(enable, true, maxWait);
+  return setAutoNAVPOSECEFrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic navigation message generation by the GNSS. This changes the way getPOSECEF
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVPOSECEF(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoNAVPOSECEFrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getPOSECEF
+//works.
+boolean SFE_UBLOX_GNSS::setAutoNAVPOSECEFrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXNAVPOSECEF == NULL) initPacketUBXNAVPOSECEF(); //Check that RAM has been allocated for the data
   if (packetUBXNAVPOSECEF == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_NAV;
   payloadCfg[1] = UBX_NAV_POSECEF;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXNAVPOSECEF->automaticFlags.flags.bits.automatic = enable;
+    packetUBXNAVPOSECEF->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXNAVPOSECEF->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXNAVPOSECEF->moduleQueried.moduleQueried.bits.all = false;
@@ -5256,33 +5265,42 @@ boolean SFE_UBLOX_GNSS::getNAVSTATUS(uint16_t maxWait)
   }
 }
 
-//Enable or disable automatic navigation message generation by the GNSS. This changes the way getSTATUS
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getNAVSTATUS
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVSTATUS(boolean enable, uint16_t maxWait)
 {
-  return setAutoNAVSTATUS(enable, true, maxWait);
+  return setAutoNAVSTATUSrate(enable ? 1 : 0, true, maxWait);
 }
 
-//Enable or disable automatic navigation message generation by the GNSS. This changes the way getSTATUS
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getNAVSTATUS
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVSTATUS(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoNAVSTATUSrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getNAVSTATUS
+//works.
+boolean SFE_UBLOX_GNSS::setAutoNAVSTATUSrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXNAVSTATUS == NULL) initPacketUBXNAVSTATUS(); //Check that RAM has been allocated for the data
   if (packetUBXNAVSTATUS == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_NAV;
   payloadCfg[1] = UBX_NAV_STATUS;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXNAVSTATUS->automaticFlags.flags.bits.automatic = enable;
+    packetUBXNAVSTATUS->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXNAVSTATUS->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXNAVSTATUS->moduleQueried.moduleQueried.bits.all = false;
@@ -5430,12 +5448,19 @@ boolean SFE_UBLOX_GNSS::getDOP(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoDOP(boolean enable, uint16_t maxWait)
 {
-  return setAutoDOP(enable, true, maxWait);
+  return setAutoDOPrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic navigation message generation by the GNSS. This changes the way getDOP
 //works.
 boolean SFE_UBLOX_GNSS::setAutoDOP(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoDOPrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getDOP
+//works.
+boolean SFE_UBLOX_GNSS::setAutoDOPrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXNAVDOP == NULL) initPacketUBXNAVDOP(); //Check that RAM has been allocated for the data
   if (packetUBXNAVDOP == NULL) //Only attempt this if RAM allocation was successful
@@ -5447,12 +5472,12 @@ boolean SFE_UBLOX_GNSS::setAutoDOP(boolean enable, boolean implicitUpdate, uint1
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_NAV;
   payloadCfg[1] = UBX_NAV_DOP;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXNAVDOP->automaticFlags.flags.bits.automatic = enable;
+    packetUBXNAVDOP->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXNAVDOP->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXNAVDOP->moduleQueried.moduleQueried.bits.all = false;
@@ -5584,29 +5609,38 @@ boolean SFE_UBLOX_GNSS::getNAVATT(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVATT(boolean enable, uint16_t maxWait)
 {
-  return setAutoNAVATT(enable, true, maxWait);
+  return setAutoNAVATTrate(enable ? 1 : 0, true, maxWait);
+}
+
+//Enable or disable automatic NAV ATT message generation by the GNSS. This changes the way getVehAtt
+//works.
+boolean SFE_UBLOX_GNSS::setAutoNAVATT(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoNAVATTrate(enable ? 1 : 0, implicitUpdate, maxWait);
 }
 
 //Enable or disable automatic NAV ATT attitude message generation by the GNSS. This changes the way getVehAtt
 //works.
-boolean SFE_UBLOX_GNSS::setAutoNAVATT(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+boolean SFE_UBLOX_GNSS::setAutoNAVATTrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXNAVATT == NULL) initPacketUBXNAVATT(); //Check that RAM has been allocated for the data
   if (packetUBXNAVATT == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_NAV;
   payloadCfg[1] = UBX_NAV_ATT;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXNAVATT->automaticFlags.flags.bits.automatic = enable;
+    packetUBXNAVATT->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXNAVATT->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXNAVATT->moduleQueried.moduleQueried.bits.all = false; // Mark data as stale
@@ -5773,6 +5807,8 @@ boolean SFE_UBLOX_GNSS::setAutoPVTrate(uint8_t rate, boolean implicitUpdate, uin
   if (packetUBXNAVPVT == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
@@ -5912,29 +5948,38 @@ boolean SFE_UBLOX_GNSS::getNAVODO(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVODO(boolean enable, uint16_t maxWait)
 {
-  return setAutoNAVODO(enable, true, maxWait);
+  return setAutoNAVODOrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic navigation message generation by the GNSS. This changes the way getODO
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVODO(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoNAVODOrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getODO
+//works.
+boolean SFE_UBLOX_GNSS::setAutoNAVODOrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXNAVODO == NULL) initPacketUBXNAVODO(); //Check that RAM has been allocated for the data
   if (packetUBXNAVODO == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_NAV;
   payloadCfg[1] = UBX_NAV_ODO;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXNAVODO->automaticFlags.flags.bits.automatic = enable;
+    packetUBXNAVODO->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXNAVODO->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXNAVODO->moduleQueried.moduleQueried.bits.all = false;
@@ -6059,29 +6104,38 @@ boolean SFE_UBLOX_GNSS::getNAVVELECEF(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVVELECEF(boolean enable, uint16_t maxWait)
 {
-  return setAutoNAVVELECEF(enable, true, maxWait);
+  return setAutoNAVVELECEFrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic navigation message generation by the GNSS. This changes the way getVELECEF
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVVELECEF(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoNAVVELECEFrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getVELECEF
+//works.
+boolean SFE_UBLOX_GNSS::setAutoNAVVELECEFrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXNAVVELECEF == NULL) initPacketUBXNAVVELECEF(); //Check that RAM has been allocated for the data
   if (packetUBXNAVVELECEF == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_NAV;
   payloadCfg[1] = UBX_NAV_VELECEF;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXNAVVELECEF->automaticFlags.flags.bits.automatic = enable;
+    packetUBXNAVVELECEF->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXNAVVELECEF->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXNAVVELECEF->moduleQueried.moduleQueried.bits.all = false;
@@ -6360,29 +6414,38 @@ boolean SFE_UBLOX_GNSS::getNAVHPPOSECEF(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVHPPOSECEF(boolean enable, uint16_t maxWait)
 {
-  return setAutoNAVHPPOSECEF(enable, true, maxWait);
+  return setAutoNAVHPPOSECEFrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic navigation message generation by the GNSS. This changes the way getHPPOSECEF
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVHPPOSECEF(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoNAVHPPOSECEFrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getHPPOSECEF
+//works.
+boolean SFE_UBLOX_GNSS::setAutoNAVHPPOSECEFrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXNAVHPPOSECEF == NULL) initPacketUBXNAVHPPOSECEF(); //Check that RAM has been allocated for the data
   if (packetUBXNAVHPPOSECEF == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_NAV;
   payloadCfg[1] = UBX_NAV_HPPOSECEF;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXNAVHPPOSECEF->automaticFlags.flags.bits.automatic = enable;
+    packetUBXNAVHPPOSECEF->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXNAVHPPOSECEF->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXNAVHPPOSECEF->moduleQueried.moduleQueried.bits.all = false;
@@ -6529,29 +6592,38 @@ boolean SFE_UBLOX_GNSS::getHPPOSLLH(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoHPPOSLLH(boolean enable, uint16_t maxWait)
 {
-  return setAutoHPPOSLLH(enable, true, maxWait);
+  return setAutoHPPOSLLHrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic navigation message generation by the GNSS. This changes the way getHPPOSLLH
 //works.
 boolean SFE_UBLOX_GNSS::setAutoHPPOSLLH(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoHPPOSLLHrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getHPPOSLLH
+//works.
+boolean SFE_UBLOX_GNSS::setAutoHPPOSLLHrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXNAVHPPOSLLH == NULL) initPacketUBXNAVHPPOSLLH(); //Check that RAM has been allocated for the data
   if (packetUBXNAVHPPOSLLH == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_NAV;
   payloadCfg[1] = UBX_NAV_HPPOSLLH;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXNAVHPPOSLLH->automaticFlags.flags.bits.automatic = enable;
+    packetUBXNAVHPPOSLLH->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXNAVHPPOSLLH->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXNAVHPPOSLLH->moduleQueried.moduleQueried.bits.all = false;
@@ -6676,29 +6748,38 @@ boolean SFE_UBLOX_GNSS::getNAVCLOCK(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoNAVCLOCK(boolean enable, uint16_t maxWait)
 {
-  return setAutoNAVCLOCK(enable, true, maxWait);
+  return setAutoNAVCLOCKrate(enable ? 1 : 0, true, maxWait);
+}
+
+//Enable or disable automatic CLOCK message generation by the GNSS. This changes the way getNAVCLOCK
+//works.
+boolean SFE_UBLOX_GNSS::setAutoNAVCLOCK(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoNAVCLOCKrate(enable ? 1 : 0, implicitUpdate, maxWait);
 }
 
 //Enable or disable automatic CLOCK attitude message generation by the GNSS. This changes the way getNAVCLOCK
 //works.
-boolean SFE_UBLOX_GNSS::setAutoNAVCLOCK(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+boolean SFE_UBLOX_GNSS::setAutoNAVCLOCKrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXNAVCLOCK == NULL) initPacketUBXNAVCLOCK(); //Check that RAM has been allocated for the data
   if (packetUBXNAVCLOCK == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_NAV;
   payloadCfg[1] = UBX_NAV_CLOCK;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXNAVCLOCK->automaticFlags.flags.bits.automatic = enable;
+    packetUBXNAVCLOCK->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXNAVCLOCK->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXNAVCLOCK->moduleQueried.moduleQueried.bits.all = false; // Mark data as stale
@@ -6875,29 +6956,38 @@ boolean SFE_UBLOX_GNSS::getRELPOSNED(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoRELPOSNED(boolean enable, uint16_t maxWait)
 {
-  return setAutoRELPOSNED(enable, true, maxWait);
+  return setAutoRELPOSNEDrate(enable ? 1 : 0, true, maxWait);
+}
+
+//Enable or disable automatic RELPOSNED message generation by the GNSS. This changes the way getRELPOSNED
+//works.
+boolean SFE_UBLOX_GNSS::setAutoRELPOSNED(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoRELPOSNEDrate(enable ? 1 : 0, implicitUpdate, maxWait);
 }
 
 //Enable or disable automatic HNR attitude message generation by the GNSS. This changes the way getRELPOSNED
 //works.
-boolean SFE_UBLOX_GNSS::setAutoRELPOSNED(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+boolean SFE_UBLOX_GNSS::setAutoRELPOSNEDrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXNAVRELPOSNED == NULL) initPacketUBXNAVRELPOSNED(); //Check that RAM has been allocated for the data
   if (packetUBXNAVRELPOSNED == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_NAV;
   payloadCfg[1] = UBX_NAV_RELPOSNED;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXNAVRELPOSNED->automaticFlags.flags.bits.automatic = enable;
+    packetUBXNAVRELPOSNED->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXNAVRELPOSNED->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXNAVRELPOSNED->moduleQueried.moduleQueried.bits.all = false; // Mark data as stale
@@ -7022,29 +7112,38 @@ boolean SFE_UBLOX_GNSS::getRXMSFRBX(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoRXMSFRBX(boolean enable, uint16_t maxWait)
 {
-  return setAutoRXMSFRBX(enable, true, maxWait);
+  return setAutoRXMSFRBXrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic navigation message generation by the GNSS. This changes the way getRXMSFRBX
 //works.
 boolean SFE_UBLOX_GNSS::setAutoRXMSFRBX(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoRXMSFRBXrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getRXMSFRBX
+//works.
+boolean SFE_UBLOX_GNSS::setAutoRXMSFRBXrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXRXMSFRBX == NULL) initPacketUBXRXMSFRBX(); //Check that RAM has been allocated for the data
   if (packetUBXRXMSFRBX == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_RXM;
   payloadCfg[1] = UBX_RXM_SFRBX;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXRXMSFRBX->automaticFlags.flags.bits.automatic = enable;
+    packetUBXRXMSFRBX->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXRXMSFRBX->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXRXMSFRBX->moduleQueried = false;
@@ -7169,29 +7268,38 @@ boolean SFE_UBLOX_GNSS::getRXMRAWX(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoRXMRAWX(boolean enable, uint16_t maxWait)
 {
-  return setAutoRXMRAWX(enable, true, maxWait);
+  return setAutoRXMRAWXrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic navigation message generation by the GNSS. This changes the way getRXMRAWX
 //works.
 boolean SFE_UBLOX_GNSS::setAutoRXMRAWX(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoRXMRAWXrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getRXMRAWX
+//works.
+boolean SFE_UBLOX_GNSS::setAutoRXMRAWXrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXRXMRAWX == NULL) initPacketUBXRXMRAWX(); //Check that RAM has been allocated for the data
   if (packetUBXRXMRAWX == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_RXM;
   payloadCfg[1] = UBX_RXM_RAWX;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXRXMRAWX->automaticFlags.flags.bits.automatic = enable;
+    packetUBXRXMRAWX->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXRXMRAWX->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXRXMRAWX->moduleQueried = false;
@@ -7376,29 +7484,38 @@ boolean SFE_UBLOX_GNSS::getTIMTM2(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoTIMTM2(boolean enable, uint16_t maxWait)
 {
-  return setAutoTIMTM2(enable, true, maxWait);
+  return setAutoTIMTM2rate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic navigation message generation by the GNSS. This changes the way getTIMTM2
 //works.
 boolean SFE_UBLOX_GNSS::setAutoTIMTM2(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoTIMTM2rate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic navigation message generation by the GNSS. This changes the way getTIMTM2
+//works.
+boolean SFE_UBLOX_GNSS::setAutoTIMTM2rate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXTIMTM2 == NULL) initPacketUBXTIMTM2(); //Check that RAM has been allocated for the data
   if (packetUBXTIMTM2 == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_TIM;
   payloadCfg[1] = UBX_TIM_TM2;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXTIMTM2->automaticFlags.flags.bits.automatic = enable;
+    packetUBXTIMTM2->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXTIMTM2->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXTIMTM2->moduleQueried.moduleQueried.bits.all = false;
@@ -7552,29 +7669,38 @@ boolean SFE_UBLOX_GNSS::getESFALG(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoESFALG(boolean enable, uint16_t maxWait)
 {
-  return setAutoESFALG(enable, true, maxWait);
+  return setAutoESFALGrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic ESF ALG message generation by the GNSS. This changes the way getEsfAlignment
 //works.
 boolean SFE_UBLOX_GNSS::setAutoESFALG(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoESFALGrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic ESF ALG message generation by the GNSS. This changes the way getEsfAlignment
+//works.
+boolean SFE_UBLOX_GNSS::setAutoESFALGrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXESFALG == NULL) initPacketUBXESFALG(); //Check that RAM has been allocated for the data
   if (packetUBXESFALG == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_ESF;
   payloadCfg[1] = UBX_ESF_ALG;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXESFALG->automaticFlags.flags.bits.automatic = enable;
+    packetUBXESFALG->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXESFALG->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXESFALG->moduleQueried.moduleQueried.bits.all = false; // Mark data as stale
@@ -7728,29 +7854,38 @@ boolean SFE_UBLOX_GNSS::getESFSTATUS(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoESFSTATUS(boolean enable, uint16_t maxWait)
 {
-  return setAutoESFSTATUS(enable, true, maxWait);
+  return setAutoESFSTATUSrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic ESF STATUS message generation by the GNSS. This changes the way getESFInfo
 //works.
 boolean SFE_UBLOX_GNSS::setAutoESFSTATUS(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoESFSTATUSrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic ESF STATUS message generation by the GNSS. This changes the way getESFInfo
+//works.
+boolean SFE_UBLOX_GNSS::setAutoESFSTATUSrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXESFSTATUS == NULL) initPacketUBXESFSTATUS(); //Check that RAM has been allocated for the data
   if (packetUBXESFSTATUS == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_ESF;
   payloadCfg[1] = UBX_ESF_STATUS;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXESFSTATUS->automaticFlags.flags.bits.automatic = enable;
+    packetUBXESFSTATUS->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXESFSTATUS->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXESFSTATUS->moduleQueried.moduleQueried.bits.all = false; // Mark data as stale
@@ -7905,29 +8040,38 @@ boolean SFE_UBLOX_GNSS::getESFINS(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoESFINS(boolean enable, uint16_t maxWait)
 {
-  return setAutoESFINS(enable, true, maxWait);
+  return setAutoESFINSrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic ESF INS message generation by the GNSS. This changes the way getESFIns
 //works.
 boolean SFE_UBLOX_GNSS::setAutoESFINS(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoESFINSrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic ESF INS message generation by the GNSS. This changes the way getESFIns
+//works.
+boolean SFE_UBLOX_GNSS::setAutoESFINSrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXESFINS == NULL) initPacketUBXESFINS(); //Check that RAM has been allocated for the data
   if (packetUBXESFINS == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_ESF;
   payloadCfg[1] = UBX_ESF_INS;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXESFINS->automaticFlags.flags.bits.automatic = enable;
+    packetUBXESFINS->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXESFINS->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXESFINS->moduleQueried.moduleQueried.bits.all = false; // Mark data as stale
@@ -8081,29 +8225,38 @@ boolean SFE_UBLOX_GNSS::getESFMEAS(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoESFMEAS(boolean enable, uint16_t maxWait)
 {
-  return setAutoESFMEAS(enable, true, maxWait);
+  return setAutoESFMEASrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic ESF MEAS message generation by the GNSS. This changes the way getESFDataInfo
 //works.
 boolean SFE_UBLOX_GNSS::setAutoESFMEAS(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoESFMEASrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic ESF MEAS message generation by the GNSS. This changes the way getESFDataInfo
+//works.
+boolean SFE_UBLOX_GNSS::setAutoESFMEASrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXESFMEAS == NULL) initPacketUBXESFMEAS(); //Check that RAM has been allocated for the data
   if (packetUBXESFMEAS == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_ESF;
   payloadCfg[1] = UBX_ESF_MEAS;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXESFMEAS->automaticFlags.flags.bits.automatic = enable;
+    packetUBXESFMEAS->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXESFMEAS->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXESFMEAS->moduleQueried.moduleQueried.bits.all = false; // Mark data as stale
@@ -8257,29 +8410,38 @@ boolean SFE_UBLOX_GNSS::getESFRAW(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoESFRAW(boolean enable, uint16_t maxWait)
 {
-  return setAutoESFRAW(enable, true, maxWait);
+  return setAutoESFRAWrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic ESF RAW message generation by the GNSS. This changes the way getESFRawDataInfo
 //works.
 boolean SFE_UBLOX_GNSS::setAutoESFRAW(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoESFRAWrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic ESF RAW message generation by the GNSS. This changes the way getESFRawDataInfo
+//works.
+boolean SFE_UBLOX_GNSS::setAutoESFRAWrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXESFRAW == NULL) initPacketUBXESFRAW(); //Check that RAM has been allocated for the data
   if (packetUBXESFRAW == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_ESF;
   payloadCfg[1] = UBX_ESF_RAW;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXESFRAW->automaticFlags.flags.bits.automatic = enable;
+    packetUBXESFRAW->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXESFRAW->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXESFRAW->moduleQueried.moduleQueried.bits.all = false; // Mark data as stale
@@ -8438,29 +8600,38 @@ boolean SFE_UBLOX_GNSS::getHNRATT(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoHNRATT(boolean enable, uint16_t maxWait)
 {
-  return setAutoHNRATT(enable, true, maxWait);
+  return setAutoHNRATTrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic HNR attitude message generation by the GNSS. This changes the way getHNRAtt
 //works.
 boolean SFE_UBLOX_GNSS::setAutoHNRATT(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoHNRATTrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic HNR attitude message generation by the GNSS. This changes the way getHNRAtt
+//works.
+boolean SFE_UBLOX_GNSS::setAutoHNRATTrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXHNRATT == NULL) initPacketUBXHNRATT(); //Check that RAM has been allocated for the data
   if (packetUBXHNRATT == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_HNR;
   payloadCfg[1] = UBX_HNR_ATT;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXHNRATT->automaticFlags.flags.bits.automatic = enable;
+    packetUBXHNRATT->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXHNRATT->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXHNRATT->moduleQueried.moduleQueried.bits.all = false; // Mark data as stale
@@ -8620,29 +8791,38 @@ boolean SFE_UBLOX_GNSS::getHNRINS(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoHNRINS(boolean enable, uint16_t maxWait)
 {
-  return setAutoHNRINS(enable, true, maxWait);
+  return setAutoHNRINSrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic HNR vehicle dynamics message generation by the GNSS. This changes the way getHNRDyn
 //works.
 boolean SFE_UBLOX_GNSS::setAutoHNRINS(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoHNRINSrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic HNR vehicle dynamics message generation by the GNSS. This changes the way getHNRDyn
+//works.
+boolean SFE_UBLOX_GNSS::setAutoHNRINSrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXHNRINS == NULL) initPacketUBXHNRINS(); //Check that RAM has been allocated for the data
   if (packetUBXHNRINS == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_HNR;
   payloadCfg[1] = UBX_HNR_INS;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXHNRINS->automaticFlags.flags.bits.automatic = enable;
+    packetUBXHNRINS->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXHNRINS->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXHNRINS->moduleQueried.moduleQueried.bits.all = false; // Mark data as stale
@@ -8796,29 +8976,38 @@ boolean SFE_UBLOX_GNSS::getHNRPVT(uint16_t maxWait)
 //works.
 boolean SFE_UBLOX_GNSS::setAutoHNRPVT(boolean enable, uint16_t maxWait)
 {
-  return setAutoHNRPVT(enable, true, maxWait);
+  return setAutoHNRPVTrate(enable ? 1 : 0, true, maxWait);
 }
 
 //Enable or disable automatic HNR PVT message generation by the GNSS. This changes the way getHNRPVT
 //works.
 boolean SFE_UBLOX_GNSS::setAutoHNRPVT(boolean enable, boolean implicitUpdate, uint16_t maxWait)
+{
+  return setAutoHNRPVTrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+//Enable or disable automatic HNR PVT message generation by the GNSS. This changes the way getHNRPVT
+//works.
+boolean SFE_UBLOX_GNSS::setAutoHNRPVTrate(uint8_t rate, boolean implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXHNRPVT == NULL) initPacketUBXHNRPVT(); //Check that RAM has been allocated for the data
   if (packetUBXHNRPVT == NULL) //Only attempt this if RAM allocation was successful
     return false;
 
+  if (rate > 127) rate = 127;
+
   packetCfg.cls = UBX_CLASS_CFG;
   packetCfg.id = UBX_CFG_MSG;
   packetCfg.len = 3;
   packetCfg.startingSpot = 0;
   payloadCfg[0] = UBX_CLASS_HNR;
   payloadCfg[1] = UBX_HNR_PVT;
-  payloadCfg[2] = enable ? 1 : 0; // rate relative to navigation freq.
+  payloadCfg[2] = rate; // rate relative to navigation freq.
 
   boolean ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
   if (ok)
   {
-    packetUBXHNRPVT->automaticFlags.flags.bits.automatic = enable;
+    packetUBXHNRPVT->automaticFlags.flags.bits.automatic = (rate > 0);
     packetUBXHNRPVT->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
   }
   packetUBXHNRPVT->moduleQueried.moduleQueried.bits.all = false; // Mark data as stale

src/SparkFun_u-blox_GNSS_Arduino_Library.h

@@ -700,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
@@ -708,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
@@ -716,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
@@ -725,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
@@ -733,7 +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); //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
@@ -742,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
@@ -750,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
@@ -758,7 +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); //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
@@ -767,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
@@ -775,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
@@ -783,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
@@ -794,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
@@ -804,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
@@ -812,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
@@ -827,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
@@ -838,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
@@ -847,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
@@ -856,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
@@ -865,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
@@ -874,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
@@ -885,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
@@ -894,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
@@ -902,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