Update keywords.txt. Add TIMEUTC and EOE to end(). Rename NAVEOE functions.

Theory.md

@@ -55,11 +55,13 @@ In v2.0, the full list of messages which can be processed and logged automatical
 - UBX-NAV-HPPOSECEF (0x01 0x13): High precision position solution in ECEF
 - UBX-NAV-HPPOSLLH (0x01 0x14): High precision geodetic position solution
 - UBX-NAV-PVAT (0x01 0x17): Navigation position velocity attitude time solution (**only with ADR or UDR products**)
+- UBX-NAV-TIMEUTC (0x01 0x21): UTC time solution
 - UBX-NAV-CLOCK (0x01 0x22): Clock solution
 - UBX-NAV-SAT (0x01 0x35): Satellite information
 - UBX-NAV-SVIN (0x01 0x3B): Survey-in data (**only with High Precision GNSS products**)
 - UBX-NAV-RELPOSNED (0x01 0x3C): Relative positioning information in NED frame (**only with High Precision GNSS products**)
 - UBX-NAV-AOPSTATUS (0x01 0x60): AssistNow Autonomous status
+- UBX-NAV-EOE (0x01 0x61): End of epoch
 - UBX-RXM-SFRBX (0x02 0x13): Broadcast navigation data subframe
 - UBX-RXM-RAWX (0x02 0x15): Multi-GNSS raw measurement data (**only with ADR or High Precision GNSS or Time Sync products**)
 - UBX-TIM-TM2 (0x0D 0x03): Time mark data
@@ -76,7 +78,6 @@ Please see [Adding_New_Messages](./Adding_New_Messages.md) for details on how to
 
 Notes:
 - UBX-NAV-POSLLH is not supported as UBX-NAV-PVT contains the same information
-- UBX-NAV-TIMEUTC is not supported as UBX-NAV-PVT contains the same information
 
 ## Migrating your code to v2.0
 

keywords.txt

@@ -45,6 +45,7 @@ UBX_NAV_SVIN_data_t	KEYWORD1
 UBX_NAV_RELPOSNED_data_t	KEYWORD1
 UBX_NAV_TIMELS_data_t	KEYWORD1
 UBX_NAV_AOPSTATUS_data_t	KEYWORD1
+UBX_NAV_EOE_data_t	KEYWORD1
 
 UBX_RXM_PMP_data_t	KEYWORD1
 UBX_RXM_PMP_message_data_t	KEYWORD1
@@ -344,6 +345,14 @@ assumeAutoNAVPVAT	KEYWORD2
 flushNAVPVAT	KEYWORD2
 logNAVPVAT	KEYWORD2
 
+getNAVTIMEUTC	KEYWORD2
+setAutoNAVTIMEUTC	KEYWORD2
+setAutoNAVTIMEUTCrate	KEYWORD2
+setAutoNAVTIMEUTCcallbackPtr	KEYWORD2
+assumeAutoNAVTIMEUTC	KEYWORD2
+flushNAVTIMEUTC	KEYWORD2
+logNAVTIMEUTC	KEYWORD2
+
 getNAVCLOCK	KEYWORD2
 setAutoNAVCLOCK	KEYWORD2
 setAutoNAVCLOCKrate	KEYWORD2
@@ -392,6 +401,14 @@ assumeAutoAOPSTATUS	KEYWORD2
 flushAOPSTATUS	KEYWORD2
 logAOPSTATUS	KEYWORD2
 
+getNAVEOE	KEYWORD2
+setAutoNAVEOE	KEYWORD2
+setAutoNAVEOErate	KEYWORD2
+setAutoNAVEOEcallbackPtr	KEYWORD2
+assumeAutoNAVEOE	KEYWORD2
+flushNAVEOE	KEYWORD2
+logNAVEOE	KEYWORD2
+
 setRXMPMPcallbackPtr	KEYWORD2
 setRXMPMPmessageCallbackPtr	KEYWORD2
 

src/SparkFun_u-blox_GNSS_Arduino_Library.cpp

@@ -251,6 +251,16 @@ void SFE_UBLOX_GNSS::end(void)
     packetUBXNAVPVAT = NULL; // Redundant?
   }
 
+  if (packetUBXNAVTIMEUTC != NULL)
+  {
+    if (packetUBXNAVTIMEUTC->callbackData != NULL)
+    {
+      delete packetUBXNAVTIMEUTC->callbackData;
+    }
+    delete packetUBXNAVTIMEUTC;
+    packetUBXNAVTIMEUTC = NULL; // Redundant?
+  }
+
   if (packetUBXNAVCLOCK != NULL)
   {
     if (packetUBXNAVCLOCK->callbackData != NULL)
@@ -301,6 +311,16 @@ void SFE_UBLOX_GNSS::end(void)
     packetUBXNAVAOPSTATUS = NULL; // Redundant?
   }
 
+  if (packetUBXNAVEOE != NULL)
+  {
+    if (packetUBXNAVEOE->callbackData != NULL)
+    {
+      delete packetUBXNAVEOE->callbackData;
+    }
+    delete packetUBXNAVEOE;
+    packetUBXNAVEOE = NULL; // Redundant?
+  }
+
   if (packetUBXRXMPMP != NULL)
   {
     if (packetUBXRXMPMP->callbackData != NULL)
@@ -1295,10 +1315,6 @@ bool SFE_UBLOX_GNSS::checkAutomatic(uint8_t Class, uint8_t ID)
       if (packetUBXNAVDOP != NULL)
         result = true;
       break;
-    case UBX_NAV_EOE:
-      if (packetUBXNAVEOE != NULL)
-        result = true;
-      break;
     case UBX_NAV_ATT:
       if (packetUBXNAVATT != NULL)
         result = true;
@@ -1311,10 +1327,6 @@ bool SFE_UBLOX_GNSS::checkAutomatic(uint8_t Class, uint8_t ID)
       if (packetUBXNAVODO != NULL)
         result = true;
       break;
-    case UBX_NAV_TIMEUTC:
-      if (packetUBXNAVTIMEUTC != NULL)
-        result = true;
-      break;
     case UBX_NAV_VELECEF:
       if (packetUBXNAVVELECEF != NULL)
         result = true;
@@ -1335,6 +1347,10 @@ bool SFE_UBLOX_GNSS::checkAutomatic(uint8_t Class, uint8_t ID)
       if (packetUBXNAVPVAT != NULL)
         result = true;
       break;
+    case UBX_NAV_TIMEUTC:
+      if (packetUBXNAVTIMEUTC != NULL)
+        result = true;
+      break;
     case UBX_NAV_CLOCK:
       if (packetUBXNAVCLOCK != NULL)
         result = true;
@@ -1359,6 +1375,10 @@ bool SFE_UBLOX_GNSS::checkAutomatic(uint8_t Class, uint8_t ID)
       if (packetUBXNAVAOPSTATUS != NULL)
         result = true;
       break;
+    case UBX_NAV_EOE:
+      if (packetUBXNAVEOE != NULL)
+        result = true;
+      break;
     }
   }
   break;
@@ -1495,9 +1515,6 @@ uint16_t SFE_UBLOX_GNSS::getMaxPayloadSize(uint8_t Class, uint8_t ID)
     case UBX_NAV_DOP:
       maxSize = UBX_NAV_DOP_LEN;
       break;
-    case UBX_NAV_EOE:
-      maxSize = UBX_NAV_EOE_LEN;
-      break;
     case UBX_NAV_ATT:
       maxSize = UBX_NAV_ATT_LEN;
       break;
@@ -1507,9 +1524,6 @@ uint16_t SFE_UBLOX_GNSS::getMaxPayloadSize(uint8_t Class, uint8_t ID)
     case UBX_NAV_ODO:
       maxSize = UBX_NAV_ODO_LEN;
       break;
-    case UBX_NAV_TIMEUTC:
-      maxSize = UBX_NAV_TIMEUTC;
-      break;
     case UBX_NAV_VELECEF:
       maxSize = UBX_NAV_VELECEF_LEN;
       break;
@@ -1525,6 +1539,9 @@ uint16_t SFE_UBLOX_GNSS::getMaxPayloadSize(uint8_t Class, uint8_t ID)
     case UBX_NAV_PVAT:
       maxSize = UBX_NAV_PVAT_LEN;
       break;
+    case UBX_NAV_TIMEUTC:
+      maxSize = UBX_NAV_TIMEUTC;
+      break;
     case UBX_NAV_CLOCK:
       maxSize = UBX_NAV_CLOCK_LEN;
       break;
@@ -1543,6 +1560,9 @@ uint16_t SFE_UBLOX_GNSS::getMaxPayloadSize(uint8_t Class, uint8_t ID)
     case UBX_NAV_AOPSTATUS:
       maxSize = UBX_NAV_AOPSTATUS_LEN;
       break;
+    case UBX_NAV_EOE:
+      maxSize = UBX_NAV_EOE_LEN;
+      break;
     }
   }
   break;
@@ -3245,31 +3265,6 @@ void SFE_UBLOX_GNSS::processUBXpacket(ubxPacket *msg)
         }
       }
     }
-    else if (msg->id == UBX_NAV_EOE && msg->len == UBX_NAV_EOE_LEN)
-    {
-      // Parse various byte fields into storage - but only if we have memory allocated for it
-      if (packetUBXNAVEOE != NULL)
-      {
-        packetUBXNAVEOE->data.iTOW = extractLong(msg, 0);
-
-        // Mark all datums as fresh (not read before)
-        packetUBXNAVEOE->moduleQueried.moduleQueried.all = 0xFFFFFFFF;
-
-        // Check if we need to copy the data for the callback
-        if ((packetUBXNAVEOE->callbackData != NULL)                                     // If RAM has been allocated for the copy of the data
-            && (packetUBXNAVEOE->automaticFlags.flags.bits.callbackCopyValid == false)) // AND the data is stale
-        {
-          memcpy(&packetUBXNAVEOE->callbackData->iTOW, &packetUBXNAVEOE->data.iTOW, sizeof(UBX_NAV_EOE_data_t));
-          packetUBXNAVEOE->automaticFlags.flags.bits.callbackCopyValid = true;
-        }
-
-        // Check if we need to copy the data into the file buffer
-        if (packetUBXNAVEOE->automaticFlags.flags.bits.addToFileBuffer)
-        {
-          storePacket(msg);
-        }
-      }
-    }
     else if (msg->id == UBX_NAV_ATT && msg->len == UBX_NAV_ATT_LEN)
     {
       // Parse various byte fields into storage - but only if we have memory allocated for it
@@ -3388,40 +3383,6 @@ void SFE_UBLOX_GNSS::processUBXpacket(ubxPacket *msg)
         }
       }
     }
-    else if (msg->id == UBX_NAV_TIMEUTC && msg->len == UBX_NAV_TIMEUTC_LEN)
-    {
-      // Parse various byte fields into storage - but only if we have memory allocated for it
-      if (packetUBXNAVTIMEUTC != NULL)
-      {
-        packetUBXNAVTIMEUTC->data.iTOW = extractLong(msg, 0);
-        packetUBXNAVTIMEUTC->data.tAcc = extractLong(msg, 4);
-        packetUBXNAVTIMEUTC->data.nano = extractSignedLong(msg, 8);
-        packetUBXNAVTIMEUTC->data.year = extractInt(msg, 12);
-        packetUBXNAVTIMEUTC->data.month = extractByte(msg, 14);
-        packetUBXNAVTIMEUTC->data.day = extractByte(msg, 15);
-        packetUBXNAVTIMEUTC->data.hour = extractByte(msg, 16);
-        packetUBXNAVTIMEUTC->data.min = extractByte(msg, 17);
-        packetUBXNAVTIMEUTC->data.sec = extractByte(msg, 18);
-        packetUBXNAVTIMEUTC->data.valid.all = extractByte(msg, 19);
-
-        // Mark all datums as fresh (not read before)
-        packetUBXNAVTIMEUTC->moduleQueried.moduleQueried.all = 0xFFFFFFFF;
-
-        // Check if we need to copy the data for the callback
-        if ((packetUBXNAVTIMEUTC->callbackData != NULL)                                   // If RAM has been allocated for the copy of the data
-          && (packetUBXNAVTIMEUTC->automaticFlags.flags.bits.callbackCopyValid == false)) // AND the data is stale
-        {
-          memcpy(&packetUBXNAVTIMEUTC->callbackData->iTOW, &packetUBXNAVTIMEUTC->data.iTOW, sizeof(UBX_NAV_TIMEUTC_data_t));
-          packetUBXNAVTIMEUTC->automaticFlags.flags.bits.callbackCopyValid = true;
-        }
-
-        // Check if we need to copy the data into the file buffer
-        if (packetUBXNAVTIMEUTC->automaticFlags.flags.bits.addToFileBuffer)
-        {
-          storePacket(msg);
-        }
-      }
-    }
     else if (msg->id == UBX_NAV_VELECEF && msg->len == UBX_NAV_VELECEF_LEN)
     {
       // Parse various byte fields into storage - but only if we have memory allocated for it
@@ -3618,6 +3579,40 @@ void SFE_UBLOX_GNSS::processUBXpacket(ubxPacket *msg)
         }
       }
     }
+    else if (msg->id == UBX_NAV_TIMEUTC && msg->len == UBX_NAV_TIMEUTC_LEN)
+    {
+      // Parse various byte fields into storage - but only if we have memory allocated for it
+      if (packetUBXNAVTIMEUTC != NULL)
+      {
+        packetUBXNAVTIMEUTC->data.iTOW = extractLong(msg, 0);
+        packetUBXNAVTIMEUTC->data.tAcc = extractLong(msg, 4);
+        packetUBXNAVTIMEUTC->data.nano = extractSignedLong(msg, 8);
+        packetUBXNAVTIMEUTC->data.year = extractInt(msg, 12);
+        packetUBXNAVTIMEUTC->data.month = extractByte(msg, 14);
+        packetUBXNAVTIMEUTC->data.day = extractByte(msg, 15);
+        packetUBXNAVTIMEUTC->data.hour = extractByte(msg, 16);
+        packetUBXNAVTIMEUTC->data.min = extractByte(msg, 17);
+        packetUBXNAVTIMEUTC->data.sec = extractByte(msg, 18);
+        packetUBXNAVTIMEUTC->data.valid.all = extractByte(msg, 19);
+
+        // Mark all datums as fresh (not read before)
+        packetUBXNAVTIMEUTC->moduleQueried.moduleQueried.all = 0xFFFFFFFF;
+
+        // Check if we need to copy the data for the callback
+        if ((packetUBXNAVTIMEUTC->callbackData != NULL)                                   // If RAM has been allocated for the copy of the data
+          && (packetUBXNAVTIMEUTC->automaticFlags.flags.bits.callbackCopyValid == false)) // AND the data is stale
+        {
+          memcpy(&packetUBXNAVTIMEUTC->callbackData->iTOW, &packetUBXNAVTIMEUTC->data.iTOW, sizeof(UBX_NAV_TIMEUTC_data_t));
+          packetUBXNAVTIMEUTC->automaticFlags.flags.bits.callbackCopyValid = true;
+        }
+
+        // Check if we need to copy the data into the file buffer
+        if (packetUBXNAVTIMEUTC->automaticFlags.flags.bits.addToFileBuffer)
+        {
+          storePacket(msg);
+        }
+      }
+    }
     else if (msg->id == UBX_NAV_CLOCK && msg->len == UBX_NAV_CLOCK_LEN)
     {
       // Parse various byte fields into storage - but only if we have memory allocated for it
@@ -3838,6 +3833,31 @@ void SFE_UBLOX_GNSS::processUBXpacket(ubxPacket *msg)
         }
       }
     }
+    else if (msg->id == UBX_NAV_EOE && msg->len == UBX_NAV_EOE_LEN)
+    {
+      // Parse various byte fields into storage - but only if we have memory allocated for it
+      if (packetUBXNAVEOE != NULL)
+      {
+        packetUBXNAVEOE->data.iTOW = extractLong(msg, 0);
+
+        // Mark all datums as fresh (not read before)
+        packetUBXNAVEOE->moduleQueried.moduleQueried.all = 0xFFFFFFFF;
+
+        // Check if we need to copy the data for the callback
+        if ((packetUBXNAVEOE->callbackData != NULL)                                     // If RAM has been allocated for the copy of the data
+            && (packetUBXNAVEOE->automaticFlags.flags.bits.callbackCopyValid == false)) // AND the data is stale
+        {
+          memcpy(&packetUBXNAVEOE->callbackData->iTOW, &packetUBXNAVEOE->data.iTOW, sizeof(UBX_NAV_EOE_data_t));
+          packetUBXNAVEOE->automaticFlags.flags.bits.callbackCopyValid = true;
+        }
+
+        // Check if we need to copy the data into the file buffer
+        if (packetUBXNAVEOE->automaticFlags.flags.bits.addToFileBuffer)
+        {
+          storePacket(msg);
+        }
+      }
+    }
     break;
   case UBX_CLASS_RXM:
     if (msg->id == UBX_RXM_PMP)
@@ -5255,25 +5275,6 @@ void SFE_UBLOX_GNSS::checkCallbacks(void)
     packetUBXNAVDOP->automaticFlags.flags.bits.callbackCopyValid = false; // Mark the data as stale
   }
 
-  if ((packetUBXNAVEOE != NULL)                                                // If RAM has been allocated for message storage
-    && (packetUBXNAVEOE->callbackData != NULL)                                 // If RAM has been allocated for the copy of the data
-    && (packetUBXNAVEOE->automaticFlags.flags.bits.callbackCopyValid == true)) // If the copy of the data is valid
-  {
-    if (packetUBXNAVEOE->callbackPointer != NULL) // If the pointer to the callback has been defined
-    {
-      // if (_printDebug == true)
-      //   _debugSerial->println(F("checkCallbacks: calling callback for NAV EOE"));
-      packetUBXNAVEOE->callbackPointer(*packetUBXNAVEOE->callbackData); // Call the callback
-    }
-    if (packetUBXNAVEOE->callbackPointerPtr != NULL) // If the pointer to the callback has been defined
-    {
-      // if (_printDebug == true)
-      //   _debugSerial->println(F("checkCallbacks: calling callbackPtr for NAV EOE"));
-      packetUBXNAVEOE->callbackPointerPtr(packetUBXNAVEOE->callbackData); // Call the callback
-    }
-    packetUBXNAVEOE->automaticFlags.flags.bits.callbackCopyValid = false; // Mark the data as stale
-  }
-
   if ((packetUBXNAVATT != NULL)                                                  // If RAM has been allocated for message storage
       && (packetUBXNAVATT->callbackData != NULL)                                 // If RAM has been allocated for the copy of the data
       && (packetUBXNAVATT->automaticFlags.flags.bits.callbackCopyValid == true)) // If the copy of the data is valid
@@ -5331,25 +5332,6 @@ void SFE_UBLOX_GNSS::checkCallbacks(void)
     packetUBXNAVODO->automaticFlags.flags.bits.callbackCopyValid = false; // Mark the data as stale
   }
 
-  if ((packetUBXNAVTIMEUTC != NULL)                                                // If RAM has been allocated for message storage
-    && (packetUBXNAVTIMEUTC->callbackData != NULL)                                 // If RAM has been allocated for the copy of the data
-    && (packetUBXNAVTIMEUTC->automaticFlags.flags.bits.callbackCopyValid == true)) // If the copy of the data is valid
-  {
-    if (packetUBXNAVTIMEUTC->callbackPointer != NULL) // If the pointer to the callback has been defined
-    {
-      // if (_printDebug == true)
-      //   _debugSerial->println(F("checkCallbacks: calling callback for NAV TIMEUTC"));
-      packetUBXNAVTIMEUTC->callbackPointer(*packetUBXNAVTIMEUTC->callbackData); // Call the callback
-    }
-    if (packetUBXNAVTIMEUTC->callbackPointerPtr != NULL) // If the pointer to the callback has been defined
-    {
-      // if (_printDebug == true)
-      //   _debugSerial->println(F("checkCallbacks: calling callbackPtr for NAV TIMEUTC"));
-      packetUBXNAVTIMEUTC->callbackPointerPtr(packetUBXNAVTIMEUTC->callbackData); // Call the callback
-    }
-    packetUBXNAVTIMEUTC->automaticFlags.flags.bits.callbackCopyValid = false; // Mark the data as stale
-  }
-
   if ((packetUBXNAVVELECEF != NULL)                                                  // If RAM has been allocated for message storage
       && (packetUBXNAVVELECEF->callbackData != NULL)                                 // If RAM has been allocated for the copy of the data
       && (packetUBXNAVVELECEF->automaticFlags.flags.bits.callbackCopyValid == true)) // If the copy of the data is valid
@@ -5445,6 +5427,19 @@ void SFE_UBLOX_GNSS::checkCallbacks(void)
     packetUBXNAVPVAT->automaticFlags.flags.bits.callbackCopyValid = false; // Mark the data as stale
   }
 
+  if ((packetUBXNAVTIMEUTC != NULL)                                                // If RAM has been allocated for message storage
+    && (packetUBXNAVTIMEUTC->callbackData != NULL)                                 // If RAM has been allocated for the copy of the data
+    && (packetUBXNAVTIMEUTC->automaticFlags.flags.bits.callbackCopyValid == true)) // If the copy of the data is valid
+  {
+    if (packetUBXNAVTIMEUTC->callbackPointerPtr != NULL) // If the pointer to the callback has been defined
+    {
+      // if (_printDebug == true)
+      //   _debugSerial->println(F("checkCallbacks: calling callbackPtr for NAV TIMEUTC"));
+      packetUBXNAVTIMEUTC->callbackPointerPtr(packetUBXNAVTIMEUTC->callbackData); // Call the callback
+    }
+    packetUBXNAVTIMEUTC->automaticFlags.flags.bits.callbackCopyValid = false; // Mark the data as stale
+  }
+
   if ((packetUBXNAVCLOCK != NULL)                                                  // If RAM has been allocated for message storage
       && (packetUBXNAVCLOCK->callbackData != NULL)                                 // If RAM has been allocated for the copy of the data
       && (packetUBXNAVCLOCK->automaticFlags.flags.bits.callbackCopyValid == true)) // If the copy of the data is valid
@@ -5534,6 +5529,19 @@ void SFE_UBLOX_GNSS::checkCallbacks(void)
     packetUBXNAVAOPSTATUS->automaticFlags.flags.bits.callbackCopyValid = false; // Mark the data as stale
   }
 
+  if ((packetUBXNAVEOE != NULL)                                                // If RAM has been allocated for message storage
+    && (packetUBXNAVEOE->callbackData != NULL)                                 // If RAM has been allocated for the copy of the data
+    && (packetUBXNAVEOE->automaticFlags.flags.bits.callbackCopyValid == true)) // If the copy of the data is valid
+  {
+    if (packetUBXNAVEOE->callbackPointerPtr != NULL) // If the pointer to the callback has been defined
+    {
+      // if (_printDebug == true)
+      //   _debugSerial->println(F("checkCallbacks: calling callbackPtr for NAV EOE"));
+      packetUBXNAVEOE->callbackPointerPtr(packetUBXNAVEOE->callbackData); // Call the callback
+    }
+    packetUBXNAVEOE->automaticFlags.flags.bits.callbackCopyValid = false; // Mark the data as stale
+  }
+
   if ((packetUBXRXMPMP != NULL)                                                  // If RAM has been allocated for message storage
       && (packetUBXRXMPMP->callbackData != NULL)                                 // If RAM has been allocated for the copy of the data
       && (packetUBXRXMPMP->callbackPointerPtr != NULL)                           // If the pointer to the callback has been defined
@@ -9977,7 +9985,7 @@ void SFE_UBLOX_GNSS::logNAVDOP(bool enabled)
 
 // ***** EOE automatic support
 
-bool SFE_UBLOX_GNSS::getEOE(uint16_t maxWait)
+bool SFE_UBLOX_GNSS::getNAVEOE(uint16_t maxWait)
 {
   if (packetUBXNAVEOE == NULL)
     initPacketUBXNAVEOE();     // Check that RAM has been allocated for the EOE data
@@ -10042,21 +10050,21 @@ bool SFE_UBLOX_GNSS::getEOE(uint16_t maxWait)
 
 // Enable or disable automatic navigation message generation by the GNSS. This changes the way getEOE
 // works.
-bool SFE_UBLOX_GNSS::setAutoEOE(bool enable, uint16_t maxWait)
+bool SFE_UBLOX_GNSS::setAutoNAVEOE(bool enable, uint16_t maxWait)
 {
-  return setAutoEOErate(enable ? 1 : 0, true, maxWait);
+  return setAutoNAVEOErate(enable ? 1 : 0, true, maxWait);
 }
 
 // Enable or disable automatic navigation message generation by the GNSS. This changes the way getEOE
 // works.
-bool SFE_UBLOX_GNSS::setAutoEOE(bool enable, bool implicitUpdate, uint16_t maxWait)
+bool SFE_UBLOX_GNSS::setAutoNAVEOE(bool enable, bool implicitUpdate, uint16_t maxWait)
 {
-  return setAutoEOErate(enable ? 1 : 0, implicitUpdate, maxWait);
+  return setAutoNAVEOErate(enable ? 1 : 0, implicitUpdate, maxWait);
 }
 
 // Enable or disable automatic navigation message generation by the GNSS. This changes the way getEOE
 // works.
-bool SFE_UBLOX_GNSS::setAutoEOErate(uint8_t rate, bool implicitUpdate, uint16_t maxWait)
+bool SFE_UBLOX_GNSS::setAutoNAVEOErate(uint8_t rate, bool implicitUpdate, uint16_t maxWait)
 {
   if (packetUBXNAVEOE == NULL)
     initPacketUBXNAVEOE();     // Check that RAM has been allocated for the data
@@ -10082,10 +10090,10 @@ bool SFE_UBLOX_GNSS::setAutoEOErate(uint8_t rate, bool implicitUpdate, uint16_t
 }
 
 // Enable automatic navigation message generation by the GNSS.
-bool SFE_UBLOX_GNSS::setAutoEOEcallback(void (*callbackPointer)(UBX_NAV_EOE_data_t), uint16_t maxWait)
+bool SFE_UBLOX_GNSS::setAutoNAVEOEcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_EOE_data_t *), uint16_t maxWait)
 {
   // Enable auto messages. Set implicitUpdate to false as we expect the user to call checkUblox manually.
-  bool result = setAutoEOE(true, false, maxWait);
+  bool result = setAutoNAVEOE(true, false, maxWait);
   if (!result)
     return (result); // Bail if setAuto failed
 
@@ -10098,32 +10106,7 @@ bool SFE_UBLOX_GNSS::setAutoEOEcallback(void (*callbackPointer)(UBX_NAV_EOE_data
   {
 #ifndef SFE_UBLOX_REDUCED_PROG_MEM
     if ((_printDebug == true) || (_printLimitedDebug == true)) // This is important. Print this if doing limited debugging
-      _debugSerial->println(F("setAutoEOEcallback: RAM alloc failed!"));
+      _debugSerial->println(F("setAutoNAVEOEcallbackPtr: RAM alloc failed!"));
-#endif
-    return (false);
-  }
-
-  packetUBXNAVEOE->callbackPointer = callbackPointer;
-  return (true);
-}
-
-bool SFE_UBLOX_GNSS::setAutoEOEcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_EOE_data_t *), uint16_t maxWait)
-{
-  // Enable auto messages. Set implicitUpdate to false as we expect the user to call checkUblox manually.
-  bool result = setAutoEOE(true, false, maxWait);
-  if (!result)
-    return (result); // Bail if setAuto failed
-
-  if (packetUBXNAVEOE->callbackData == NULL) // Check if RAM has been allocated for the callback copy
-  {
-    packetUBXNAVEOE->callbackData = new UBX_NAV_EOE_data_t; // Allocate RAM for the main struct
-  }
-
-  if (packetUBXNAVEOE->callbackData == NULL)
-  {
-#ifndef SFE_UBLOX_REDUCED_PROG_MEM
-    if ((_printDebug == true) || (_printLimitedDebug == true)) // This is important. Print this if doing limited debugging
-      _debugSerial->println(F("setAutoEOEcallbackPtr: RAM alloc failed!"));
 #endif
     return (false);
   }
@@ -10134,7 +10117,7 @@ bool SFE_UBLOX_GNSS::setAutoEOEcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_EO
 
 // In case no config access to the GNSS is possible and EOE is send cyclically already
 // set config to suitable parameters
-bool SFE_UBLOX_GNSS::assumeAutoEOE(bool enabled, bool implicitUpdate)
+bool SFE_UBLOX_GNSS::assumeAutoNAVEOE(bool enabled, bool implicitUpdate)
 {
   if (packetUBXNAVEOE == NULL)
     initPacketUBXNAVEOE();     // Check that RAM has been allocated for the data
@@ -10163,7 +10146,6 @@ bool SFE_UBLOX_GNSS::initPacketUBXNAVEOE()
     return (false);
   }
   packetUBXNAVEOE->automaticFlags.flags.all = 0;
-  packetUBXNAVEOE->callbackPointer = NULL;
   packetUBXNAVEOE->callbackPointerPtr = NULL;
   packetUBXNAVEOE->callbackData = NULL;
   packetUBXNAVEOE->moduleQueried.moduleQueried.all = 0;
@@ -10171,7 +10153,7 @@ bool SFE_UBLOX_GNSS::initPacketUBXNAVEOE()
 }
 
 // Mark all the EOE data as read/stale. This is handy to get data alignment after CRC failure
-void SFE_UBLOX_GNSS::flushEOE()
+void SFE_UBLOX_GNSS::flushNAVEOE()
 {
   if (packetUBXNAVEOE == NULL)
     return;                                             // Bail if RAM has not been allocated (otherwise we could be writing anywhere!)
@@ -10797,195 +10779,6 @@ void SFE_UBLOX_GNSS::logNAVODO(bool enabled)
   packetUBXNAVODO->automaticFlags.flags.bits.addToFileBuffer = (uint8_t)enabled;
 }
 
-// ***** NAV TIMEUTC automatic support
-
-bool SFE_UBLOX_GNSS::getNAVTIMEUTC(uint16_t maxWait)
-{
-  if (packetUBXNAVTIMEUTC == NULL)
-    initPacketUBXNAVTIMEUTC();     // Check that RAM has been allocated for the TIMEUTC data
-  if (packetUBXNAVTIMEUTC == NULL) // Bail if the RAM allocation failed
-    return (false);
-
-  if (packetUBXNAVTIMEUTC->automaticFlags.flags.bits.automatic && packetUBXNAVTIMEUTC->automaticFlags.flags.bits.implicitUpdate)
-  {
-    // The GPS is automatically reporting, we just check whether we got unread data
-    checkUbloxInternal(&packetCfg, UBX_CLASS_NAV, UBX_NAV_TIMEUTC);
-    return packetUBXNAVTIMEUTC->moduleQueried.moduleQueried.bits.all;
-  }
-  else if (packetUBXNAVTIMEUTC->automaticFlags.flags.bits.automatic && !packetUBXNAVTIMEUTC->automaticFlags.flags.bits.implicitUpdate)
-  {
-    // Someone else has to call checkUblox for us...
-    return (false);
-  }
-  else
-  {
-    // The GPS is not automatically reporting navigation position so we have to poll explicitly
-    packetCfg.cls = UBX_CLASS_NAV;
-    packetCfg.id = UBX_NAV_TIMEUTC;
-    packetCfg.len = 0;
-    packetCfg.startingSpot = 0;
-
-    // The data is parsed as part of processing the response
-    sfe_ublox_status_e retVal = sendCommand(&packetCfg, maxWait);
-
-    if (retVal == SFE_UBLOX_STATUS_DATA_RECEIVED)
-      return (true);
-
-    if (retVal == SFE_UBLOX_STATUS_DATA_OVERWRITTEN)
-    {
-      return (true);
-    }
-
-    return (false);
-  }
-}
-
-// Enable or disable automatic navigation message generation by the GNSS. This changes the way getTIMEUTC
-// works.
-bool SFE_UBLOX_GNSS::setAutoNAVTIMEUTC(bool enable, uint16_t maxWait)
-{
-  return setAutoNAVTIMEUTCrate(enable ? 1 : 0, true, maxWait);
-}
-
-// Enable or disable automatic navigation message generation by the GNSS. This changes the way getTIMEUTC
-// works.
-bool SFE_UBLOX_GNSS::setAutoNAVTIMEUTC(bool enable, bool implicitUpdate, uint16_t maxWait)
-{
-  return setAutoNAVTIMEUTCrate(enable ? 1 : 0, implicitUpdate, maxWait);
-}
-
-// Enable or disable automatic navigation message generation by the GNSS. This changes the way getTIMEUTC
-// works.
-bool SFE_UBLOX_GNSS::setAutoNAVTIMEUTCrate(uint8_t rate, bool implicitUpdate, uint16_t maxWait)
-{
-  if (packetUBXNAVTIMEUTC == NULL)
-    initPacketUBXNAVTIMEUTC();     // Check that RAM has been allocated for the data
-  if (packetUBXNAVTIMEUTC == NULL) // Only attempt this if RAM allocation was successful
-    return false;
-
-  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_TIMEUTC;
-  payloadCfg[2] = rate; // rate relative to navigation freq.
-
-  bool ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
-  if (ok)
-  {
-    packetUBXNAVTIMEUTC->automaticFlags.flags.bits.automatic = (rate > 0);
-    packetUBXNAVTIMEUTC->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
-  }
-  packetUBXNAVTIMEUTC->moduleQueried.moduleQueried.bits.all = false;
-  return ok;
-}
-
-// Enable automatic navigation message generation by the GNSS.
-bool SFE_UBLOX_GNSS::setAutoNAVTIMEUTCcallback(void (*callbackPointer)(UBX_NAV_TIMEUTC_data_t), uint16_t maxWait)
-{
-  // Enable auto messages. Set implicitUpdate to false as we expect the user to call checkUblox manually.
-  bool result = setAutoNAVTIMEUTC(true, false, maxWait);
-  if (!result)
-    return (result); // Bail if setAuto failed
-
-  if (packetUBXNAVTIMEUTC->callbackData == NULL) // Check if RAM has been allocated for the callback copy
-  {
-    packetUBXNAVTIMEUTC->callbackData = new UBX_NAV_TIMEUTC_data_t; // Allocate RAM for the main struct
-  }
-
-  if (packetUBXNAVTIMEUTC->callbackData == NULL)
-  {
-#ifndef SFE_UBLOX_REDUCED_PROG_MEM
-    if ((_printDebug == true) || (_printLimitedDebug == true)) // This is important. Print this if doing limited debugging
-      _debugSerial->println(F("setAutoNAVTIMEUTCcallback: RAM alloc failed!"));
-#endif
-    return (false);
-  }
-
-  packetUBXNAVTIMEUTC->callbackPointer = callbackPointer;
-  return (true);
-}
-
-bool SFE_UBLOX_GNSS::setAutoNAVTIMEUTCcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_TIMEUTC_data_t *), uint16_t maxWait)
-{
-  // Enable auto messages. Set implicitUpdate to false as we expect the user to call checkUblox manually.
-  bool result = setAutoNAVTIMEUTC(true, false, maxWait);
-  if (!result)
-    return (result); // Bail if setAuto failed
-
-  if (packetUBXNAVTIMEUTC->callbackData == NULL) // Check if RAM has been allocated for the callback copy
-  {
-    packetUBXNAVTIMEUTC->callbackData = new UBX_NAV_TIMEUTC_data_t; // Allocate RAM for the main struct
-  }
-
-  if (packetUBXNAVTIMEUTC->callbackData == NULL)
-  {
-#ifndef SFE_UBLOX_REDUCED_PROG_MEM
-    if ((_printDebug == true) || (_printLimitedDebug == true)) // This is important. Print this if doing limited debugging
-      _debugSerial->println(F("setAutoNAVTIMEUTCcallbackPtr: RAM alloc failed!"));
-#endif
-    return (false);
-  }
-
-  packetUBXNAVTIMEUTC->callbackPointerPtr = callbackPointerPtr;
-  return (true);
-}
-
-// In case no config access to the GNSS is possible and TIMEUTC is send cyclically already
-// set config to suitable parameters
-bool SFE_UBLOX_GNSS::assumeAutoNAVTIMEUTC(bool enabled, bool implicitUpdate)
-{
-  if (packetUBXNAVTIMEUTC == NULL)
-    initPacketUBXNAVTIMEUTC();     // Check that RAM has been allocated for the data
-  if (packetUBXNAVTIMEUTC == NULL) // Only attempt this if RAM allocation was successful
-    return false;
-
-  bool changes = packetUBXNAVTIMEUTC->automaticFlags.flags.bits.automatic != enabled || packetUBXNAVTIMEUTC->automaticFlags.flags.bits.implicitUpdate != implicitUpdate;
-  if (changes)
-  {
-    packetUBXNAVTIMEUTC->automaticFlags.flags.bits.automatic = enabled;
-    packetUBXNAVTIMEUTC->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
-  }
-  return changes;
-}
-
-// PRIVATE: Allocate RAM for packetUBXNAVTIMEUTC and initialize it
-bool SFE_UBLOX_GNSS::initPacketUBXNAVTIMEUTC()
-{
-  packetUBXNAVTIMEUTC = new UBX_NAV_TIMEUTC_t; // Allocate RAM for the main struct
-  if (packetUBXNAVTIMEUTC == NULL)
-  {
-#ifndef SFE_UBLOX_REDUCED_PROG_MEM
-    if ((_printDebug == true) || (_printLimitedDebug == true)) // This is important. Print this if doing limited debugging
-      _debugSerial->println(F("initPacketUBXNAVTIMEUTC: RAM alloc failed!"));
-#endif
-    return (false);
-  }
-  packetUBXNAVTIMEUTC->automaticFlags.flags.all = 0;
-  packetUBXNAVTIMEUTC->callbackPointer = NULL;
-  packetUBXNAVTIMEUTC->callbackPointerPtr = NULL;
-  packetUBXNAVTIMEUTC->callbackData = NULL;
-  packetUBXNAVTIMEUTC->moduleQueried.moduleQueried.all = 0;
-  return (true);
-}
-
-// Mark all the data as read/stale
-void SFE_UBLOX_GNSS::flushNAVTIMEUTC()
-{
-  if (packetUBXNAVTIMEUTC == NULL)
-    return;                                                 // Bail if RAM has not been allocated (otherwise we could be writing anywhere!)
-  packetUBXNAVTIMEUTC->moduleQueried.moduleQueried.all = 0; // Mark all datums as stale (read before)
-}
-
-// Log this data in file buffer
-void SFE_UBLOX_GNSS::logNAVTIMEUTC(bool enabled)
-{
-  if (packetUBXNAVTIMEUTC == NULL)
-    return; // Bail if RAM has not been allocated (otherwise we could be writing anywhere!)
-  packetUBXNAVTIMEUTC->automaticFlags.flags.bits.addToFileBuffer = (uint8_t)enabled;
-}
-
 // ***** NAV VELECEF automatic support
 
 bool SFE_UBLOX_GNSS::getNAVVELECEF(uint16_t maxWait)
@@ -11969,6 +11762,169 @@ void SFE_UBLOX_GNSS::logNAVPVAT(bool enabled)
   packetUBXNAVPVAT->automaticFlags.flags.bits.addToFileBuffer = (uint8_t)enabled;
 }
 
+// ***** NAV TIMEUTC automatic support
+
+bool SFE_UBLOX_GNSS::getNAVTIMEUTC(uint16_t maxWait)
+{
+  if (packetUBXNAVTIMEUTC == NULL)
+    initPacketUBXNAVTIMEUTC();     // Check that RAM has been allocated for the TIMEUTC data
+  if (packetUBXNAVTIMEUTC == NULL) // Bail if the RAM allocation failed
+    return (false);
+
+  if (packetUBXNAVTIMEUTC->automaticFlags.flags.bits.automatic && packetUBXNAVTIMEUTC->automaticFlags.flags.bits.implicitUpdate)
+  {
+    // The GPS is automatically reporting, we just check whether we got unread data
+    checkUbloxInternal(&packetCfg, UBX_CLASS_NAV, UBX_NAV_TIMEUTC);
+    return packetUBXNAVTIMEUTC->moduleQueried.moduleQueried.bits.all;
+  }
+  else if (packetUBXNAVTIMEUTC->automaticFlags.flags.bits.automatic && !packetUBXNAVTIMEUTC->automaticFlags.flags.bits.implicitUpdate)
+  {
+    // Someone else has to call checkUblox for us...
+    return (false);
+  }
+  else
+  {
+    // The GPS is not automatically reporting navigation position so we have to poll explicitly
+    packetCfg.cls = UBX_CLASS_NAV;
+    packetCfg.id = UBX_NAV_TIMEUTC;
+    packetCfg.len = 0;
+    packetCfg.startingSpot = 0;
+
+    // The data is parsed as part of processing the response
+    sfe_ublox_status_e retVal = sendCommand(&packetCfg, maxWait);
+
+    if (retVal == SFE_UBLOX_STATUS_DATA_RECEIVED)
+      return (true);
+
+    if (retVal == SFE_UBLOX_STATUS_DATA_OVERWRITTEN)
+    {
+      return (true);
+    }
+
+    return (false);
+  }
+}
+
+// Enable or disable automatic navigation message generation by the GNSS. This changes the way getTIMEUTC
+// works.
+bool SFE_UBLOX_GNSS::setAutoNAVTIMEUTC(bool enable, uint16_t maxWait)
+{
+  return setAutoNAVTIMEUTCrate(enable ? 1 : 0, true, maxWait);
+}
+
+// Enable or disable automatic navigation message generation by the GNSS. This changes the way getTIMEUTC
+// works.
+bool SFE_UBLOX_GNSS::setAutoNAVTIMEUTC(bool enable, bool implicitUpdate, uint16_t maxWait)
+{
+  return setAutoNAVTIMEUTCrate(enable ? 1 : 0, implicitUpdate, maxWait);
+}
+
+// Enable or disable automatic navigation message generation by the GNSS. This changes the way getTIMEUTC
+// works.
+bool SFE_UBLOX_GNSS::setAutoNAVTIMEUTCrate(uint8_t rate, bool implicitUpdate, uint16_t maxWait)
+{
+  if (packetUBXNAVTIMEUTC == NULL)
+    initPacketUBXNAVTIMEUTC();     // Check that RAM has been allocated for the data
+  if (packetUBXNAVTIMEUTC == NULL) // Only attempt this if RAM allocation was successful
+    return false;
+
+  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_TIMEUTC;
+  payloadCfg[2] = rate; // rate relative to navigation freq.
+
+  bool ok = ((sendCommand(&packetCfg, maxWait)) == SFE_UBLOX_STATUS_DATA_SENT); // We are only expecting an ACK
+  if (ok)
+  {
+    packetUBXNAVTIMEUTC->automaticFlags.flags.bits.automatic = (rate > 0);
+    packetUBXNAVTIMEUTC->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
+  }
+  packetUBXNAVTIMEUTC->moduleQueried.moduleQueried.bits.all = false;
+  return ok;
+}
+
+// Enable automatic navigation message generation by the GNSS.
+bool SFE_UBLOX_GNSS::setAutoNAVTIMEUTCcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_TIMEUTC_data_t *), uint16_t maxWait)
+{
+  // Enable auto messages. Set implicitUpdate to false as we expect the user to call checkUblox manually.
+  bool result = setAutoNAVTIMEUTC(true, false, maxWait);
+  if (!result)
+    return (result); // Bail if setAuto failed
+
+  if (packetUBXNAVTIMEUTC->callbackData == NULL) // Check if RAM has been allocated for the callback copy
+  {
+    packetUBXNAVTIMEUTC->callbackData = new UBX_NAV_TIMEUTC_data_t; // Allocate RAM for the main struct
+  }
+
+  if (packetUBXNAVTIMEUTC->callbackData == NULL)
+  {
+#ifndef SFE_UBLOX_REDUCED_PROG_MEM
+    if ((_printDebug == true) || (_printLimitedDebug == true)) // This is important. Print this if doing limited debugging
+      _debugSerial->println(F("setAutoNAVTIMEUTCcallbackPtr: RAM alloc failed!"));
+#endif
+    return (false);
+  }
+
+  packetUBXNAVTIMEUTC->callbackPointerPtr = callbackPointerPtr;
+  return (true);
+}
+
+// In case no config access to the GNSS is possible and TIMEUTC is send cyclically already
+// set config to suitable parameters
+bool SFE_UBLOX_GNSS::assumeAutoNAVTIMEUTC(bool enabled, bool implicitUpdate)
+{
+  if (packetUBXNAVTIMEUTC == NULL)
+    initPacketUBXNAVTIMEUTC();     // Check that RAM has been allocated for the data
+  if (packetUBXNAVTIMEUTC == NULL) // Only attempt this if RAM allocation was successful
+    return false;
+
+  bool changes = packetUBXNAVTIMEUTC->automaticFlags.flags.bits.automatic != enabled || packetUBXNAVTIMEUTC->automaticFlags.flags.bits.implicitUpdate != implicitUpdate;
+  if (changes)
+  {
+    packetUBXNAVTIMEUTC->automaticFlags.flags.bits.automatic = enabled;
+    packetUBXNAVTIMEUTC->automaticFlags.flags.bits.implicitUpdate = implicitUpdate;
+  }
+  return changes;
+}
+
+// PRIVATE: Allocate RAM for packetUBXNAVTIMEUTC and initialize it
+bool SFE_UBLOX_GNSS::initPacketUBXNAVTIMEUTC()
+{
+  packetUBXNAVTIMEUTC = new UBX_NAV_TIMEUTC_t; // Allocate RAM for the main struct
+  if (packetUBXNAVTIMEUTC == NULL)
+  {
+#ifndef SFE_UBLOX_REDUCED_PROG_MEM
+    if ((_printDebug == true) || (_printLimitedDebug == true)) // This is important. Print this if doing limited debugging
+      _debugSerial->println(F("initPacketUBXNAVTIMEUTC: RAM alloc failed!"));
+#endif
+    return (false);
+  }
+  packetUBXNAVTIMEUTC->automaticFlags.flags.all = 0;
+  packetUBXNAVTIMEUTC->callbackPointerPtr = NULL;
+  packetUBXNAVTIMEUTC->callbackData = NULL;
+  packetUBXNAVTIMEUTC->moduleQueried.moduleQueried.all = 0;
+  return (true);
+}
+
+// Mark all the data as read/stale
+void SFE_UBLOX_GNSS::flushNAVTIMEUTC()
+{
+  if (packetUBXNAVTIMEUTC == NULL)
+    return;                                                 // Bail if RAM has not been allocated (otherwise we could be writing anywhere!)
+  packetUBXNAVTIMEUTC->moduleQueried.moduleQueried.all = 0; // Mark all datums as stale (read before)
+}
+
+// Log this data in file buffer
+void SFE_UBLOX_GNSS::logNAVTIMEUTC(bool enabled)
+{
+  if (packetUBXNAVTIMEUTC == NULL)
+    return; // Bail if RAM has not been allocated (otherwise we could be writing anywhere!)
+  packetUBXNAVTIMEUTC->automaticFlags.flags.bits.addToFileBuffer = (uint8_t)enabled;
+}
+
 // ***** NAV CLOCK automatic support
 
 bool SFE_UBLOX_GNSS::getNAVCLOCK(uint16_t maxWait)

src/SparkFun_u-blox_GNSS_Arduino_Library.h

@@ -1021,16 +1021,6 @@ public:
   void flushDOP();                                                                                                 // Mark all the DOP data as read/stale
   void logNAVDOP(bool enabled = true);                                                                             // Log data to file buffer
 
-  bool getEOE(uint16_t maxWait = defaultMaxWait);                                                                  // Query module for latest dilution of precision values and load global vars:. If autoEOE is disabled, performs an explicit poll and waits, if enabled does not block. Returns true if new EOE is available.
-  bool setAutoEOE(bool enabled, uint16_t maxWait = defaultMaxWait);                                                // Enable/disable automatic EOE reports at the navigation frequency
-  bool setAutoEOE(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic EOE reports at the navigation frequency, with implicitUpdate == false accessing stale data will not issue parsing of data in the rxbuffer of your interface, instead you have to call checkUblox when you want to perform an update
-  bool setAutoEOErate(uint8_t rate, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                       // Set the rate for automatic EOE reports
-  bool setAutoEOEcallback(void (*callbackPointer)(UBX_NAV_EOE_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic EOE reports at the navigation frequency. Data is accessed from the callback.
-  bool setAutoEOEcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_EOE_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic EOE reports at the navigation frequency. Data is accessed from the callback.
-  bool assumeAutoEOE(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and EOE is send cyclically already
-  void flushEOE();                                                                                                 // Mark all the EOE data as read/stale
-  void logNAVEOE(bool enabled = true);                                                                             // Log data to file buffer
-
   bool getVehAtt(uint16_t maxWait = defaultMaxWait);                                                                  // NAV ATT Helper
   bool getNAVATT(uint16_t maxWait = defaultMaxWait);                                                                  // NAV ATT
   bool setAutoNAVATT(bool enabled, uint16_t maxWait = defaultMaxWait);                                                // Enable/disable automatic vehicle attitude reports at the navigation frequency
@@ -1062,16 +1052,6 @@ public:
   void flushNAVODO();                                                                                                 // Mark all the data as read/stale
   void logNAVODO(bool enabled = true);                                                                                // Log data to file buffer
 
-  bool getNAVTIMEUTC(uint16_t maxWait = defaultMaxWait);                                                                      // NAV TIMEUTC
-  bool setAutoNAVTIMEUTC(bool enabled, uint16_t maxWait = defaultMaxWait);                                                    // Enable/disable automatic TIMEUTC reports at the navigation frequency
-  bool setAutoNAVTIMEUTC(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                               // Enable/disable automatic TIMEUTC reports at the navigation frequency, with implicitUpdate == false accessing stale data will not issue parsing of data in the rxbuffer of your interface, instead you have to call checkUblox when you want to perform an update
-  bool setAutoNAVTIMEUTCrate(uint8_t rate, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Set the rate for automatic TIMEUTC reports
-  bool setAutoNAVTIMEUTCcallback(void (*callbackPointer)(UBX_NAV_TIMEUTC_data_t), uint16_t maxWait = defaultMaxWait);         // Enable automatic TIMEUTC reports at the navigation frequency. Data is accessed from the callback.
-  bool setAutoNAVTIMEUTCcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_TIMEUTC_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic TIMEUTC reports at the navigation frequency. Data is accessed from the callback.
-  bool assumeAutoNAVTIMEUTC(bool enabled, bool implicitUpdate = true);                                                        // In case no config access to the GPS is possible and TIMEUTC is send cyclically already
-  void flushNAVTIMEUTC();                                                                                                     // Mark all the data as read/stale
-  void logNAVTIMEUTC(bool enabled = true);                                                                                    // Log data to file buffer
-
   bool getNAVVELECEF(uint16_t maxWait = defaultMaxWait);                                                                      // NAV VELECEF
   bool setAutoNAVVELECEF(bool enabled, uint16_t maxWait = defaultMaxWait);                                                    // Enable/disable automatic VELECEF reports at the navigation frequency
   bool setAutoNAVVELECEF(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                               // Enable/disable automatic VELECEF reports at the navigation frequency, with implicitUpdate == false accessing stale data will not issue parsing of data in the rxbuffer of your interface, instead you have to call checkUblox when you want to perform an update
@@ -1122,6 +1102,15 @@ public:
   void flushNAVPVAT();                                                                                                  // Mark all the PVAT data as read/stale
   void logNAVPVAT(bool enabled = true);                                                                                 // Log data to file buffer
 
+  bool getNAVTIMEUTC(uint16_t maxWait = defaultMaxWait);                                                                      // NAV TIMEUTC
+  bool setAutoNAVTIMEUTC(bool enabled, uint16_t maxWait = defaultMaxWait);                                                    // Enable/disable automatic TIMEUTC reports at the navigation frequency
+  bool setAutoNAVTIMEUTC(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                               // Enable/disable automatic TIMEUTC reports at the navigation frequency, with implicitUpdate == false accessing stale data will not issue parsing of data in the rxbuffer of your interface, instead you have to call checkUblox when you want to perform an update
+  bool setAutoNAVTIMEUTCrate(uint8_t rate, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Set the rate for automatic TIMEUTC reports
+  bool setAutoNAVTIMEUTCcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_TIMEUTC_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic TIMEUTC reports at the navigation frequency. Data is accessed from the callback.
+  bool assumeAutoNAVTIMEUTC(bool enabled, bool implicitUpdate = true);                                                        // In case no config access to the GPS is possible and TIMEUTC is send cyclically already
+  void flushNAVTIMEUTC();                                                                                                     // Mark all the data as read/stale
+  void logNAVTIMEUTC(bool enabled = true);                                                                                    // Log data to file buffer
+
   bool getNAVCLOCK(uint16_t maxWait = defaultMaxWait);                                                                    // NAV CLOCK
   bool setAutoNAVCLOCK(bool enabled, uint16_t maxWait = defaultMaxWait);                                                  // Enable/disable automatic clock reports at the navigation frequency
   bool setAutoNAVCLOCK(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                             // Enable/disable automatic clock reports at the navigation frequency, with implicitUpdate == false accessing stale data will not issue parsing of data in the rxbuffer of your interface, instead you have to call checkUblox when you want to perform an update
@@ -1141,6 +1130,15 @@ public:
   void flushNAVSVIN();                                                                                                  // Mark all the data as read/stale
   void logNAVSVIN(bool enabled = true);                                                                                 // Log data to file buffer
 
+  bool getNAVEOE(uint16_t maxWait = defaultMaxWait);                                                                  // Query module for latest dilution of precision values and load global vars:. If autoEOE is disabled, performs an explicit poll and waits, if enabled does not block. Returns true if new EOE is available.
+  bool setAutoNAVEOE(bool enabled, uint16_t maxWait = defaultMaxWait);                                                // Enable/disable automatic EOE reports at the navigation frequency
+  bool setAutoNAVEOE(bool enabled, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                           // Enable/disable automatic EOE reports at the navigation frequency, with implicitUpdate == false accessing stale data will not issue parsing of data in the rxbuffer of your interface, instead you have to call checkUblox when you want to perform an update
+  bool setAutoNAVEOErate(uint8_t rate, bool implicitUpdate, uint16_t maxWait = defaultMaxWait);                       // Set the rate for automatic EOE reports
+  bool setAutoNAVEOEcallbackPtr(void (*callbackPointerPtr)(UBX_NAV_EOE_data_t *), uint16_t maxWait = defaultMaxWait); // Enable automatic EOE reports at the navigation frequency. Data is accessed from the callback.
+  bool assumeAutoNAVEOE(bool enabled, bool implicitUpdate = true);                                                    // In case no config access to the GPS is possible and EOE is send cyclically already
+  void flushNAVEOE();                                                                                                 // Mark all the EOE data as read/stale
+  void logNAVEOE(bool enabled = true);                                                                                // Log data to file buffer
+
   // Add "auto" support for NAV TIMELS - to avoid needing 'global' storage
   bool getLeapSecondEvent(uint16_t maxWait = defaultMaxWait); // Reads leap second event info
 
@@ -1623,22 +1621,22 @@ private:
   bool initPacketUBXNAVPOSECEF();    // Allocate RAM for packetUBXNAVPOSECEF and initialize it
   bool initPacketUBXNAVSTATUS();     // Allocate RAM for packetUBXNAVSTATUS and initialize it
   bool initPacketUBXNAVDOP();        // Allocate RAM for packetUBXNAVDOP and initialize it
-  bool initPacketUBXNAVEOE();        // Allocate RAM for packetUBXNAVEOE and initialize it
   bool initPacketUBXNAVATT();        // Allocate RAM for packetUBXNAVATT and initialize it
   bool initPacketUBXNAVPVT();        // Allocate RAM for packetUBXNAVPVT and initialize it
   bool initPacketUBXNAVODO();        // Allocate RAM for packetUBXNAVODO and initialize it
-  bool initPacketUBXNAVTIMEUTC();    // Allocate RAM for packetUBXNAVTIMEUTC and initialize it
   bool initPacketUBXNAVVELECEF();    // Allocate RAM for packetUBXNAVVELECEF and initialize it
   bool initPacketUBXNAVVELNED();     // Allocate RAM for packetUBXNAVVELNED and initialize it
   bool initPacketUBXNAVHPPOSECEF();  // Allocate RAM for packetUBXNAVHPPOSECEF and initialize it
   bool initPacketUBXNAVHPPOSLLH();   // Allocate RAM for packetUBXNAVHPPOSLLH and initialize it
   bool initPacketUBXNAVPVAT();       // Allocate RAM for packetUBXNAVPVAT and initialize it
+  bool initPacketUBXNAVTIMEUTC();    // Allocate RAM for packetUBXNAVTIMEUTC and initialize it
   bool initPacketUBXNAVCLOCK();      // Allocate RAM for packetUBXNAVCLOCK and initialize it
   bool initPacketUBXNAVTIMELS();     // Allocate RAM for packetUBXNAVTIMELS and initialize it
   bool initPacketUBXNAVSVIN();       // Allocate RAM for packetUBXNAVSVIN and initialize it
   bool initPacketUBXNAVSAT();        // Allocate RAM for packetUBXNAVSAT and initialize it
   bool initPacketUBXNAVRELPOSNED();  // Allocate RAM for packetUBXNAVRELPOSNED and initialize it
   bool initPacketUBXNAVAOPSTATUS();  // Allocate RAM for packetUBXNAVAOPSTATUS and initialize it
+  bool initPacketUBXNAVEOE();        // Allocate RAM for packetUBXNAVEOE and initialize it
   bool initPacketUBXRXMPMP();        // Allocate RAM for packetUBXRXMPMP and initialize it
   bool initPacketUBXRXMPMPmessage(); // Allocate RAM for packetUBXRXMPMPRaw and initialize it
   bool initPacketUBXRXMCOR();        // Allocate RAM for packetUBXRXMCOR and initialize it

src/u-blox_structs.h

@@ -298,38 +298,6 @@ typedef struct
   UBX_NAV_DOP_data_t *callbackData;
 } UBX_NAV_DOP_t;
 
-// UBX-NAV-EOE (0x01 0x61): End of Epoch
-const uint16_t UBX_NAV_EOE_LEN = 4;
-
-typedef struct
-{
-  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
-} UBX_NAV_EOE_data_t;
-
-typedef struct
-{
-  union
-  {
-    uint32_t all;
-    struct
-    {
-      uint32_t all : 1;
-
-      uint32_t iTOW : 1;
-    } bits;
-  } moduleQueried;
-} UBX_NAV_EOE_moduleQueried_t;
-
-typedef struct
-{
-  ubxAutomaticFlags automaticFlags;
-  UBX_NAV_EOE_data_t data;
-  UBX_NAV_EOE_moduleQueried_t moduleQueried;
-  void (*callbackPointer)(UBX_NAV_EOE_data_t);
-  void (*callbackPointerPtr)(UBX_NAV_EOE_data_t *);
-  UBX_NAV_EOE_data_t  *callbackData;
-} UBX_NAV_EOE_t;
-
 // UBX-NAV-ATT (0x01 0x05): Attitude solution
 const uint16_t UBX_NAV_ATT_LEN = 32;
 
@@ -1031,7 +999,6 @@ typedef struct
   ubxAutomaticFlags automaticFlags;
   UBX_NAV_TIMEUTC_data_t data;
   UBX_NAV_TIMEUTC_moduleQueried_t moduleQueried;
-  void (*callbackPointer)(UBX_NAV_TIMEUTC_data_t);
   void (*callbackPointerPtr)(UBX_NAV_TIMEUTC_data_t *);
   UBX_NAV_TIMEUTC_data_t *callbackData;
 } UBX_NAV_TIMEUTC_t;
@@ -1415,6 +1382,37 @@ typedef struct
   UBX_NAV_AOPSTATUS_data_t *callbackData;
 } UBX_NAV_AOPSTATUS_t;
 
+// UBX-NAV-EOE (0x01 0x61): End of Epoch
+const uint16_t UBX_NAV_EOE_LEN = 4;
+
+typedef struct
+{
+  uint32_t iTOW; // GPS time of week of the navigation epoch: ms
+} UBX_NAV_EOE_data_t;
+
+typedef struct
+{
+  union
+  {
+    uint32_t all;
+    struct
+    {
+      uint32_t all : 1;
+
+      uint32_t iTOW : 1;
+    } bits;
+  } moduleQueried;
+} UBX_NAV_EOE_moduleQueried_t;
+
+typedef struct
+{
+  ubxAutomaticFlags automaticFlags;
+  UBX_NAV_EOE_data_t data;
+  UBX_NAV_EOE_moduleQueried_t moduleQueried;
+  void (*callbackPointerPtr)(UBX_NAV_EOE_data_t *);
+  UBX_NAV_EOE_data_t  *callbackData;
+} UBX_NAV_EOE_t;
+
 // RXM-specific structs
 
 // UBX-RXM-SFRBX (0x02 0x13): Broadcast navigation data subframe