Enable different msgs on BT vs Logging. Combine UBX/NMEA logs into one.

Author: nseidle

Firmware/RTK_Surveyor/RTK_Surveyor.ino

@@ -32,11 +32,9 @@
     (Done) Firmware upgrade menu
     Enable various debug outputs sent over BT
 
-    Fix file date/time updates
+    Test file date/time updates
     Test firmware loading
-    Test file listing from debug menu
-    Test file creation from cold start (date/time invalid)
-
+    Add blinking log file icon
 */
 
 const int FIRMWARE_VERSION_MAJOR = 1;
@@ -97,12 +95,8 @@ SPIClass spi = SPIClass(VSPI); //We need to pass the class into SD.begin so we c
 
 char settingsFileName[40] = "SFE_Surveyor_Settings.txt"; //File to read/write system settings to
 
-SdFile nmeaFile; //File that all gnss nmea setences are written to
 SdFile ubxFile; //File that all gnss ubx messages setences are written to
-
-unsigned long lastNMEALogSyncTime = 0; //Used to record to SD every half second
 unsigned long lastUBXLogSyncTime = 0; //Used to record to SD every half second
-
 long startLogTime_minutes = 0; //Mark when we start logging so we can stop logging after maxLogTime_minutes
 
 //SdFat crashes when F9PSerialReadTask() is called in the middle of a ubx file write within loop()
@@ -131,8 +125,8 @@ uint32_t serverBytesSent = 0; //Just a running total
 #include <SparkFun_u-blox_GNSS_Arduino_Library.h> //http://librarymanager/All#SparkFun_u-blox_GNSS
 SFE_UBLOX_GNSS i2cGNSS;
 
-//Note: There are two prevalent versions of the ZED-F9P: v1.12 (part# -01B) and v1.13 (-02B). 
-//v1.13 causes the RTK LED to not function if SBAS is enabled. To avoid this, we 
+//Note: There are two prevalent versions of the ZED-F9P: v1.12 (part# -01B) and v1.13 (-02B).
+//v1.13 causes the RTK LED to not function if SBAS is enabled. To avoid this, we
 //disable SBAS by default.
 
 //Used for config ZED for things not supported in library: getPortSettings, getSerialRate, getNMEASettings, getRTCMSettings
@@ -141,6 +135,9 @@ SFE_UBLOX_GNSS i2cGNSS;
 uint8_t settingPayload[MAX_PAYLOAD_SIZE];
 
 #define gnssFileBufferSize 16384 // Allocate 16KBytes of RAM for UBX message storage
+
+TaskHandle_t F9PI2CTaskHandle = NULL; //Task for regularly checking I2C
+const int i2cTaskStackSize = 2000;
 //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 //Battery fuel gauge and PWM LEDs
@@ -179,8 +176,7 @@ TaskHandle_t F9PSerialWriteTaskHandle = NULL; //Store handles so that we can kil
 TaskHandle_t startUART2TaskHandle = NULL; //Dummy task to start UART2 on core 0.
 bool uart2Started = false;
 
-//Reduced stack size from 10,000 to 1,000 to make room for WiFi/NTRIP server capabilities
-//Increase stacks to 2k to allow for dual file write of NMEA/UBX using built in SD library
+//Reduced stack size from 10,000 to 2,000 to make room for WiFi/NTRIP server capabilities
 const int readTaskStackSize = 2000;
 const int writeTaskStackSize = 2000;
 //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
@@ -308,7 +304,7 @@ void loop()
 
   updateRTC(); //Set system time to GNSS once we have fix
 
-  updateLogs(); //Record any new UBX data. Create files or close NMEA and UBX files as needed.
+  updateLogs(); //Record any new data. Create or close files as needed.
 
   //Menu system via ESP32 USB connection
   if (Serial.available()) menuMain(); //Present user menu
@@ -319,42 +315,30 @@ void loop()
   delay(10); //A small delay prevents panic if no other I2C or functions are called
 }
 
-//Create or close UBX/NMEA files as needed (startup or as user changes settings)
-//Push new UBX packets to log as needed
+//Create or close files as needed (startup or as user changes settings)
+//Push new data to log as needed
 void updateLogs()
 {
-  if (online.nmeaLogging == false && settings.logNMEA == true)
-  {
-    beginLoggingNMEA();
-  }
-  else if (online.nmeaLogging == true && settings.logNMEA == false)
-  {
-    //Close down file
-    nmeaFile.sync();
-    nmeaFile.close();
-    online.nmeaLogging = false;
-  }
-
-  if (online.ubxLogging == false && settings.logUBX == true)
+  if (online.logging == false && logMessages() == true)
   {
-    beginLoggingUBX();
+    beginLogging();
   }
-  else if (online.ubxLogging == true && settings.logUBX == false)
+  else if (online.logging == true && logMessages() == false)
   {
     //Close down file
     ubxFile.sync();
     ubxFile.close();
-    online.ubxLogging = false;
+    online.logging = false;
   }
 
-  if (online.ubxLogging == true)
+  if (online.logging == true)
   {
     //Check if we are inside the max time window for logging
     if ((systemTime_minutes - startLogTime_minutes) < settings.maxLogTime_minutes)
     {
       while (i2cGNSS.fileBufferAvailable() >= sdWriteSize) // Check to see if we have at least sdWriteSize waiting in the buffer
       {
-        //Attempt to write to file system. This avoids collisions with file writing in F9PSerialReadTask()
+        //Attempt to write to file system. This avoids collisions with file writing from other functions like recordSystemSettingsToFile()
         if (xSemaphoreTake(xFATSemaphore, fatSemaphore_maxWait) == pdPASS)
         {
           uint8_t myBuffer[sdWriteSize]; // Create our own buffer to hold the data while we write it to SD card
@@ -382,17 +366,12 @@ void updateLogs()
   }
 
   //Report file sizes to show recording is working
-  if (online.nmeaLogging == true || online.ubxLogging == true)
+  if (online.logging == true)
   {
     if (millis() - lastFileReport > 5000)
     {
       lastFileReport = millis();
-      if (online.nmeaLogging == true && online.ubxLogging == true)
-        Serial.printf("UBX and NMEA file size: %d / %d", ubxFile.fileSize(), nmeaFile.fileSize());
-      else if (online.nmeaLogging == true)
-        Serial.printf("NMEA file size: %d", nmeaFile.fileSize());
-      else if (online.ubxLogging == true)
-        Serial.printf("UBX file size: %d", ubxFile.fileSize());
+      Serial.printf("UBX file size: %d", ubxFile.fileSize());
 
       if ((systemTime_minutes - startLogTime_minutes) > settings.maxLogTime_minutes)
         Serial.printf(" reached max log time %d / System time %d",

Firmware/RTK_Surveyor/System.ino

@@ -40,13 +40,13 @@ bool configureUbloxModule()
 #define OUTPUT_SETTING 14
 #define INPUT_SETTING 12
 
-  //UART1 will primarily be used to pass NMEA from ZED to ESP32 (eventually to cell phone)
+  //UART1 will primarily be used to pass NMEA and UBX from ZED to ESP32 (eventually to cell phone)
   //but the phone can also provide RTCM data. So let's be sure to enable RTCM on UART1 input.
   //Protocol out = NMEA, protocol in = RTCM
   getPortSettings(COM_PORT_UART1); //Load the settingPayload with this port's settings
-  if (settingPayload[OUTPUT_SETTING] != (COM_TYPE_NMEA) || settingPayload[INPUT_SETTING] != COM_TYPE_RTCM3)
+  if (settingPayload[OUTPUT_SETTING] != (COM_TYPE_NMEA | COM_TYPE_UBX) || settingPayload[INPUT_SETTING] != COM_TYPE_RTCM3)
   {
-    response &= i2cGNSS.setPortOutput(COM_PORT_UART1, COM_TYPE_NMEA); //Set the UART1 to output NMEA
+    response &= i2cGNSS.setPortOutput(COM_PORT_UART1, COM_TYPE_NMEA | COM_TYPE_UBX); //Set the UART1 to output NMEA and UBX
     response &= i2cGNSS.setPortInput(COM_PORT_UART1, COM_TYPE_RTCM3); //Set the UART1 to input RTCM
   }
 
@@ -66,9 +66,9 @@ bool configureUbloxModule()
   }
 
   getPortSettings(COM_PORT_I2C); //Load the settingPayload with this port's settings
-  if (settingPayload[OUTPUT_SETTING] != COM_TYPE_UBX || settingPayload[INPUT_SETTING] != COM_TYPE_UBX)
+  if (settingPayload[OUTPUT_SETTING] != (COM_TYPE_UBX | COM_TYPE_NMEA) || settingPayload[INPUT_SETTING] != COM_TYPE_UBX)
   {
-    response &= i2cGNSS.setPortOutput(COM_PORT_I2C, COM_TYPE_UBX); //Set the I2C port to output UBX only (turn off NMEA noise)
+    response &= i2cGNSS.setPortOutput(COM_PORT_I2C, COM_TYPE_UBX | COM_TYPE_NMEA); //Set the I2C port to output UBX and NMEA
     response &= i2cGNSS.setPortInput(COM_PORT_I2C, COM_TYPE_UBX); //Set the I2C port to input UBX only
   }
 
@@ -81,9 +81,8 @@ bool configureUbloxModule()
     response &= i2cGNSS.setPortInput(COM_PORT_USB, (COM_TYPE_UBX | COM_TYPE_NMEA | COM_TYPE_RTCM3)); //Set the USB port to everything
   }
 
-  response &= enableNMEASentences(COM_PORT_UART1); //Make sure the appropriate NMEA sentences are enabled
-
-  response &= enableRXMSentences(COM_PORT_I2C); //Make sure the appropriate RXM (RAXW and SFXBR) are enabled
+  response &= enableMessages(COM_PORT_UART1, settings.broadcast); //Make sure the appropriate messages are enabled
+  response &= enableMessages(COM_PORT_I2C, settings.log); //Make sure the appropriate messages are enabled
 
   response &= i2cGNSS.setAutoPVT(true, false); //Tell the GPS to "send" each solution, but do not update stale data when accessed
   response &= i2cGNSS.setAutoHPPOSLLH(true, false); //Tell the GPS to "send" each high res solution, but do not update stale data when accessed
@@ -105,15 +104,14 @@ bool configureUbloxModule()
     return (false);
   }
 
-  //Enable callbacks and logging as needed
-  if (settings.logRAWX == true)
-  {
-    i2cGNSS.logRXMRAWX(); // Enable RXM RAWX data logging
-  }
-  if (settings.logSFRBX == true)
-  {
-    i2cGNSS.logRXMSFRBX(); // Enable RXM SFRBX data logging
-  }
+  //Based on current settings, update the logging options within the GNSS library
+  i2cGNSS.logRXMRAWX(settings.log.rawx);
+  i2cGNSS.logRXMSFRBX(settings.log.sfrbx);
+
+  if (logNMEAMessages() == true)
+    i2cGNSS.setNMEALoggingMask(SFE_UBLOX_FILTER_NMEA_ALL); // Enable logging of all enabled NMEA messages
+  else
+    i2cGNSS.setNMEALoggingMask(0); // Disable logging of all enabled NMEA messages
 
   //Check rover switch and configure module accordingly
   //When switch is set to '1' = BASE, pin will be shorted to ground
@@ -143,57 +141,27 @@ bool configureUbloxModule()
   return (response);
 }
 
-//Enable the RAWX and SFRBX message based on user's settings, on a given com port
-bool enableRXMSentences(uint8_t portType)
+//Enable the NMEA/UBX messages, based on given log or broadcast settings, for a given port
+bool enableMessages(uint8_t portType, gnssMessages messageSetting)
 {
   bool response = true;
-
-  if (settings.logRAWX == true)
-  {
-    if (getRAWXSettings(portType) != 1)
-      response &= i2cGNSS.enableMessage(UBX_CLASS_RXM, UBX_RXM_RAWX, portType);
-  }
-  else if (settings.logRAWX == false)
-  {
-    if (getRAWXSettings(portType) != 0)
-      response &= i2cGNSS.disableMessage(UBX_CLASS_RXM, UBX_RXM_RAWX, portType);
-  }
-
-  if (settings.logSFRBX == true)
-  {
-    if (getSFRBXSettings(portType) != 1)
-      response &= i2cGNSS.enableMessage(UBX_CLASS_RXM, UBX_RXM_SFRBX, portType);
-  }
-  else if (settings.logSFRBX == false)
-  {
-    if (getSFRBXSettings(portType) != 0)
-      response &= i2cGNSS.disableMessage(UBX_CLASS_RXM, UBX_RXM_SFRBX, portType);
-  }
-
-  return (response);
-}
-
-//Enable the NMEA messages, based on user's settings, on a given com port
-bool enableNMEASentences(uint8_t portType)
-{
-  bool response = true;
-  if (settings.outputSentenceGGA == true)
+  if (messageSetting.gga == true)
   {
     if (getNMEASettings(UBX_NMEA_GGA, portType) != 1)
       response &= i2cGNSS.enableNMEAMessage(UBX_NMEA_GGA, portType);
   }
-  else if (settings.outputSentenceGGA == false)
+  else if (messageSetting.gga == false)
   {
     if (getNMEASettings(UBX_NMEA_GGA, portType) != 0)
       response &= i2cGNSS.disableNMEAMessage(UBX_NMEA_GGA, portType);
   }
 
-  if (settings.outputSentenceGSA == true)
+  if (messageSetting.gsa == true)
   {
     if (getNMEASettings(UBX_NMEA_GSA, portType) != 1)
       response &= i2cGNSS.enableNMEAMessage(UBX_NMEA_GSA, portType);
   }
-  else if (settings.outputSentenceGSA == false)
+  else if (messageSetting.gsa == false)
   {
     if (getNMEASettings(UBX_NMEA_GSA, portType) != 0)
       response &= i2cGNSS.disableNMEAMessage(UBX_NMEA_GSA, portType);
@@ -203,39 +171,61 @@ bool enableNMEASentences(uint8_t portType)
   //If the update rate is >1Hz then this data can overcome the BT capabilities causing timeouts and lag
   //So we set the GSV sentence to 1Hz regardless of update rate
   uint16_t measurementFrequency = (uint16_t)getMeasurementFrequency(); //Force to int
-  if (settings.outputSentenceGSV == true)
+  if (messageSetting.gsv == true)
   {
     if (getNMEASettings(UBX_NMEA_GSV, portType) != measurementFrequency)
       response &= i2cGNSS.enableNMEAMessage(UBX_NMEA_GSV, portType, measurementFrequency);
   }
-  else if (settings.outputSentenceGSV == false)
+  else if (messageSetting.gsv == false)
   {
     if (getNMEASettings(UBX_NMEA_GSV, portType) != 0)
       response &= i2cGNSS.disableNMEAMessage(UBX_NMEA_GSV, portType);
   }
 
-  if (settings.outputSentenceRMC == true)
+  if (messageSetting.rmc == true)
   {
     if (getNMEASettings(UBX_NMEA_RMC, portType) != 1)
       response &= i2cGNSS.enableNMEAMessage(UBX_NMEA_RMC, portType);
   }
-  else if (settings.outputSentenceRMC == false)
+  else if (messageSetting.rmc == false)
   {
     if (getNMEASettings(UBX_NMEA_RMC, portType) != 0)
       response &= i2cGNSS.disableNMEAMessage(UBX_NMEA_RMC, portType);
   }
 
-  if (settings.outputSentenceGST == true)
+  if (messageSetting.gst == true)
   {
     if (getNMEASettings(UBX_NMEA_GST, portType) != 1)
       response &= i2cGNSS.enableNMEAMessage(UBX_NMEA_GST, portType);
   }
-  else if (settings.outputSentenceGST == false)
+  else if (messageSetting.gst == false)
   {
     if (getNMEASettings(UBX_NMEA_GST, portType) != 0)
       response &= i2cGNSS.disableNMEAMessage(UBX_NMEA_GST, portType);
   }
 
+  if (messageSetting.rawx == true)
+  {
+    if (getRAWXSettings(portType) != 1)
+      response &= i2cGNSS.enableMessage(UBX_CLASS_RXM, UBX_RXM_RAWX, portType);
+  }
+  else if (messageSetting.rawx == false)
+  {
+    if (getRAWXSettings(portType) != 0)
+      response &= i2cGNSS.disableMessage(UBX_CLASS_RXM, UBX_RXM_RAWX, portType);
+  }
+
+  if (messageSetting.sfrbx == true)
+  {
+    if (getSFRBXSettings(portType) != 1)
+      response &= i2cGNSS.enableMessage(UBX_CLASS_RXM, UBX_RXM_SFRBX, portType);
+  }
+  else if (messageSetting.sfrbx == false)
+  {
+    if (getSFRBXSettings(portType) != 0)
+      response &= i2cGNSS.disableMessage(UBX_CLASS_RXM, UBX_RXM_SFRBX, portType);
+  }
+
   return (response);
 }
 
@@ -586,3 +576,29 @@ bool createTestFile()
 
   return (false);
 }
+
+//Returns true if any messages are enabled for logging
+bool logMessages()
+{
+  if (logNMEAMessages())
+    return (true);
+  if (logUBXMessages())
+    return (true);
+  return (false);
+}
+
+//Returns true if any of the NMEA messages are enabled for logging
+bool logNMEAMessages()
+{
+  if (settings.log.gga == true || settings.log.gsa == true || settings.log.gsv == true || settings.log.rmc == true || settings.log.gst == true)
+    return (true);
+  return (false);
+}
+
+//Returns true if any of the UBX messages are enabled for logging
+bool logUBXMessages()
+{
+  if (settings.log.rawx == true || settings.log.sfrbx == true)
+    return (true);
+  return (false);
+}

Firmware/RTK_Surveyor/begin.ino

@@ -84,6 +84,15 @@ void beginUART2()
     delay(1);
 }
 
+//ESP32 requires the creation of an EEPROM space
+void beginEEPROM()
+{
+  if (EEPROM.begin(EEPROM_SIZE) == false)
+    Serial.println(F("beginEEPROM: Failed to initialize EEPROM"));
+  else
+    online.eeprom = true;
+}
+
 void beginDisplay()
 {
   //0x3D is default on Qwiic board
@@ -149,7 +158,7 @@ void beginDisplay()
 //Connect to and configure ZED-F9P
 void beginGNSS()
 {
-  if (settings.logUBX == true)
+  if (logUBXMessages() == true)
   {
     i2cGNSS.disableUBX7Fcheck(); // RAWX data can legitimately contain 0x7F, so we need to disable the "7F" check in checkUbloxI2C
   }