Prelim NTRIP server support. Reduced serial buffers. Reduced task stack size.

Serial buffers were 16384, task stack size was 10,000. Reduced to 4096 and 1k to make room for WiFi/NTRIP capabilities.

Author: Nathan Seidle

Firmware/RTK_Surveyor/Base.ino

@@ -43,7 +43,6 @@ bool updateSurveyInStatus()
     } //baseState = Surveying In Not started
     else
     {
-
       bool response = myGPS.getSurveyStatus(2000); //Query module for SVIN status with 2000ms timeout (req can take a long time)
       if (response == true)
       {
@@ -135,65 +134,53 @@ bool configureUbloxModuleBase()
   digitalWrite(positionAccuracyLED_10cm, LOW);
   digitalWrite(positionAccuracyLED_100cm, LOW);
 
+  //In base mode we force 1Hz
+  if (myGPS.getNavigationFrequency() != 1)
+  {
+    response &= myGPS.setNavigationFrequency(1); //Set output in Hz
+  }
+
   // Set dynamic model
   if (myGPS.getDynamicModel() != DYN_MODEL_STATIONARY)
   {
-    if (myGPS.setDynamicModel(DYN_MODEL_STATIONARY) == false)
-    {
+    response &= myGPS.setDynamicModel(DYN_MODEL_STATIONARY);
+    if (response == false)
       Serial.println(F("setDynamicModel failed!"));
-      return (false);
-    }
   }
 
-  //In base mode the Surveyor should output RTCM over UART1, UART2, and USB ports:
+  //In base mode the Surveyor should output RTCM over UART2 and I2C ports:
   //(Primary) UART2 in case the Surveyor is connected via radio to rover
+  //(Optional) I2C in case user wants base to connect to WiFi and NTRIP Serve to Caster
   //(Seconday) USB in case the Surveyor is used as an NTRIP caster
   //(Tertiary) UART1 in case Surveyor is sending RTCM to phone that is then NTRIP caster
-  if (getRTCMSettings(UBX_RTCM_1005, COM_PORT_UART2) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1005, COM_PORT_UART2, 1); //Enable message 1005 to output through UART2, message every second
-  if (getRTCMSettings(UBX_RTCM_1074, COM_PORT_UART2) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1074, COM_PORT_UART2, 1);
-  if (getRTCMSettings(UBX_RTCM_1084, COM_PORT_UART2) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1084, COM_PORT_UART2, 1);
-  if (getRTCMSettings(UBX_RTCM_1094, COM_PORT_UART2) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1094, COM_PORT_UART2, 1);
-  if (getRTCMSettings(UBX_RTCM_1124, COM_PORT_UART2) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1124, COM_PORT_UART2, 1);
-  if (getRTCMSettings(UBX_RTCM_1230, COM_PORT_UART2) != 10)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1230, COM_PORT_UART2, 10); //Enable message every 10 seconds
-
-  if (getRTCMSettings(UBX_RTCM_1005, COM_PORT_UART1) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1005, COM_PORT_UART1, 1); //Enable message 1005 to output through UART2, message every second
-  if (getRTCMSettings(UBX_RTCM_1074, COM_PORT_UART1) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1074, COM_PORT_UART1, 1);
-  if (getRTCMSettings(UBX_RTCM_1084, COM_PORT_UART1) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1084, COM_PORT_UART1, 1);
-  if (getRTCMSettings(UBX_RTCM_1094, COM_PORT_UART1) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1094, COM_PORT_UART1, 1);
-  if (getRTCMSettings(UBX_RTCM_1124, COM_PORT_UART1) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1124, COM_PORT_UART1, 1);
-  if (getRTCMSettings(UBX_RTCM_1230, COM_PORT_UART1) != 10)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1230, COM_PORT_UART1, 10); //Enable message every 10 seconds
-
-  if (getRTCMSettings(UBX_RTCM_1005, COM_PORT_USB) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1005, COM_PORT_USB, 1); //Enable message 1005 to output through UART2, message every second
-  if (getRTCMSettings(UBX_RTCM_1074, COM_PORT_USB) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1074, COM_PORT_USB, 1);
-  if (getRTCMSettings(UBX_RTCM_1084, COM_PORT_USB) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1084, COM_PORT_USB, 1);
-  if (getRTCMSettings(UBX_RTCM_1094, COM_PORT_USB) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1094, COM_PORT_USB, 1);
-  if (getRTCMSettings(UBX_RTCM_1124, COM_PORT_USB) != 1)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1124, COM_PORT_USB, 1);
-  if (getRTCMSettings(UBX_RTCM_1230, COM_PORT_USB) != 10)
-    response &= myGPS.enableRTCMmessage(UBX_RTCM_1230, COM_PORT_USB, 10); //Enable message every 10 seconds
+  response &= enableRTCMSentences(COM_PORT_UART2);
+  response &= enableRTCMSentences(COM_PORT_UART1);
+  response &= enableRTCMSentences(COM_PORT_USB);
 
-  if (response == false)
+  if (settings.enableNtripServer == true)
   {
-    Serial.println(F("RTCM failed to enable."));
-    return (false);
+    //Turn on RTCM over I2C port so that we can harvest RTCM over I2C and send out over WiFi
+    //This is easier than parsing over UART because the library handles the frame detection
+
+#define OUTPUT_SETTING 14
+#define INPUT_SETTING 12
+    getPortSettings(COM_PORT_I2C); //Load the settingPayload with this port's settings
+    if (settingPayload[OUTPUT_SETTING] != COM_TYPE_UBX | COM_TYPE_NMEA | COM_TYPE_RTCM3 || settingPayload[INPUT_SETTING] != COM_TYPE_UBX)
+    {
+      response &= myGPS.setPortOutput(COM_PORT_I2C, COM_TYPE_UBX | COM_TYPE_NMEA | COM_TYPE_RTCM3); //UBX+RTCM3 is not a valid option so we enable all three.
+      response &= myGPS.setPortInput(COM_PORT_I2C, COM_TYPE_UBX); //Set the I2C port to input UBX only
+    }
+
+    //Disable any NMEA sentences
+    response &= disableNMEASentences(COM_PORT_I2C);
+
+    //Enable necessary RTCM sentences
+    response &= enableRTCMSentences(COM_PORT_I2C);
   }
 
+  if (response == false)
+    Serial.println(F("RTCM settings failed to enable"));
+
   return (response);
 }
 
@@ -266,17 +253,17 @@ bool startFixedBase()
     int32_t majorAlt = settings.fixedAltitude * 100;
     int32_t minorAlt = ((settings.fixedAltitude * 100) - majorAlt) * 100;
 
-    Serial.printf("fixedLat (should be -105.184774720): %0.09f\n", settings.fixedLat);
-    Serial.printf("major (should be -1051847747): %lld\n", majorLat);
-    Serial.printf("minor (should be -20): %lld\n", minorLat);
-
-    Serial.printf("fixedLong (should be 40.090335429): %0.09f\n", settings.fixedLong);
-    Serial.printf("major (should be 400903354): %lld\n", majorLong);
-    Serial.printf("minor (should be 29): %lld\n", minorLong);
-
-    Serial.printf("fixedAlt (should be 1560.2284): %0.04f\n", settings.fixedAltitude);
-    Serial.printf("major (should be 156022): %ld\n", majorAlt);
-    Serial.printf("minor (should be 84): %ld\n", minorAlt);
+//    Serial.printf("fixedLat (should be -105.184774720): %0.09f\n", settings.fixedLat);
+//    Serial.printf("major (should be -1051847747): %lld\n", majorLat);
+//    Serial.printf("minor (should be -20): %lld\n", minorLat);
+//
+//    Serial.printf("fixedLong (should be 40.090335429): %0.09f\n", settings.fixedLong);
+//    Serial.printf("major (should be 400903354): %lld\n", majorLong);
+//    Serial.printf("minor (should be 29): %lld\n", minorLong);
+//
+//    Serial.printf("fixedAlt (should be 1560.2284): %0.04f\n", settings.fixedAltitude);
+//    Serial.printf("major (should be 156022): %ld\n", majorAlt);
+//    Serial.printf("minor (should be 84): %ld\n", minorAlt);
 
     response = myGPS.setStaticPosition(
                  majorLong, minorLong,
@@ -293,6 +280,133 @@ bool startFixedBase()
   return (response);
 }
 
+//Call regularly to get data from u-blox module and send out over local WiFi
+//We make sure we are connected to WiFi, then
+bool updateNtripServer()
+{
+  //Is WiFi setup?
+  if (WiFi.isConnected() == false)
+  {
+    //Turn off Bluetooth and turn on WiFi
+    endBluetooth();
+
+    Serial.printf("Connecting to local WiFi: %s\n", settings.wifiSSID);
+    WiFi.begin(settings.wifiSSID, settings.wifiPW);
+
+    //while(1) delay(10);
+
+    int maxTime = 10000;
+    long startTime = millis();
+    while (WiFi.status() != WL_CONNECTED) {
+      delay(500);
+      Serial.print(F("."));
+
+      if (millis() - startTime > maxTime)
+      {
+        Serial.println(F("Failed to connect to WiFi. Are you sure your WiFi credentials are correct?"));
+        return (false);
+      }
+    }
+    delay(10);
+
+  } //End WiFi connect check
+
+  //Are we connected to caster?
+  if (caster.connected() == false)
+  {
+    Serial.printf("Opening socket to %s\n", settings.casterHost);
+
+    if (caster.connect(settings.casterHost, settings.casterPort) == true) //Attempt connection
+    {
+      Serial.printf("Connected to %s:%d\n", settings.casterHost, settings.casterPort);
+
+      const int SERVER_BUFFER_SIZE  = 512;
+      char serverBuffer[SERVER_BUFFER_SIZE];
+
+      snprintf(serverBuffer, SERVER_BUFFER_SIZE, "SOURCE %s /%s\r\nSource-Agent: NTRIP %s/%s\r\n\r\n",
+               settings.mountPointPW, settings.mountPoint, ntrip_server_name, "App Version 1.0");
+
+      Serial.printf("Sending credentials:\n%s\n", serverBuffer);
+      caster.write(serverBuffer, strlen(serverBuffer));
+
+      //Wait for response
+      unsigned long timeout = millis();
+      while (caster.available() == 0)
+      {
+        if (millis() - timeout > 5000)
+        {
+          Serial.println(F("Caster failed to respond. Do you have your caster address and port correct?"));
+          caster.stop();
+          delay(10);
+          return (false);
+        }
+        delay(10);
+      }
+
+      delay(10); //Yield to RTOS
+
+      //Check reply
+      bool connectionSuccess = false;
+      char response[512];
+      int responseSpot = 0;
+      while (caster.available())
+      {
+        response[responseSpot++] = caster.read();
+        if (strstr(response, "200") > 0) //Look for 'ICY 200 OK'
+          connectionSuccess = true;
+        if (responseSpot == 512 - 1) break;
+      }
+      response[responseSpot] = '\0';
+      Serial.printf("Caster responded with: %s\n", response);
+
+      if (connectionSuccess == false)
+      {
+        Serial.printf("Caster responded with bad news: %s. Are you sure your caster credentials are correct?", response);
+      }
+      else
+      {
+        //We're connected!
+        Serial.println(F("Connected to caster"));
+
+        //Reset flags
+        lastServerReport_ms = millis();
+        lastServerSent_ms = millis();
+        serverBytesSent = 0;
+      }
+    } //End attempt to connect
+    else
+    {
+      Serial.println(F("Failed to connect to caster"));
+      delay(10); //Give RTOS some time
+      return (false);
+    }
+  } //End connected == false
+
+
+  //Poll module for any new I2C data including RTCM
+  //These bytes will automatically be parsed by processRTCM() function
+  myGPS.checkUblox();
+
+  //Close socket if we don't have new data for 10s
+  //RTK2Go will ban your IP address if you abuse it. See http://www.rtk2go.com/how-to-get-your-ip-banned/
+  //So let's not leave the socket open/hanging without data
+  if (millis() - lastServerSent_ms > maxTimeBeforeHangup_ms)
+  {
+    Serial.println(F("RTCM timeout. Disconnecting from caster."));
+    caster.stop();
+    return (false);
+  }
+
+  //Report some statistics every 250
+  if (millis() - lastServerReport_ms > 250)
+  {
+    lastServerReport_ms += 250;
+    Serial.printf("Total bytes sent to caster: %d\n", serverBytesSent);
+  }
+
+  return (true);
+}
+
 //This function gets called from the SparkFun u-blox Arduino Library.
 //As each RTCM byte comes in you can specify what to do with it
 //Useful for passing the RTCM correction data to a radio, Ntrip broadcaster, etc.
@@ -302,6 +416,6 @@ void SFE_UBLOX_GPS::processRTCM(uint8_t incoming)
   {
     caster.write(incoming); //Send this byte to socket
     serverBytesSent++;
-    lastSentRTCM_ms = millis();
+    lastServerSent_ms = millis();
   }
 }

Firmware/RTK_Surveyor/RTK_Surveyor.ino

@@ -29,7 +29,6 @@
     (Done) Ports - Configure Radio and Data port baud rates
     (Done) Test menu
     Enable various debug outputs sent over BT
-
 */
 
 const int FIRMWARE_VERSION_MAJOR = 1;
@@ -87,7 +86,8 @@ long startLogTime_minutes = 0; //Mark when we start logging so we can stop loggi
 WiFiClient caster;
 const char * ntrip_server_name = "SparkFun_RTK_Surveyor";
 
-long lastSentRTCM_ms = 0; //Time of last data pushed to socket
+unsigned long lastServerSent_ms = 0; //Time of last data pushed to caster
+unsigned long lastServerReport_ms = 0; //Time of last report of caster bytes sent
 int maxTimeBeforeHangup_ms = 10000; //If we fail to get a complete RTCM frame after 10s, then disconnect from caster
 
 uint32_t serverBytesSent = 0; //Just a running total
@@ -125,6 +125,10 @@ SFE_UBLOX_GPS_ADD myGPS;
 //u-blox firmware to work correctly. We check the module firmware at startup but
 //don't prevent operation if firmware is mismatched.
 char latestZEDFirmware[] = "FWVER=HPG 1.13";
+
+//Used for config ZED for things not supported in library: getPortSettings, getSerialRate, getNMEASettings, getRTCMSettings 
+//This array holds the payload data bytes. Global so that we can use between config functions.
+uint8_t settingPayload[MAX_PAYLOAD_SIZE]; 
 //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 //Battery fuel gauge and PWM LEDs
@@ -143,14 +147,17 @@ const int resolution = 8;
 //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 #include "BluetoothSerial.h"
 BluetoothSerial SerialBT;
+#include "esp_bt.h" //Core access is needed for BT stop. See customBTstop() for more info.
 
 HardwareSerial GPS(2);
 #define RXD2 16
 #define TXD2 17
 
-#define SERIAL_SIZE_RX 16384 //Using a large buffer. This might be much bigger than needed but the ESP32 has enough RAM
+#define SERIAL_SIZE_RX 4096 //Reduced from 16384 to make room for WiFi/NTRIP server capabilities
 uint8_t rBuffer[SERIAL_SIZE_RX]; //Buffer for reading F9P
 uint8_t wBuffer[SERIAL_SIZE_RX]; //Buffer for writing to F9P
+TaskHandle_t F9PSerialReadTaskHandle = NULL; //Store handles so that we can kill them if user goes into WiFi NTRIP Server mode
+TaskHandle_t F9PSerialWriteTaskHandle = NULL; //Store handles so that we can kill them if user goes into WiFi NTRIP Server mode
 //=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 //External Display
@@ -280,6 +287,13 @@ void loop()
   {
     updateSurveyInStatus();
   }
+  else if (baseState == BASE_TRANSMITTING)
+  {
+    if(settings.enableNtripServer == true)
+    {
+      updateNtripServer();
+    }
+  }
   else if (baseState == BASE_OFF)
   {
     updateRoverStatus();