Merge pull request #277 from LeeLeahy2/usb-serial

Switch USB serial output to GNSS data with system/operation menu and back to status and debug messages using +++

Author: nseidle

Firmware/RTK_Everywhere/RTK_Everywhere.ino

@@ -445,6 +445,29 @@ float batteryChargingPercentPerHour;
 #include "bluetoothSelect.h"
 #endif // COMPILE_BT
 
+// This value controls the data that is output from the USB serial port
+// to the host PC.  By default (false) status and debug messages are output
+// to the USB serial port.  When this value is set to true then the status
+// and debug messages are discarded and only GNSS data is output to USB
+// serial.
+//
+// Switching from status and debug messages to GNSS output is done in two
+// places, at the end of setup and at the end of maenuMain.  In both of
+// these places the new value comes from settings.enableGnssToUsbSerial.
+// Upon boot status and debug messages are output at least until the end
+// of setup.  Upon entry into menuMain, this value is set false to again
+// output menu output, status and debug messages to be output.  At the end
+// of setup the value is updated and if enabled GNSS data is sent to the
+// USB serial port and PC.
+volatile bool forwardGnssDataToUsbSerial;
+
+// Timeout between + characters to enter the +++ sequence while
+// forwardGnssDataToUsbSerial is true.  When sequence is properly entered
+// forwardGnssDataToUsbSerial is set to false and menuMain is displayed.
+// If the timeout between characters occurs or an invalid character is
+// entered then no changes are made and the +++ sequence must be re-entered.
+#define PLUS_PLUS_PLUS_TIMEOUT      (2 * 1000)  // Milliseconds
+
 #define platformPrefix platformPrefixTable[productVariant] // Sets the prefix for broadcast names
 
 #include <driver/uart.h>    //Required for uart_set_rx_full_threshold() on cores <v2.0.5
@@ -1113,6 +1136,10 @@ void setup()
         systemPrintf("%8d mSec: Total boot time\r\n", bootTime[bootTimeIndex]);
         systemPrintln();
     }
+
+    // If necessary, switch to sending GNSS data out the USB serial port
+    // to the PC
+    forwardGnssDataToUsbSerial = settings.enableGnssToUsbSerial;
 }
 
 void loop()

Firmware/RTK_Everywhere/Tasks.ino

@@ -56,12 +56,13 @@ enum RingBufferConsumers
     RBC_TCP_SERVER,
     RBC_SD_CARD,
     RBC_UDP_SERVER,
+    RBC_USB_SERIAL,
     // Insert new consumers here
     RBC_MAX
 };
 
 const char *const ringBufferConsumer[] = {
-    "Bluetooth", "TCP Client", "TCP Server", "SD Card", "UDP Server",
+    "Bluetooth", "TCP Client", "TCP Server", "SD Card", "UDP Server", "USB Serial",
 };
 
 const int ringBufferConsumerEntries = sizeof(ringBufferConsumer) / sizeof(ringBufferConsumer[0]);
@@ -101,6 +102,7 @@ unsigned long lastGnssSend; // Timestamp of the last time we sent RTCM to GNSS
 // Ring buffer tails
 static RING_BUFFER_OFFSET btRingBufferTail; // BT Tail advances as it is sent over BT
 static RING_BUFFER_OFFSET sdRingBufferTail; // SD Tail advances as it is recorded to SD
+static RING_BUFFER_OFFSET usbRingBufferTail; // USB Tail advances as it is sent over USB serial
 
 // Ring buffer offsets
 static uint16_t rbOffsetHead;
@@ -898,6 +900,58 @@ void handleGnssDataTask(void *e)
             }
         }
 
+        //----------------------------------------------------------------------
+        // Send data over USB serial
+        //----------------------------------------------------------------------
+
+        startMillis = millis();
+
+        // Determine USB serial connection state
+        if (!forwardGnssDataToUsbSerial)
+            // Discard the data
+            usbRingBufferTail = dataHead;
+        else
+        {
+            // Determine the amount of USB serial data in the buffer
+            bytesToSend = dataHead - usbRingBufferTail;
+            if (bytesToSend < 0)
+                bytesToSend += settings.gnssHandlerBufferSize;
+            if (bytesToSend > 0)
+            {
+                // Reduce bytes to send if we have more to send then the end of
+                // the buffer, we'll wrap next loop
+                if ((usbRingBufferTail + bytesToSend) > settings.gnssHandlerBufferSize)
+                    bytesToSend = settings.gnssHandlerBufferSize - usbRingBufferTail;
+
+                // Send data over USB serial to the PC
+                bytesToSend = systemWriteGnssDataToUsbSerial(&ringBuffer[usbRingBufferTail], bytesToSend);
+
+                // Account for the data that was sent
+                if (bytesToSend > 0)
+                {
+                    // Account for the sent or dropped data
+                    usbRingBufferTail += bytesToSend;
+                    if (usbRingBufferTail >= settings.gnssHandlerBufferSize)
+                        usbRingBufferTail -= settings.gnssHandlerBufferSize;
+
+                    // Remember the maximum transfer time
+                    deltaMillis = millis() - startMillis;
+                    if (maxMillis[RBC_USB_SERIAL] < deltaMillis)
+                        maxMillis[RBC_USB_SERIAL] = deltaMillis;
+                }
+
+                // Determine the amount of data that remains in the buffer
+                bytesToSend = dataHead - usbRingBufferTail;
+                if (bytesToSend < 0)
+                    bytesToSend += settings.gnssHandlerBufferSize;
+                if (usedSpace < bytesToSend)
+                {
+                    usedSpace = bytesToSend;
+                    slowConsumer = "USB Serial";
+                }
+            }
+        }
+
         //----------------------------------------------------------------------
         // Send data to the network clients
         //----------------------------------------------------------------------

Firmware/RTK_Everywhere/menuMain.ino

@@ -11,6 +11,7 @@ void terminalUpdate()
         periodicDisplay = settings.periodicDisplay;
     }
 
+    // Check for USB serial input
     if (systemAvailable())
     {
         byte incoming = systemRead();
@@ -21,13 +22,49 @@ void terminalUpdate()
             printCurrentConditionsNMEA();
         }
         else
+        {
+            // When outputting GNSS data to USB serial, check for +++
+            if (forwardGnssDataToUsbSerial)
+            {
+                static uint32_t plusTimeout;
+                static uint8_t plusCount;
+
+                // Reset plusCount on timeout
+                if ((millis() - plusTimeout) > PLUS_PLUS_PLUS_TIMEOUT)
+                    plusCount = 0;
+
+                // Check for + input
+                if (incoming != '+')
+                {
+                    // Must start over looking for +++
+                    plusCount = 0;
+                    return;
+                }
+                else
+                {
+                    // + entered, check for the +++ sequence
+                    plusCount++;
+                    if (plusCount < 3)
+                    {
+                        // Restart the timeout
+                        plusTimeout = millis();
+                        return;
+                    }
+
+                    // +++ was entered, display the main menu
+                }
+            }
             menuMain(); // Present user menu
+        }
     }
 }
 
 // Display the main menu configuration options
 void menuMain()
 {
+    // Redirect menu output, status and debug messages to the USB serial port
+    forwardGnssDataToUsbSerial = false;
+
     inMainMenu = true;
     displaySerialConfig(); // Display 'Serial Config' while user is configuring
 
@@ -259,6 +296,9 @@ void menuMain()
     clearBuffer();           // Empty buffer of any newline chars
     btPrintEchoExit = false; // We are out of the menu system
     inMainMenu = false;
+
+    // Change the USB serial output behavior if necessary
+    forwardGnssDataToUsbSerial = settings.enableGnssToUsbSerial;
 }
 
 // Change system wide settings based on current user profile

Firmware/RTK_Everywhere/menuSystem.ino

@@ -156,6 +156,13 @@ void menuSystem()
         systemPrintf("Filtered by parser: %d NMEA / %d RTCM / %d UBX\r\n", failedParserMessages_NMEA,
                      failedParserMessages_RTCM, failedParserMessages_UBX);
 
+        // Display the USB serial output status
+        menuSystemDisplayUsbSerialOutput(settings.enableGnssToUsbSerial);
+
+        //---------------------------
+        // Start of menu
+        //---------------------------
+
         systemPrintln();
         systemPrintln("Menu: System");
         // Separate the menu from the status
@@ -211,7 +218,7 @@ void menuSystem()
 
         systemPrintln("n) Debug network");
 
-        systemPrintln("o) Configure RTK operation");
+        systemPrintln("o) Configure operation");
 
         systemPrintln("p) Configure periodic print messages");
 
@@ -429,7 +436,7 @@ void menuDebugHardware()
         systemPrintf("%s\r\n", settings.enableImuCompensationDebug ? "Enabled" : "Disabled");
 
         if (present.gnss_um980)
-            systemPrintln("13) UM980 Direct connect");
+            systemPrintln("13) UM980 direct connect");
 
         systemPrint("14) PSRAM (");
         if (ESP.getPsramSize() == 0)
@@ -939,7 +946,11 @@ void menuOperation()
         systemPrintln(settings.uartReceiveBufferSize);
 
         // ZED
-        systemPrintln("10) Mirror ZED-F9x's UART1 settings to USB");
+        if(present.gnss_zedf9p)
+            systemPrintln("10) Mirror ZED-F9x's UART1 settings to USB");
+
+        // USB Serial
+        systemPrintln("11) Output GNSS data to USB serial");
 
         systemPrintln("----  Interrupts  ----");
         systemPrint("30) Bluetooth Interrupts Core: ");
@@ -1032,7 +1043,7 @@ void menuOperation()
                 ESP.restart();
             }
         }
-        else if (incoming == 10)
+        else if (incoming == 10 && present.gnss_zedf9p)
         {
             bool response = gnssSetMessagesUsb(MAX_SET_MESSAGES_RETRIES);
 
@@ -1042,6 +1053,12 @@ void menuOperation()
                 systemPrintln(F("USB messages successfully enabled"));
         }
 
+        else if (incoming == 11)
+        {
+            settings.enableGnssToUsbSerial ^= 1;
+            menuSystemDisplayUsbSerialOutput(settings.enableGnssToUsbSerial);
+        }
+
         else if (incoming == 30)
         {
             getNewSetting("Not yet implemented! - Enter Core used for Bluetooth Interrupts", 0, 1,
@@ -1094,6 +1111,15 @@ void menuOperation()
     clearBuffer(); // Empty buffer of any newline chars
 }
 
+// Display the USB serial output
+void menuSystemDisplayUsbSerialOutput(bool gnssData)
+{
+    if (gnssData)
+        systemPrintln("USB Serial output is GNSS data");
+    else
+        systemPrintln("USB Serial output is status and debug messages");
+}
+
 // Toggle periodic print message enables
 void menuPeriodicPrint()
 {

Firmware/RTK_Everywhere/settings.h

@@ -976,7 +976,7 @@ typedef struct
     const uint32_t frequency; // L-Band frequency, Hz, if supported. 0 if not supported
 } Regional_Information;
 
-const Regional_Information Regional_Information_Table[] = 
+const Regional_Information Regional_Information_Table[] =
 {
     { "US", "us", { 50.0,  25.0, -60.0, -125.0}, 1556290000 },
     { "EU", "eu", { 72.0,  36.0,  32.0,  -11.0}, 1545260000 },
@@ -1324,6 +1324,8 @@ struct Settings
     uint8_t wifiChannel = 1; //Valid channels are 1 to 14
     bool enableGalileoHas = true; // Allow E6 corrections if possible
 
+    bool enableGnssToUsbSerial = false;
+
     // Add new settings above <------------------------------------------------------------>
     // Then also add to rtkSettingsEntries below
 
@@ -1627,6 +1629,8 @@ const RTK_Settings_Entry rtkSettingsEntries[] = {
     { & settings.wifiChannel, "wifiChannel", _uint8_t, 0, false, true, true },
     { & settings.enableGalileoHas, "enableGalileoHas", _bool, 0, false, true, true },
 
+    { & settings.enableGnssToUsbSerial, "enableGnssToUsbSerial", _bool, 0, false, true, true },
+
     // Add new settings above <------------------------------------------------------------>
     /*
     { & settings., "", , 0, false, true },

Firmware/RTK_Everywhere/support.ino

@@ -19,17 +19,28 @@ int systemRead()
 // Output a buffer of the specified length to the serial port
 void systemWrite(const uint8_t *buffer, uint16_t length)
 {
-    if (printEndpoint == PRINT_ENDPOINT_ALL)
-    {
-        Serial.write(buffer, length);
-        bluetoothWrite(buffer, length);
-    }
-    else if (printEndpoint == PRINT_ENDPOINT_BLUETOOTH)
+    // Output data to bluetooth if necessary
+    if ((printEndpoint == PRINT_ENDPOINT_ALL)
+        || (printEndpoint == PRINT_ENDPOINT_BLUETOOTH))
         bluetoothWrite(buffer, length);
-    else
+
+    // Output data to USB serial if necessary
+    if ((printEndpoint != PRINT_ENDPOINT_BLUETOOTH)
+        && (!forwardGnssDataToUsbSerial))
         Serial.write(buffer, length);
 }
 
+// Forward GNSS data to the USB serial port
+size_t systemWriteGnssDataToUsbSerial(const uint8_t *buffer, uint16_t length)
+{
+    // Determine if status and debug messages are being output to USB serial
+    if (!forwardGnssDataToUsbSerial)
+        return length;
+
+    // Output GNSS data to USB serial
+    return Serial.write(buffer, length);
+}
+
 // Ensure all serial output has been transmitted, FIFOs are empty
 void systemFlush()
 {