Add support for getVersion, getModelType, getID, getCompileTime.

Author: nseidle

src/SparkFun_Unicore_GNSS_Arduino_Library.cpp

@@ -67,6 +67,7 @@
       FReset
       Reset
       SaveConfig
+      Version
 
   Data Query Commands
 
@@ -187,6 +188,10 @@ bool UM980::updateOnce()
             um980NmeaLineTermination(&unicoreParse, incoming);
             break;
 
+        case (UNICORE_PARSE_STATE_UNICORE_CRC):
+            um980UnicoreCRC(&unicoreParse, incoming);
+            break;
+
         case (UNICORE_PARSE_STATE_UNICORE_SYNC2):
             um980UnicoreBinarySync2(&unicoreParse, incoming);
             break;
@@ -519,7 +524,7 @@ bool UM980::disableOutput()
 // Disable all messages on a given port
 bool UM980::disableOutputPort(const char *comName)
 {
-    //We don't know if this is the COM port we are communicating on, so err on the side of caution.
+    // We don't know if this is the COM port we are communicating on, so err on the side of caution.
     stopAutoReports(); // Remove pointers so we will re-init next check
 
     char command[50];
@@ -691,8 +696,6 @@ Um980Result UM980::sendQuery(const char *command, uint16_t maxWaitMs)
         delay(1);
     }
 
-    // debugPrintf("Found OK to command");
-
     return (UM980_RESULT_OK);
 }
 
@@ -706,8 +709,8 @@ Um980Result UM980::sendString(const char *command, uint16_t maxWaitMs)
 {
     clearBuffer();
 
-    unicoreParse.length = 0; // Reset parser
-    strncpy(commandName, command, sizeof(commandName));
+    unicoreParse.length = 0;                                 // Reset parser
+    strncpy(commandName, command, sizeof(commandName));      // Copy to class so that parsers can see it
     commandResponse = UM980_RESULT_RESPONSE_COMMAND_WAITING; // Reset
 
     serialPrintln(command);
@@ -808,6 +811,14 @@ Um980Result UM980::checkCRC(char *response)
             return;                                                                                                    \
     }
 
+#define CHECK_POINTER_CHAR(packetPointer, initPointer)                                                                 \
+    {                                                                                                                  \
+        if (packetPointer == nullptr)                                                                                  \
+            initPointer();                                                                                             \
+        if (packetPointer == nullptr)                                                                                  \
+            return ((char *)"Error");                                                                                  \
+    }
+
 // Cracks a given binary message into the applicable container
 void UM980::unicoreHandler(uint8_t *response, uint16_t length)
 {
@@ -896,6 +907,69 @@ void UM980::unicoreHandler(uint8_t *response, uint16_t length)
         memcpy(&packetBESTNAVXYZ->data.ecefYDeviation, &data[offsetBestnavXyzPYDeviation], sizeof(float));
         memcpy(&packetBESTNAVXYZ->data.ecefZDeviation, &data[offsetBestnavXyzPZDeviation], sizeof(float));
     }
+    else if (messageID == messageIdVersion)
+    {
+        // debugPrintf("Version Handler");
+        CHECK_POINTER_VOID(packetVERSION, initVersion); // Check that RAM has been allocated
+
+        lastUpdateVersion = millis(); // Update stale marker
+
+        uint8_t *data = &response[um980HeaderLength]; // Point at the start of the data fields
+
+        // Move data into given containers
+        memcpy(&packetVERSION->data.modelType, &data[offsetVersionModuleType], sizeof(packetVERSION->data.modelType));
+        memcpy(&packetVERSION->data.swVersion, &data[offsetVersionFirmwareVersion],
+               sizeof(packetVERSION->data.swVersion));
+        memcpy(&packetVERSION->data.efuseID, &data[offsetVersionEfuseID], sizeof(packetVERSION->data.efuseID));
+        memcpy(&packetVERSION->data.compileTime, &data[offsetVersionCompTime], sizeof(packetVERSION->data.compileTime));
+    }
+    else
+    {
+        debugPrintf("Unknown message id: %d\r\n", messageID);
+    }
+}
+
+// Allocate RAM for packetVERSION and initialize it
+bool UM980::initVersion()
+{
+    packetVERSION = new UNICORE_VERSION_t; // Allocate RAM for the main struct
+    if (packetVERSION == nullptr)
+    {
+        debugPrintf("Pointer alloc fail");
+        return (false);
+    }
+    //   packetVERSION->callbackPointerPtr = nullptr;
+    //   packetVERSION->callbackData = nullptr;
+
+    // Send command for single query
+    if (sendCommand("VERSIONB") == false)
+    {
+        delete packetVERSION;
+        packetVERSION = nullptr; // Remove pointer so we will re-init next check
+        return (false);
+    }
+
+    debugPrintf("VERSION started");
+
+    // Wait until response is received
+    lastUpdateVersion = 0;
+    uint16_t maxWait = 1000; // Wait for one response to come in
+    unsigned long startTime = millis();
+    while (1)
+    {
+        update(); // Call parser
+        if (lastUpdateVersion > 0)
+            break;
+        if (millis() - startTime > maxWait)
+        {
+            debugPrintf("GNSS: Failed to get response from VERSION start");
+            delete packetVERSION;
+            packetVERSION = nullptr;
+            return (false);
+        }
+    }
+
+    return (true);
 }
 
 // Allocate RAM for packetBESTNAV and initialize it
@@ -1241,3 +1315,61 @@ double UM980::getTimeOffsetDeviation()
     CHECK_POINTER_BOOL(packetRECTIME, initRectime); // Check that RAM has been allocated
     return (packetRECTIME->data.timeDeviation);
 }
+
+uint8_t UM980::getModelType()
+{
+    CHECK_POINTER_BOOL(packetVERSION, initVersion); // Check that RAM has been allocated
+    return (packetVERSION->data.modelType);
+}
+char *UM980::getVersion()
+{
+    CHECK_POINTER_CHAR(packetVERSION, initVersion); // Check that RAM has been allocated
+    return (packetVERSION->data.swVersion);
+}
+char *UM980::getID()
+{
+    CHECK_POINTER_CHAR(packetVERSION, initVersion); // Check that RAM has been allocated
+    return (packetVERSION->data.efuseID);
+}
+char *UM980::getCompileTime()
+{
+    CHECK_POINTER_CHAR(packetVERSION, initVersion); // Check that RAM has been allocated
+    return (packetVERSION->data.compileTime);
+}
+
+// Returns pointer to terminated response.
+//$command,VERSION,response: OK*04
+// #VERSION,92,GPS,FINE,2289,167126600,0,0,18,155;UM980,R4.10Build7923,HRPT00-S10C-P,2310415000001-MD22B1224961040,ff3bd496fd7ca68b,2022/09/28*45d62771
+char *UM980::getVersionFull(uint16_t maxWaitMs)
+{
+    if (sendString("VERSION") == UM980_RESULT_OK)
+    {
+        unicoreParse.length = 0; // Reset parser
+        strncpy(commandName, "VERSION", sizeof(commandName));
+        commandResponse = UM980_RESULT_OK; // Tell parser to keep the data in the buffer
+
+        // Feed the parser until we see the actual response to the query
+        int wait = 0;
+        while (1)
+        {
+            if (wait++ == maxWaitMs)
+                return ((char *)"Timeout");
+
+            updateOnce(); // Will call um980EomHandler()
+
+            if (commandResponse == UM980_RESULT_RESPONSE_COMMAND_OK)
+            {
+                // Response sitting in buffer. Return pointer to buffer.
+                unicoreParse.buffer[unicoreParse.length] = '\0'; // Terminate string
+                return ((char *)unicoreParse.buffer);
+            }
+
+            if (commandResponse == UM980_RESULT_RESPONSE_COMMAND_ERROR)
+                return ((char *)"Error1");
+
+            delay(1);
+        }
+    }
+
+    return ((char *)"Error2");
+}

src/SparkFun_Unicore_GNSS_Arduino_Library.h

@@ -76,6 +76,7 @@ const uint16_t offsetHeaderLeapSecond = 21;
 const uint16_t offsetHeaderOutputDelay = 22;
 
 // VERSIONB
+const uint16_t messageIdVersion = 37;
 const uint16_t offsetVersionModuleType = 0;
 const uint16_t offsetVersionFirmwareVersion = 4;
 const uint16_t offsetVersionAuth = 37;
@@ -139,10 +140,11 @@ class UM980
     unsigned long lastUpdateGeodetic = 0;
     unsigned long lastUpdateEcef = 0;
     unsigned long lastUpdateDateTime = 0;
+    unsigned long lastUpdateVersion = 0;
 
     bool staleDateTime();
     bool staleEcef();
-    void stopAutoReports(); //Delete all pointers to force reinit next time a helper function is called
+    void stopAutoReports(); // Delete all pointers to force reinit next time a helper function is called
 
     Um980Result getGeodetic(uint16_t maxWaitMs = 1500);
     Um980Result updateEcef(uint16_t maxWaitMs = 1500);
@@ -266,6 +268,13 @@ class UM980
 
     uint32_t getFixAgeMilliseconds(); // Based on Geodetic report
 
+    uint8_t getModelType();
+    char *getVersion();
+    char *getID();
+    char *getCompileTime();
+
+    char *getVersionFull(uint16_t maxWaitMs = 1500);
+
     void unicoreHandler(uint8_t *data, uint16_t length);
 
     bool initBestnav(uint8_t rate = 1);
@@ -276,6 +285,9 @@ class UM980
 
     bool initRectime(uint8_t rate = 1);
     UNICORE_RECTIME_t *packetRECTIME = nullptr;
+
+    bool initVersion();
+    UNICORE_VERSION_t *packetVERSION = nullptr;
 };
 
 #endif //_SPARKFUN_UNICORE_GNSS_ARDUINO_LIBRARY_H

src/unicore_structs.h

@@ -79,4 +79,21 @@ typedef struct
     UNICORE_RECTIME_data_t *callbackData;
 } UNICORE_RECTIME_t;
 
+// #VERSION,98,GPS,UNKNOWN,1,711000,0,0,18,144;UM980,R4.10Build7923,HRPT00-S10C-P,2310415000001-MD22B1224961040,ff3bd496fd7ca68b,2022/09/28*55f61e51
+typedef struct
+{
+    uint8_t modelType = 0;
+    char swVersion[33 + 1] = {0}; // Add terminator
+    char efuseID[33 + 1] = {0};   // Add terminator
+    char compileTime[43 + 1] = {0};   // Add terminator
+} UNICORE_VERSION_data_t;
+
+typedef struct
+{
+    // ubxAutomaticFlags automaticFlags;
+    UNICORE_VERSION_data_t data;
+    void (*callbackPointerPtr)(UNICORE_VERSION_data_t *);
+    UNICORE_VERSION_data_t *callbackData;
+} UNICORE_VERSION_t;
+
 #endif // _SPARKFUN_UNICORE_STRUCTS_H