1.2.46

[Meshtastic DIY v1]

.github/workflows/main.yml

@@ -58,6 +58,19 @@ jobs:
       run: |
         pio upgrade
 
+    - name: Pull web ui
+      uses: dsaltares/fetch-gh-release-asset@master
+      with:
+        repo: "meshtastic/meshtastic-web"
+        file: "build.tar"
+        target: "build.tar"
+        token: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Unpack web ui
+      run: |
+        tar -xf build.tar -C data/static
+        rm build.tar
+
     # We now run integration test before other build steps (to quickly see runtime failures)
     - name: Build for native
       run: platformio run -e native

.github/workflows/release.yml

@@ -47,6 +47,19 @@ jobs:
       run: |
         pio upgrade
 
+    - name: Pull web ui
+      uses: dsaltares/fetch-gh-release-asset@master
+      with:
+        repo: "meshtastic/meshtastic-web"
+        file: "build.tar"
+        target: "build.tar"
+        token: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Unpack web ui
+      run: |
+        tar -xf build.tar -C data/static
+        rm build.tar
+
     # Will be available in steps.version.outputs.version
     - name: Get version string
       run: echo "::set-output name=version::$(./bin/buildinfo.py long)"

bin/build-all.sh

@@ -72,6 +72,9 @@ platformio lib update
 do_boards "$BOARDS_ESP32" "false"
 do_boards "$BOARDS_NRF52" "true"
 
+pio run --environment native
+cp .pio/build/native/program $OUTDIR/bins/universal/meshtasticd_linux_amd64
+
 echo "Building SPIFFS for ESP32 targets"
 pio run --environment tbeam -t buildfs
 cp .pio/build/tbeam/spiffs.bin $OUTDIR/bins/universal/spiffs-$VERSION.bin
@@ -99,7 +102,7 @@ XML
 
 echo Generating $ARCHIVEDIR/firmware-$VERSION.zip
 rm -f $ARCHIVEDIR/firmware-$VERSION.zip
-zip --junk-paths $ARCHIVEDIR/firmware-$VERSION.zip $ARCHIVEDIR/spiffs-$VERSION.bin $OUTDIR/bins/universal/firmware-*-$VERSION.* images/system-info.bin bin/device-install.* bin/device-update.*
+zip --junk-paths $ARCHIVEDIR/firmware-$VERSION.zip $ARCHIVEDIR/spiffs-$VERSION.bin $OUTDIR/bins/universal/firmware-*-$VERSION.* $OUTDIR/bins/universal/meshtasticd* images/system-info.bin bin/device-install.* bin/device-update.*
 echo Generating $ARCHIVEDIR/elfs-$VERSION.zip
 rm -f $ARCHIVEDIR/elfs-$VERSION.zip
 zip --junk-paths $ARCHIVEDIR/elfs-$VERSION.zip $OUTDIR/elfs/universal/firmware-*-$VERSION.* 

boards/nrf52840_dk_modified.json

@@ -16,9 +16,9 @@
       "name": "adafruit"
     },
     "softdevice": {
-      "sd_flags": "-DS113",
-      "sd_name": "s113",
-      "sd_version": "7.2.0",
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
       "sd_fwid": "0x00B6"
     },
     "bootloader": {

data/static/index.html

@@ -1 +0,0 @@
-not yet supported - soon will be included in build

geeksville-private/TODO.md

@@ -2,20 +2,19 @@
 
 You probably don't care about this section - skip to the next one.
 
-* list portduino on platformio
-* router mode dropping messages? https://meshtastic.discourse.group/t/router-mode-missing-messages/3329/3
-* fix ttgo eink screen
-* figure our wss for mqtt.meshtastic - use cloudflare? 2052 ws, 2053 crypt
+* usb lora dongle from pine64, add end user instructions
 * measure rak4630 power draw and turn off power for GPS most of the time.  We should be able to run on the small solar panel.
-* pine64 lora module
-* @havealoha fixedposition not working
+* turn on watchdog reset if app hangs on nrf52 or esp32
+* pine64 solar boards
+* for the matrix gateway?  recommended by @sam-uk https://github.com/matrix-org/coap-proxy
+* figure our wss for mqtt.meshtastic - use cloudflare? 2052 ws, 2053 crypt
 * ask for vercel access
 * finish plan for riot.im
 * turn on setTx(timeout) and   state = setDioIrqParams(SX126X_IRQ_TX_DONE | SX126X_IRQ_TIMEOUT, SX126X_IRQ_TX_DONE | SX126X_IRQ_TIMEOUT); in sx1262 code
-* add rak4600 support (with rf95 radio and limited ram)
+* NO add rak4600 support (with rf95 radio and limited ram)
 * store esp32 crashes to flash (and 64KB coredump partition) - https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-guides/core_dump.html
-* 
-* Switch to use https://github.com/adafruit/Adafruit_nRF52_Arduino.git when available (see arduino code for examples)
+* If more nodes appear than the nodedb can hold, delete oldest entries from DB
+* send debug info 'in-band'
 * DONE @luxonn reports that after a while the android app stops showing new messages
 * DONE release android APK - fix recent 1.2.28 crash report
 * DONE remote admin busted? 
@@ -28,7 +27,6 @@ You probably don't care about this section - skip to the next one.
 * DONE tcp stream problem in python+pordtuino, server thinks client dropped when client DID NOT DROP
 * DONE TCP mode for android, localhost is at 10.0.2.2
 * DONE make sure USB still works in android
-* add portduino builds to zip
 * add license to portduino and make announcement
 * DONE naks are being dropped (though enqueuedLocal) sometimes before phone/PC gets them
 * DONE have android fill in if local GPS has poor signal

geeksville-private/bl602.md

@@ -0,0 +1,25 @@
+
+* nutcracker https://www.pine64.org/2020/10/28/nutcracker-challenge-blob-free-wifi-ble/
+* https://github.com/pine64/bl_iot_sdk
+* https://github.com/pine64/bl602-docs / https://pine64.github.io/bl602-docs/
+* https://github.com/pine64/ArduinoCore-bouffalo 
+
+
+cd ~/packages
+git clone --recursive https://github.com/pine64/bl_iot_sdk
+
+https://github.com/spacemeowx2/blflash/releases
+
+
+# FIXME or BL604
+cd bl_iot_sdk
+export BL60X_SDK_PATH=/home/kevinh/packages/bl_iot_sdk
+export CONFIG_CHIP_NAME=BL602
+cd customer_app/bl602_boot2
+make
+
+* todo run hello world on hardware (check for bl604 vs bl602 first)
+* build/run in the crummy arduino environment
+* build in platformio
+
+https://lupyuen.github.io/articles/lorawan2

platformio.ini

@@ -9,7 +9,7 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-default_envs = tbeam
+;default_envs = tbeam
 ;default_envs = tbeam0.7
 ;default_envs = heltec-v2.0
 ;default_envs = tlora-v1
@@ -21,6 +21,7 @@ default_envs = tbeam
 ;default_envs = native # lora-relay-v1 # nrf52840dk-geeksville # linux # or if you'd like to change the default to something like lora-relay-v1 put that here
 ;default_envs = rak4631
 ;default_envs = rak4630
+default_envs = meshtastic-diy-v1
 
 [common]
 ; common is not currently used
@@ -70,9 +71,9 @@ lib_deps =
   https://github.com/meshtastic/esp8266-oled-ssd1306.git#35d796226b853b0c0ff818b2f1aa3d35e7296a96 ; ESP8266_SSD1306 
   https://github.com/geeksville/OneButton.git ; OneButton library for non-blocking button debounce
   1202 ; CRC32, explicitly needed because dependency is missing in the ble ota update lib
-  https://github.com/meshtastic/arduino-fsm.git#829e967b8a95c094f73c60ef8dacfe66eae38940
+  https://github.com/meshtastic/arduino-fsm.git
   https://github.com/meshtastic/SparkFun_Ublox_Arduino_Library.git#31015a55e630a2df77d9d714669c621a5bf355ad
-  https://github.com/meshtastic/RadioLib.git#80ed10d689a0568782c5bd152906b0f97d2bce93
+  https://github.com/meshtastic/RadioLib.git#5582ac30578ff3f53f20630a00b2a8a4b8f92c74
   https://github.com/meshtastic/TinyGPSPlus.git#f0f47067ef2f67c856475933188251c1ef615e79
   https://github.com/meshtastic/AXP202X_Library.git#8404abb6d4b486748636bc6ad72d2a47baaf5460
   Wire ; explicitly needed here because the AXP202 library forgets to add it
@@ -190,6 +191,15 @@ board = ttgo-lora32-v1
 build_flags = 
   ${esp32_base.build_flags} -D TLORA_V2_1_16
 
+; Meshtastic DIY v1 by Nano VHF Schematic based on ESP32-WROOM-32 (38 pins) devkit & EBYTE E22 SX1262/SX1268 module
+[env:meshtastic-diy-v1]
+extends = esp32_base
+board = esp32doit-devkit-v1
+build_flags =
+  ${esp32_base.build_flags}
+  -D DIY_V1
+  -D EBYTE_E22
+
 ; The Heltec Cubecell plus 
 ; IMPORTANT NOTE: This target doesn't yet work and probably won't ever work.  I'm keeping it around for now.
 ; For more details see my post in the forum.
@@ -218,7 +228,7 @@ src_filter =
   ${arduino_base.src_filter} -<esp32/> -<nimble/> -<mesh/wifi/> -<mesh/http/> -<plugins/esp32> -<mqtt/>
 lib_ignore =
   BluetoothOTA
-monitor_port = /dev/ttyACM1
+; monitor_port = /dev/ttyACM1
 
 # we pass in options to jlink so it can understand freertos (note: we don't use "jlink" as the tool)
 ;debug_tool = jlink
@@ -255,9 +265,12 @@ debug_init_break =
 [nrf52840_base]
 ; Common base class for all nrf52840 based targets
 extends = nrf52_base
+; was -DTINY_USB
+build_flags = ${nrf52_base.build_flags} 
 lib_deps =
   ${arduino_base.lib_deps}
   Adafruit nRFCrypto 
+  # Adafruit TinyUSB Arduino
   # add Adafruit nRFCrypto platform IO automated scan is broken
 
 [env:lora_isp4520]
@@ -315,7 +328,7 @@ extends = nrf52840_base
 board = wiscore_rak4631
 # add our variants files to the include and src paths
 # define build flags for the TFT_eSPI library
-build_flags = ${nrf52_base.build_flags} -Ivariants/WisCore_RAK4631_Board
+build_flags = ${nrf52840_base.build_flags} -Ivariants/WisCore_RAK4631_Board
 src_filter = ${nrf52_base.src_filter} +<../variants/WisCore_RAK4631_Board>
 debug_tool = jlink
 ; If not set we will default to uploading over serial (first it forces bootloader entry by talking 1200bps to cdcacm)
@@ -354,10 +367,13 @@ lib_deps =
 [env:t-echo]
 extends = nrf52840_base
 board = t-echo
+debug_tool = jlink
+upload_protocol = jlink
 # add our variants files to the include and src paths
 # define build flags for the TFT_eSPI library - NOTE: WE NOT LONGER USE TFT_eSPI, it was for an earlier version of the TTGO eink screens
 # -DBUSY_PIN=3 -DRST_PIN=2 -DDC_PIN=28 -DCS_PIN=30
-build_flags = ${nrf52_base.build_flags} -Ivariants/t-echo 
+# add -DCFG_SYSVIEW if you want to use the Segger systemview tool for OS profiling.
+build_flags = ${nrf52840_base.build_flags} -Ivariants/t-echo 
 src_filter = ${nrf52_base.src_filter} +<../variants/t-echo>
 lib_deps = 
   ${nrf52840_base.lib_deps}
@@ -385,7 +401,7 @@ extends = nrf52840_base
 board = lora-relay-v1
 # add our variants files to the include and src paths
 # define build flags for the TFT_eSPI library
-build_flags = ${nrf52_base.build_flags} -Ivariants/lora_relay_v1
+build_flags = ${nrf52840_base.build_flags} -Ivariants/lora_relay_v1
   -DUSER_SETUP_LOADED
   -DTFT_WIDTH=80
   -DTFT_HEIGHT=160
@@ -407,7 +423,7 @@ extends = nrf52840_base
 board = lora-relay-v2
 # add our variants files to the include and src paths
 # define build flags for the TFT_eSPI library
-build_flags = ${nrf52_base.build_flags} -Ivariants/lora_relay_v2
+build_flags = ${nrf52840_base.build_flags} -Ivariants/lora_relay_v2
   -DUSER_SETUP_LOADED
   -DTFT_WIDTH=80
   -DTFT_HEIGHT=160

src/GPSStatus.h

@@ -1,8 +1,11 @@
 #pragma once
 #include "Status.h"
 #include "configuration.h"
+#include "NodeDB.h"
 #include <Arduino.h>
 
+extern NodeDB nodeDB;
+
 namespace meshtastic
 {
 
@@ -47,11 +50,36 @@ class GPSStatus : public Status
 
     bool getIsConnected() const { return isConnected; }
 
-    int32_t getLatitude() const { return latitude; }
+    int32_t getLatitude() const {
+        if (radioConfig.preferences.fixed_position){
+            DEBUG_MSG("WARNING: Using fixed latitude\n");
+            NodeInfo *node = nodeDB.getNode(nodeDB.getNodeNum());
+            return node->position.latitude_i;
+        } else {
+            return latitude;
+        }
+    }
 
-    int32_t getLongitude() const { return longitude; }
+    int32_t getLongitude() const {
+        if (radioConfig.preferences.fixed_position){
+            DEBUG_MSG("WARNING: Using fixed longitude\n");
+            NodeInfo *node = nodeDB.getNode(nodeDB.getNodeNum());
+            return node->position.longitude_i;
+        } else {
+            return longitude;
+        }
+    }
+
+    int32_t getAltitude() const {
+        if (radioConfig.preferences.fixed_position){
+            DEBUG_MSG("WARNING: Using fixed altitude\n");
+            NodeInfo *node = nodeDB.getNode(nodeDB.getNodeNum());
+            return node->position.altitude;
+        } else {
+            return altitude;
+        }
+    }
 
-    int32_t getAltitude() const { return altitude; }
 
     uint32_t getDOP() const { return dop; }
 

src/Power.cpp

@@ -82,10 +82,13 @@ class AnalogBatteryLevel : public HasBatteryLevel
         if (v < noBatVolt)
             return -1; // If voltage is super low assume no battery installed
 
+#ifndef NRF52_SERIES
+        // This does not work on a RAK4631 with battery connected
         if (v > chargingVolt)
             return 0; // While charging we can't report % full on the battery
+#endif
 
-        return 100 * (v - emptyVolt) / (fullVolt - emptyVolt);
+        return clamp((int)(100 * (v - emptyVolt) / (fullVolt - emptyVolt)), 0, 100);
     }
 
     /**
@@ -189,6 +192,7 @@ bool Power::setup()
         found = analogInit();
     }
     enabled = found;
+    low_voltage_counter = 0;
 
     return found;
 }
@@ -235,9 +239,24 @@ void Power::readPowerStatus()
                   powerStatus.getIsCharging(), powerStatus.getBatteryVoltageMv(), powerStatus.getBatteryChargePercent());
         newStatus.notifyObservers(&powerStatus);
 
+
+        // If we have a battery at all and it is less than 10% full, force deep sleep if we have more than 3 low readings in a row
+        // Supect fluctuating voltage on the RAK4631 to force it to deep sleep even if battery is at 85% after only a few days
+        #ifdef NRF52_SERIES
+        if (powerStatus.getHasBattery() && !powerStatus.getHasUSB()){
+            if (batteryLevel->getBattVoltage() < MIN_BAT_MILLIVOLTS){
+                low_voltage_counter++;
+                if (low_voltage_counter>3)
+                    powerFSM.trigger(EVENT_LOW_BATTERY);
+            } else {
+                low_voltage_counter = 0;
+            }
+        }
+        #else
         // If we have a battery at all and it is less than 10% full, force deep sleep
         if (powerStatus.getHasBattery() && !powerStatus.getHasUSB() && batteryLevel->getBattVoltage() < MIN_BAT_MILLIVOLTS)
             powerFSM.trigger(EVENT_LOW_BATTERY);
+        #endif
     } else {
         // No power sensing on this board - tell everyone else we have no idea what is happening
         const PowerStatus powerStatus = PowerStatus(OptUnknown, OptUnknown, OptUnknown, -1, -1);

src/PowerFSM.cpp

@@ -27,6 +27,7 @@ static bool isPowered()
 
 static void sdsEnter()
 {
+    DEBUG_MSG("Enter state: SDS\n");
     // FIXME - make sure GPS and LORA radio are off first - because we want close to zero current draw
     doDeepSleep(getPref_sds_secs() * 1000LL);
 }
@@ -41,7 +42,7 @@ static void lsEnter()
     screen->setOn(false);
     secsSlept = 0; // How long have we been sleeping this time
 
-    DEBUG_MSG("lsEnter end\n");
+    // DEBUG_MSG("lsEnter end\n");
 }
 
 static void lsIdle()
@@ -112,6 +113,7 @@ static void lsIdle()
 
 static void lsExit()
 {
+    DEBUG_MSG("Exit state: LS\n");
     // setGPSPower(true); // restore GPS power
     if (gps)
         gps->forceWake(true);
@@ -119,6 +121,7 @@ static void lsExit()
 
 static void nbEnter()
 {
+    DEBUG_MSG("Enter state: NB\n");
     screen->setOn(false);
     setBluetoothEnable(false);
 
@@ -133,6 +136,7 @@ static void darkEnter()
 
 static void serialEnter()
 {
+    DEBUG_MSG("Enter state: SERIAL\n");
     setBluetoothEnable(false);
     screen->setOn(true);
     screen->print("Serial connected\n");
@@ -145,6 +149,7 @@ static void serialExit()
 
 static void powerEnter()
 {
+    DEBUG_MSG("Enter state: POWER\n");
     if (!isPowered()) {
         // If we got here, we are in the wrong state - we should be in powered, let that state ahndle things
         DEBUG_MSG("Loss of power in Powered\n");
@@ -174,6 +179,7 @@ static void powerExit()
 
 static void onEnter()
 {
+    DEBUG_MSG("Enter state: ON\n");
     screen->setOn(true);
     setBluetoothEnable(true);
 
@@ -202,7 +208,9 @@ static void screenPress()
     screen->onPress();
 }
 
-static void bootEnter() {}
+static void bootEnter() {
+    DEBUG_MSG("Enter state: BOOT\n");
+}
 
 State stateSDS(sdsEnter, NULL, NULL, "SDS");
 State stateLS(lsEnter, lsIdle, lsExit, "LS");
@@ -226,10 +234,9 @@ void PowerFSM_setup()
     // if we are a router node, we go to NB (no need for bluetooth) otherwise we go to DARK (so we can send message to phone)
     powerFSM.add_transition(&stateLS, isRouter ? &stateNB : &stateDARK, EVENT_WAKE_TIMER, NULL, "Wake timer");
 
-    // Note we don't really use this transition, because when we wake from light sleep we _always_ transition to NB or dark and
-    // then it handles things powerFSM.add_transition(&stateLS, &stateNB, EVENT_RECEIVED_PACKET, NULL, "Received packet");
-
-    powerFSM.add_transition(&stateNB, &stateNB, EVENT_RECEIVED_PACKET, NULL, "Received packet, resetting win wake");
+    // We need this transition, because we might not transition if we were waiting to enter light-sleep, because when we wake from light sleep we _always_ transition to NB or dark and
+    powerFSM.add_transition(&stateLS, isRouter ? &stateNB : &stateDARK, EVENT_PACKET_FOR_PHONE, NULL, "Received packet, exiting light sleep");
+    powerFSM.add_transition(&stateNB, &stateNB, EVENT_PACKET_FOR_PHONE, NULL, "Received packet, resetting win wake");
 
     // Handle press events - note: we ignore button presses when in API mode
     powerFSM.add_transition(&stateLS, &stateON, EVENT_PRESS, NULL, "Press");
@@ -253,6 +260,9 @@ void PowerFSM_setup()
 
     // if we are a router we don't turn the screen on for these things
     if (!isRouter) {
+        // if any packet destined for phone arrives, turn on bluetooth at least
+        powerFSM.add_transition(&stateNB, &stateDARK, EVENT_PACKET_FOR_PHONE, NULL, "Packet for phone");
+
         // show the latest node when we get a new node db update
         powerFSM.add_transition(&stateNB, &stateON, EVENT_NODEDB_UPDATED, NULL, "NodeDB update");
         powerFSM.add_transition(&stateDARK, &stateON, EVENT_NODEDB_UPDATED, NULL, "NodeDB update");
@@ -292,13 +302,13 @@ void PowerFSM_setup()
     powerFSM.add_transition(&stateDARK, &stateON, EVENT_FIRMWARE_UPDATE, NULL, "Got firmware update");
     powerFSM.add_transition(&stateON, &stateON, EVENT_FIRMWARE_UPDATE, NULL, "Got firmware update");
 
-    powerFSM.add_transition(&stateNB, &stateDARK, EVENT_PACKET_FOR_PHONE, NULL, "Packet for phone");
-
     powerFSM.add_timed_transition(&stateON, &stateDARK, getPref_screen_on_secs() * 1000, NULL, "Screen-on timeout");
 
     // On most boards we use light-sleep to be our main state, but on NRF52 we just stay in DARK
     State *lowPowerState = &stateLS;
 
+    uint32_t meshSds = 0;
+
 #ifndef NRF52_SERIES
     // We never enter light-sleep or NB states on NRF52 (because the CPU uses so little power normally)
 
@@ -307,11 +317,12 @@ void PowerFSM_setup()
 
     powerFSM.add_timed_transition(&stateNB, &stateLS, getPref_min_wake_secs() * 1000, NULL, "Min wake timeout");
     powerFSM.add_timed_transition(&stateDARK, &stateLS, getPref_wait_bluetooth_secs() * 1000, NULL, "Bluetooth timeout");
+    meshSds = getPref_mesh_sds_timeout_secs();
 #else
     lowPowerState = &stateDARK;
+    meshSds = UINT32_MAX; //Workaround for now: Don't go into deep sleep on the RAK4631
 #endif
 
-    auto meshSds = getPref_mesh_sds_timeout_secs();
     if (meshSds != UINT32_MAX)
         powerFSM.add_timed_transition(lowPowerState, &stateSDS, meshSds * 1000, NULL, "mesh timeout");
     // removing for now, because some users don't even have phones

src/PowerFSM.h

@@ -6,7 +6,7 @@
 
 #define EVENT_PRESS 1
 #define EVENT_WAKE_TIMER 2
-#define EVENT_RECEIVED_PACKET 3
+// #define EVENT_RECEIVED_PACKET 3
 #define EVENT_PACKET_FOR_PHONE 4
 #define EVENT_RECEIVED_TEXT_MSG 5
 // #define EVENT_BOOT 6 // now done with a timed transition

src/RedirectablePrint.cpp

@@ -2,6 +2,7 @@
 #include "RedirectablePrint.h"
 #include "RTC.h"
 #include "concurrency/OSThread.h"
+// #include "wifi/WiFiServerAPI.h"
 #include <assert.h>
 #include <sys/time.h>
 #include <time.h>
@@ -25,6 +26,10 @@ size_t RedirectablePrint::write(uint8_t c)
     SEGGER_RTT_PutChar(SEGGER_STDOUT_CH, c);
 #endif
 
+    // FIXME - clean this up, the whole relationship of this class to SerialConsole to TCP/bluetooth debug log output is kinda messed up.  But for now, just have this hack to
+    // optionally send chars to TCP also
+    //WiFiServerPort::debugOut(c);
+
     dest->write(c);
     return 1; // We always claim one was written, rather than trusting what the
               // serial port said (which could be zero)

src/concurrency/NotifiedWorkerThread.cpp

@@ -72,14 +72,21 @@ bool NotifiedWorkerThread::notifyLater(uint32_t delay, uint32_t v, bool overwrit
     return didIt;
 }
 
-int32_t NotifiedWorkerThread::runOnce()
+void NotifiedWorkerThread::checkNotification()
 {
     auto n = notification;
-    enabled = false;  // Only run once per notification
     notification = 0; // clear notification
     if (n) {
         onNotify(n);
     }
+}
+
+
+
+int32_t NotifiedWorkerThread::runOnce()
+{
+    enabled = false;  // Only run once per notification
+    checkNotification();
 
     return RUN_SAME;
 }

src/concurrency/NotifiedWorkerThread.h

@@ -38,8 +38,14 @@ class NotifiedWorkerThread : public OSThread
   protected:
     virtual void onNotify(uint32_t notification) = 0;
 
+    /// just calls checkNotification()
     virtual int32_t runOnce();
 
+    /// Sometimes we might want to check notifications independently of when our thread was getting woken up (i.e. if we are about to change
+    /// radio transmit/receive modes we want to handle any pending interrupts first).  You can call this method and if any notifications are currently
+    /// pending they will be handled immediately.
+    void checkNotification();
+
   private:
     /**
      * Notify this thread so it can run

src/configuration.h

@@ -188,11 +188,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define LORA_DIO3    // Not connected on PCB, but internally on the TTGO SX1262, if DIO3 is high the TXCO is enabled
 
 #ifdef USE_SX1262
-#define SX1262_CS RF95_NSS // FIXME - we really should define LORA_CS instead
-#define SX1262_DIO1 LORA_DIO1
-#define SX1262_BUSY LORA_DIO2
-#define SX1262_RESET LORA_RESET
-#define SX1262_E22 // Not really an E22 but TTGO seems to be trying to clone that
+#define SX126X_CS RF95_NSS // FIXME - we really should define LORA_CS instead
+#define SX126X_DIO1 LORA_DIO1
+#define SX126X_BUSY LORA_DIO2
+#define SX126X_RESET LORA_RESET
+#define SX126X_E22 // Not really an E22 but TTGO seems to be trying to clone that
 // Internally the TTGO module hooks the SX1262-DIO2 in to control the TX/RX switch (which is the default for the sx1262interface
 // code)
 #endif
@@ -226,6 +226,51 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define GPS_RX_PIN 12
 #define GPS_TX_PIN 15
 
+#elif defined(DIY_V1)
+// This string must exactly match the case used in release file names or the android updater won't work
+#define HW_VENDOR HardwareModel_DIY_V1
+
+// For OLED LCD
+#define I2C_SDA 21
+#define I2C_SCL 22
+
+// GPS
+#undef GPS_RX_PIN
+#define GPS_RX_PIN 15
+//#undef GPS_TX_PIN
+//#define GPS_TX_PIN 12 // not connected
+
+#define BUTTON_PIN 39 // The middle button GPIO on the T-Beam
+
+#define LORA_DIO0 26  // a No connect on the SX1262/SX1268 module
+#define LORA_RESET 23 // RST for SX1276, and for SX1262/SX1268
+#define LORA_DIO1 33  // IRQ for SX1262/SX1268
+#define LORA_DIO2 32  // BUSY for SX1262/SX1268
+#define LORA_DIO3     // Not connected on PCB, but internally on the TTGO SX1262/SX1268, if DIO3 is high the TXCO is enabled
+
+#define RF95_SCK 5
+#define RF95_MISO 19
+#define RF95_MOSI 27
+#define RF95_NSS 18
+
+// supported modules list
+#define USE_SX1262
+#define USE_SX1268
+
+// common pinouts for SX126X modules
+#define SX126X_CS 18 // NSS for SX126X
+#define SX126X_DIO1 LORA_DIO1
+#define SX126X_BUSY LORA_DIO2
+#define SX126X_RESET LORA_RESET
+#define SX126X_RXEN 14
+#define SX126X_TXEN 13
+
+#ifdef EBYTE_E22
+// Internally the TTGO module hooks the SX126x-DIO2 in to control the TX/RX switch
+// (which is the default for the sx1262interface code)
+#define SX126X_E22
+#endif
+
 #elif defined(ARDUINO_HELTEC_WIFI_LORA_32_V2)
 
 // the default ESP32 Pin of 15 is the Oled SCL, set to 36 and 37 and works fine.
@@ -462,11 +507,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define LORA_DIO3    // Not connected on PCB, but internally on the TTGO SX1262, if DIO3 is high the TXCO is enabled
 
 #ifdef USE_SX1262
-#define SX1262_CS 20 // CS0 on pinelora schematic, hooked to gpio D0 on ch341f
-#define SX1262_DIO1 LORA_DIO1
-#define SX1262_BUSY LORA_DIO2
-#define SX1262_RESET LORA_RESET
-// HOPE RFM90 does not have a TCXO therefore not SX1262_E22 
+#define SX126X_CS 20 // CS0 on pinelora schematic, hooked to gpio D0 on ch341f
+#define SX126X_DIO1 LORA_DIO1
+#define SX126X_BUSY LORA_DIO2
+#define SX126X_RESET LORA_RESET
+// HOPE RFM90 does not have a TCXO therefore not SX126X_E22 
 #endif
 
 #endif

src/gps/GPS.cpp

@@ -80,6 +80,8 @@ GPS::~GPS()
     notifyDeepSleepObserver.unobserve();
 }
 
+bool GPS::hasLock() { return hasValidLocation; }
+
 // Allow defining the polarity of the WAKE output.  default is active high
 #ifndef GPS_WAKE_ACTIVE
 #define GPS_WAKE_ACTIVE 1
@@ -325,6 +327,11 @@ GPS *createGps()
 #ifdef NO_GPS
     return nullptr;
 #else
+#ifdef GPS_ALTITUDE_HAE
+    DEBUG_MSG("Using HAE altitude model\n");
+#else
+    DEBUG_MSG("Using MSL altitude model\n");
+#endif
 // If we don't have bidirectional comms, we can't even try talking to UBLOX
 #ifdef GPS_TX_PIN
     // Init GPS - first try ublox

src/gps/GPS.h

@@ -45,6 +45,9 @@ class GPS : private concurrency::OSThread
                           // scaling before use)
     uint32_t heading = 0; // Heading of motion, in degrees * 10^-5
 
+    int32_t geoidal_height = 0;  // geoidal separation, in meters!
+    time_t pos_timestamp = 0;  // positional timestamp from GPS solution
+
     GPS() : concurrency::OSThread("GPS") {}
 
     virtual ~GPS();
@@ -57,8 +60,8 @@ class GPS : private concurrency::OSThread
      */
     virtual bool setup();
 
-    /// Returns ture if we have acquired GPS lock.
-    bool hasLock() const { return hasValidLocation; }
+    /// Returns true if we have acquired GPS lock.
+    virtual bool hasLock();
 
     /// Return true if we are connected to a GPS
     bool isConnected() const { return hasGPS; }

src/gps/GeoCoord.cpp

@@ -0,0 +1,450 @@
+#include "GeoCoord.h"
+
+GeoCoord::GeoCoord() {
+    _dirty = true;
+}
+
+GeoCoord::GeoCoord (int32_t lat, int32_t lon, int32_t alt) : _latitude(lat), _longitude(lon), _altitude(alt) {
+    GeoCoord::setCoords();
+}
+
+GeoCoord::GeoCoord (float lat, float lon, int32_t alt) : _altitude(alt) {
+    // Change decimial reprsentation to int32_t. I.e., 12.345 becomes 123450000
+    _latitude = int32_t(lat * 1e+7);
+    _longitude = int32_t(lon * 1e+7);
+    GeoCoord::setCoords();
+}
+
+GeoCoord::GeoCoord(double lat, double lon, int32_t alt): _altitude(alt) {
+    // Change decimial reprsentation to int32_t. I.e., 12.345 becomes 123450000
+    _latitude = int32_t(lat * 1e+7);
+    _longitude = int32_t(lon * 1e+7);
+    GeoCoord::setCoords();
+}
+
+// Initialize all the coordinate systems
+void GeoCoord::setCoords() {
+    double lat = _latitude * 1e-7;
+    double lon = _longitude * 1e-7;
+    GeoCoord::latLongToDMS(lat, lon, _dms);
+    GeoCoord::latLongToUTM(lat, lon, _utm);
+    GeoCoord::latLongToMGRS(lat, lon, _mgrs);
+    GeoCoord::latLongToOSGR(lat, lon, _osgr);
+    GeoCoord::latLongToOLC(lat, lon, _olc);
+    _dirty = false;
+}
+
+void GeoCoord::updateCoords(int32_t lat, int32_t lon, int32_t alt) {
+    // If marked dirty or new coordiantes
+    if(_dirty || _latitude != lat || _longitude != lon || _altitude != alt) {
+        _dirty = true;
+        _latitude = lat;
+        _longitude = lon;
+        _altitude = alt;
+        setCoords();
+    }
+}
+
+void GeoCoord::updateCoords(const double lat, const double lon, const int32_t alt) {
+    int32_t iLat = lat * 1e+7;
+    int32_t iLon = lon * 1e+7;
+    // If marked dirty or new coordiantes
+    if(_dirty ||  _latitude != iLat || _longitude != iLon || _altitude != alt) {
+        _dirty = true;
+        _latitude = iLat;
+        _longitude = iLon;
+        _altitude = alt;
+        setCoords();
+    }
+    
+}
+
+void GeoCoord::updateCoords(const float lat, const float lon, const int32_t alt) {
+    int32_t iLat = lat * 1e+7;
+    int32_t iLon = lon * 1e+7;
+    // If marked dirty or new coordiantes
+    if(_dirty || _latitude != iLat || _longitude != iLon || _altitude != alt) {
+        _dirty = true;
+        _latitude = iLat;
+        _longitude = iLon;
+        _altitude = alt;
+        setCoords();
+    }
+}
+
+/**
+ * Converts lat long coordinates from decimal degrees to degrees minutes seconds format. 
+ * DD°MM'SS"C DDD°MM'SS"C
+ */
+void GeoCoord::latLongToDMS(const double lat, const double lon, DMS &dms) {    
+    if (lat < 0) dms.latCP = 'S';
+    else dms.latCP = 'N';
+
+    double latDeg = lat;
+
+    if (lat < 0)
+        latDeg = latDeg * -1;
+
+    dms.latDeg = floor(latDeg);
+    double latMin = (latDeg - dms.latDeg) * 60;
+    dms.latMin = floor(latMin);
+    dms.latSec = (latMin - dms.latMin) * 60;
+
+    if (lon < 0) dms.lonCP = 'W';
+    else dms.lonCP = 'E';
+
+    double lonDeg = lon;
+
+    if (lon < 0)
+        lonDeg = lonDeg * -1;
+
+    dms.lonDeg = floor(lonDeg);
+    double lonMin = (lonDeg - dms.lonDeg) * 60;
+    dms.lonMin = floor(lonMin);
+    dms.lonSec = (lonMin - dms.lonMin) * 60;
+}
+
+/**
+ * Converts lat long coordinates to UTM.
+ * based on this: https://github.com/walvok/LatLonToUTM/blob/master/latlon_utm.ino
+ */
+void GeoCoord::latLongToUTM(const double lat, const double lon, UTM &utm) {
+
+    const std::string latBands = "CDEFGHJKLMNPQRSTUVWXX";
+    utm.zone = int((lon + 180)/6 + 1);
+    utm.band = latBands[int(lat/8 + 10)];
+    double a = 6378137; // WGS84 - equatorial radius
+    double k0 = 0.9996; // UTM point scale on the central meridian
+    double eccSquared = 0.00669438;   // eccentricity squared
+    double lonTemp = (lon + 180) - int((lon + 180)/360) * 360 - 180; //Make sure the longitude is between -180.00 .. 179.9
+    double latRad = toRadians(lat);
+    double lonRad = toRadians(lonTemp);
+
+    // Special Zones for Norway and Svalbard
+    if( lat >= 56.0 && lat < 64.0 && lonTemp >= 3.0 && lonTemp < 12.0 ) // Norway
+        utm.zone = 32;
+    if( lat >= 72.0 && lat < 84.0 ) { // Svalbard
+        if     ( lonTemp >= 0.0  && lonTemp <  9.0 ) utm.zone = 31;
+        else if( lonTemp >= 9.0  && lonTemp < 21.0 ) utm.zone = 33;
+        else if( lonTemp >= 21.0 && lonTemp < 33.0 ) utm.zone = 35;
+        else if( lonTemp >= 33.0 && lonTemp < 42.0 ) utm.zone = 37;
+    }
+    
+    double lonOrigin = (utm.zone - 1)*6 - 180 + 3;  // puts origin in middle of zone
+    double lonOriginRad = toRadians(lonOrigin);
+    double eccPrimeSquared = (eccSquared)/(1 - eccSquared);
+    double N = a/sqrt(1 - eccSquared*sin(latRad)*sin(latRad));
+    double T = tan(latRad)*tan(latRad);
+    double C = eccPrimeSquared*cos(latRad)*cos(latRad);
+    double A = cos(latRad)*(lonRad - lonOriginRad);
+    double M = a*((1 - eccSquared/4 - 3*eccSquared*eccSquared/64 - 5*eccSquared*eccSquared*eccSquared/256)*latRad 
+        - (3*eccSquared/8 + 3*eccSquared*eccSquared/32 + 45*eccSquared*eccSquared*eccSquared/1024)*sin(2*latRad)
+        + (15*eccSquared*eccSquared/256 + 45*eccSquared*eccSquared*eccSquared/1024)*sin(4*latRad) 
+        - (35*eccSquared*eccSquared*eccSquared/3072)*sin(6*latRad));
+    utm.easting = (double)(k0*N*(A+(1-T+C)*pow(A, 3)/6 + (5-18*T+T*T+72*C-58*eccPrimeSquared)*A*A*A*A*A/120) 
+        + 500000.0);
+    utm.northing = (double)(k0*(M+N*tan(latRad)*(A*A/2+(5-T+9*C+4*C*C)*A*A*A*A/24
+        + (61-58*T+T*T+600*C-330*eccPrimeSquared)*A*A*A*A*A*A/720)));
+            
+    if(lat < 0)
+        utm.northing += 10000000.0; //10000000 meter offset for southern hemisphere
+}
+
+// Converts lat long coordinates to an MGRS.
+void GeoCoord::latLongToMGRS(const double lat, const double lon, MGRS &mgrs) {
+    const std::string e100kLetters[3] = { "ABCDEFGH", "JKLMNPQR", "STUVWXYZ" };
+    const std::string n100kLetters[2] = { "ABCDEFGHJKLMNPQRSTUV", "FGHJKLMNPQRSTUVABCDE" };
+    UTM utm;
+    latLongToUTM(lat, lon, utm);
+    mgrs.zone = utm.zone;
+    mgrs.band = utm.band;
+    double col = floor(utm.easting / 100000);
+    mgrs.east100k = e100kLetters[(mgrs.zone - 1) % 3][col - 1];
+    double row = (int32_t)floor(utm.northing / 100000.0) % 20;
+    mgrs.north100k = n100kLetters[(mgrs.zone-1)%2][row];
+    mgrs.easting = (int32_t)utm.easting % 100000;
+    mgrs.northing = (int32_t)utm.northing % 100000;
+}
+
+/**
+ * Converts lat long coordinates to Ordnance Survey Grid Reference (UK National Grid Ref).
+ * Based on: https://www.movable-type.co.uk/scripts/latlong-os-gridref.html
+ */
+void GeoCoord::latLongToOSGR(const double lat, const double lon, OSGR &osgr) {
+    char letter[] = "ABCDEFGHJKLMNOPQRSTUVWXYZ"; // No 'I' in OSGR
+    double a = 6377563.396; // Airy 1830 semi-major axis
+    double b = 6356256.909; // Airy 1830 semi-minor axis
+    double f0 = 0.9996012717; // National Grid point scale factor on the central meridian
+    double phi0 = toRadians(49); 
+    double lambda0 = toRadians(-2);
+    double n0 = -100000;
+    double e0 = 400000;
+    double e2 = 1 - (b*b)/(a*a); // eccentricity squared
+    double n = (a - b)/(a + b);
+    
+    double osgb_Latitude;
+    double osgb_Longitude;
+    convertWGS84ToOSGB36(lat, lon, osgb_Latitude, osgb_Longitude);
+    double phi = osgb_Latitude; // already in radians
+    double lambda = osgb_Longitude; // already in radians
+    double v = a * f0 / sqrt(1 - e2 * sin(phi) * sin(phi));
+    double rho = a * f0 * (1 - e2) / pow(1 - e2 * sin(phi) * sin(phi), 1.5);
+    double eta2 = v / rho - 1;
+    double mA = (1 + n + (5/4)*n*n + (5/4)*n*n*n) * (phi - phi0);
+    double mB = (3*n + 3*n*n + (21/8)*n*n*n) * sin(phi - phi0) * cos(phi + phi0);
+    // loss of precision in mC & mD due to floating point rounding can cause innaccuracy of northing by a few meters
+    double mC = (15/8*n*n + 15/8*n*n*n) * sin(2*(phi - phi0)) * cos(2*(phi + phi0));
+    double mD = (35/24)*n*n*n * sin(3*(phi - phi0)) * cos(3*(phi + phi0));
+    double m = b*f0*(mA - mB + mC - mD);
+
+    double cos3Phi = cos(phi)*cos(phi)*cos(phi);
+    double cos5Phi = cos3Phi*cos(phi)*cos(phi);
+    double tan2Phi = tan(phi)*tan(phi);
+    double tan4Phi = tan2Phi*tan2Phi;
+    double I = m + n0;
+    double II = (v/2)*sin(phi)*cos(phi);
+    double III = (v/24)*sin(phi)*cos3Phi*(5 - tan2Phi + 9*eta2);
+    double IIIA = (v/720)*sin(phi)*cos5Phi*(61 - 58*tan2Phi + tan4Phi);
+    double IV = v*cos(phi);
+    double V = (v/6)*cos3Phi*(v/rho - tan2Phi);
+    double VI = (v/120)*cos5Phi*(5 - 18*tan2Phi + tan4Phi + 14*eta2 - 58*tan2Phi*eta2);
+
+    double deltaLambda = lambda - lambda0;
+    double deltaLambda2 = deltaLambda*deltaLambda;
+    double northing = I + II*deltaLambda2 + III*deltaLambda2*deltaLambda2 + IIIA*deltaLambda2*deltaLambda2*deltaLambda2;
+    double easting = e0 + IV*deltaLambda + V*deltaLambda2*deltaLambda + VI*deltaLambda2*deltaLambda2*deltaLambda;
+
+    if (easting < 0 || easting > 700000 || northing < 0 || northing > 1300000) // Check if out of boundaries
+        osgr = { 'I', 'I', 0, 0 };
+    else {
+        uint32_t e100k = floor(easting / 100000);
+        uint32_t n100k = floor(northing / 100000);
+        int8_t l1 = (19 - n100k) - (19 - n100k) % 5 + floor((e100k + 10) / 5);
+        int8_t l2 = (19 - n100k) * 5 % 25 + e100k % 5;
+        osgr.e100k = letter[l1];
+        osgr.n100k = letter[l2];
+        osgr.easting = floor((int)easting % 100000);
+        osgr.northing = floor((int)northing % 100000);
+    }
+}
+
+/**
+ * Converts lat long coordinates to Open Location Code.
+ * Based on: https://github.com/google/open-location-code/blob/main/c/src/olc.c
+ */
+void GeoCoord::latLongToOLC(double lat, double lon, OLC &olc) {
+    char tempCode[] = "1234567890abc";
+    const char kAlphabet[] = "23456789CFGHJMPQRVWX";
+    double latitude;
+    double longitude = lon;
+    double latitude_degrees = std::min(90.0, std::max(-90.0, lat));
+
+    if (latitude_degrees < 90) // Check latitude less than lat max
+        latitude = latitude_degrees;
+    else {
+        double precision;
+        if (OLC_CODE_LEN <= 10)
+            precision = pow_neg(20, floor((OLC_CODE_LEN / -2) + 2));
+        else
+            precision = pow_neg(20, -3) / pow(5, OLC_CODE_LEN - 10);
+        latitude = latitude_degrees - precision / 2;
+    }
+    while (longitude < -180) // Normalize longitude
+        longitude += 360;
+    while (longitude >= 180)
+        longitude -= 360;
+    int64_t lat_val = 90 * 2.5e7;
+    int64_t lng_val = 180 * 8.192e6;
+    lat_val += latitude * 2.5e7;
+    lng_val += longitude * 8.192e6;
+    size_t pos = OLC_CODE_LEN;
+    
+    if (OLC_CODE_LEN > 10) { // Compute grid part of code if needed
+        for (size_t i = 0; i < 5; i++) {
+            int lat_digit = lat_val % 5;
+            int lng_digit = lng_val % 4;
+            int ndx = lat_digit * 4 + lng_digit;
+            tempCode[pos--] = kAlphabet[ndx];
+            lat_val /= 5;
+            lng_val /= 4;
+        }
+    } else {
+        lat_val /= pow(5, 5);
+        lng_val /= pow(4, 5);
+    }
+    
+    pos = 10;
+    
+    for (size_t i = 0; i < 5; i++) { // Compute pair section of code
+        int lat_ndx = lat_val % 20;
+        int lng_ndx = lng_val % 20;
+        tempCode[pos--] = kAlphabet[lng_ndx];
+        tempCode[pos--] = kAlphabet[lat_ndx];
+        lat_val /= 20;
+        lng_val /= 20;
+
+        if (i == 0)
+            tempCode[pos--] = '+';
+    }
+    
+    if (OLC_CODE_LEN < 9) { // Add padding if needed
+        for (size_t i = OLC_CODE_LEN; i < 9; i++)
+            tempCode[i] = '0';
+        tempCode[9] = '+';
+    }
+
+    size_t char_count = OLC_CODE_LEN;
+    if (10 > char_count) {
+        char_count = 10;
+    }
+    for (size_t i = 0; i < char_count; i++) {
+        olc.code[i] = tempCode[i];
+    }
+    olc.code[char_count] = '\0';    
+}
+
+// Converts the coordinate in WGS84 datum to the OSGB36 datum.
+void GeoCoord::convertWGS84ToOSGB36(const double lat, const double lon, double &osgb_Latitude, double &osgb_Longitude) {
+    // Convert lat long to cartesian
+    double phi = toRadians(lat);
+    double lambda = toRadians(lon);
+    double h = 0.0; // No OSTN height data used, some loss of accuracy (up to 5m)
+    double wgsA = 6378137; // WGS84 datum semi major axis
+    double wgsF = 1 / 298.257223563; // WGS84 datum flattening
+    double ecc = 2*wgsF - wgsF*wgsF;
+    double vee = wgsA / sqrt(1 - ecc * pow(sin(phi), 2));
+    double wgsX = (vee + h) * cos(phi) * cos(lambda);
+    double wgsY = (vee + h) * cos(phi) * sin(lambda);
+    double wgsZ = ((1 - ecc) * vee + h) * sin(phi);
+
+    // 7-parameter Helmert transform
+    double tx = -446.448; // x shift in meters
+    double ty = 125.157; // y shift in meters
+    double tz = -542.060; // z shift in meters
+    double s = 20.4894/1e6 + 1; // scale normalized parts per million to (s + 1)
+    double rx = toRadians(-0.1502/3600); // x rotation normalize arcseconds to radians
+    double ry = toRadians(-0.2470/3600); // y rotation normalize arcseconds to radians
+    double rz = toRadians(-0.8421/3600); // z rotation normalize arcseconds to radians
+    double osgbX = tx + wgsX*s - wgsY*rz + wgsZ*ry; 
+    double osgbY = ty + wgsX*rz + wgsY*s - wgsZ*rx;
+    double osgbZ = tz - wgsX*ry + wgsY*rx + wgsZ*s;
+
+    // Convert cartesian to lat long
+    double airyA = 6377563.396; // Airy1830 datum semi major axis
+    double airyB = 6356256.909; // Airy1830 datum semi minor axis
+    double airyF = 1/ 299.3249646; // Airy1830 datum flattening
+    double airyEcc = 2*airyF - airyF*airyF;
+    double airyEcc2 = airyEcc / (1 - airyEcc);
+    double p = sqrt(osgbX*osgbX + osgbY*osgbY);
+    double R = sqrt(p*p + osgbZ*osgbZ);
+    double tanBeta = (airyB*osgbZ) / (airyA*p) * (1 + airyEcc2*airyB/R);
+    double sinBeta = tanBeta / sqrt(1 + tanBeta*tanBeta);
+    double cosBeta = sinBeta / tanBeta;
+    osgb_Latitude = atan2(osgbZ + airyEcc2*airyB*sinBeta*sinBeta*sinBeta, p - airyEcc*airyA*cosBeta*cosBeta*cosBeta); // leave in radians
+    osgb_Longitude = atan2(osgbY, osgbX); // leave in radians
+    //osgb height = p*cos(osgb.latitude) + osgbZ*sin(osgb.latitude) - 
+            //(airyA*airyA/(airyA / sqrt(1 - airyEcc*sin(osgb.latitude)*sin(osgb.latitude)))); // Not used, no OSTN data
+}
+
+/// Ported from my old java code, returns distance in meters along the globe
+/// surface (by magic?)
+float GeoCoord::latLongToMeter(double lat_a, double lng_a, double lat_b, double lng_b)
+{
+    double pk = (180 / 3.14169);
+    double a1 = lat_a / pk;
+    double a2 = lng_a / pk;
+    double b1 = lat_b / pk;
+    double b2 = lng_b / pk;
+    double cos_b1 = cos(b1);
+    double cos_a1 = cos(a1);
+    double t1 = cos_a1 * cos(a2) * cos_b1 * cos(b2);
+    double t2 = cos_a1 * sin(a2) * cos_b1 * sin(b2);
+    double t3 = sin(a1) * sin(b1);
+    double tt = acos(t1 + t2 + t3);
+    if (std::isnan(tt))
+        tt = 0.0; // Must have been the same point?
+
+    return (float)(6366000 * tt);
+}
+
+/**
+ * Computes the bearing in degrees between two points on Earth.  Ported from my
+ * old Gaggle android app.
+ *
+ * @param lat1
+ * Latitude of the first point
+ * @param lon1
+ * Longitude of the first point
+ * @param lat2
+ * Latitude of the second point
+ * @param lon2
+ * Longitude of the second point
+ * @return Bearing between the two points in radians. A value of 0 means due
+ * north.
+ */
+float GeoCoord::bearing(double lat1, double lon1, double lat2, double lon2)
+{
+    double lat1Rad = toRadians(lat1);
+    double lat2Rad = toRadians(lat2);
+    double deltaLonRad = toRadians(lon2 - lon1);
+    double y = sin(deltaLonRad) * cos(lat2Rad);
+    double x = cos(lat1Rad) * sin(lat2Rad) - (sin(lat1Rad) * cos(lat2Rad) * cos(deltaLonRad));
+    return atan2(y, x);
+}
+
+/**
+ * Ported from http://www.edwilliams.org/avform147.htm#Intro
+ * @brief Convert from meters to range in radians on a great circle
+ * @param range_meters
+ * The range in meters
+ * @return range in radians on a great circle 
+ */
+float GeoCoord::rangeMetersToRadians(double range_meters) {
+    // 1 nm is 1852 meters
+    double distance_nm = range_meters * 1852;
+    return (PI / (180 * 60)) *distance_nm;
+}
+
+/**
+ * Ported from http://www.edwilliams.org/avform147.htm#Intro
+ * @brief Convert from radians to range in meters on a great circle
+ * @param range_radians
+ * The range in radians
+ * @return Range in meters on a great circle 
+ */
+float GeoCoord::rangeRadiansToMeters(double range_radians) {
+    double distance_nm = ((180 * 60) / PI) * range_radians;
+    // 1 meter is 0.000539957 nm
+    return distance_nm * 0.000539957;
+}
+
+// Find distance from point to passed in point
+int32_t GeoCoord::distanceTo(GeoCoord pointB) {
+    return latLongToMeter(this->getLatitude() * 1e-7, this->getLongitude() * 1e-7, pointB.getLatitude() * 1e-7, pointB.getLongitude() * 1e-7);
+}
+
+// Find bearing from point to passed in point
+int32_t GeoCoord::bearingTo(GeoCoord pointB) {
+    return bearing(this->getLatitude() * 1e-7, this->getLongitude() * 1e-7, pointB.getLatitude() * 1e-7, pointB.getLongitude() * 1e-7);
+}
+
+/**
+ * Create a new point bassed on the passed in poin
+ * Ported from http://www.edwilliams.org/avform147.htm#LL
+ * @param bearing
+ * The bearing in raidans
+ * @param range_meters
+ * range in meters
+ * @return GeoCoord object of point at bearing and range from initial point
+*/ 
+std::shared_ptr<GeoCoord> GeoCoord::pointAtDistance(double bearing, double range_meters) {
+    double range_radians = rangeMetersToRadians(range_meters);
+    double lat1 = this->getLatitude() * 1e-7;
+    double lon1 = this->getLongitude() * 1e-7;
+    double lat = asin(sin(lat1) * cos(range_radians) + cos(lat1) * sin(range_radians) * cos(bearing));
+    double dlon = atan2(sin(bearing) * sin(range_radians) * cos(lat1), cos(range_radians) - sin(lat1) * sin(lat));
+    double lon = fmod(lon1 - dlon + PI, 2 * PI) - PI;
+
+    return std::make_shared<GeoCoord>(double(lat), double(lon), this->getAltitude());
+    
+}

src/gps/GeoCoord.h

@@ -0,0 +1,164 @@
+#pragma once
+
+#include <algorithm>
+#include <string>
+#include <cstring>
+#include <cstdint>
+#include <math.h>
+#include <stdint.h>
+#include <stdexcept>
+#include <memory>
+
+#define PI 3.1415926535897932384626433832795
+#define OLC_CODE_LEN 11
+
+// Helper functions
+// Raises a number to an exponent, handling negative exponents.
+static double pow_neg(double base, double exponent) {
+  if (exponent == 0) {
+    return 1;
+  } else if (exponent > 0) {
+    return pow(base, exponent);
+  }
+  return 1 / pow(base, -exponent);
+}
+
+static inline double toRadians(double deg)
+{
+    return deg * PI / 180;
+}
+
+static inline double toDegrees(double r)
+{
+    return r * 180 / PI;
+}
+
+// GeoCoord structs/classes
+// A struct to hold the data for a DMS coordinate.
+struct DMS
+{
+    uint8_t latDeg;
+    uint8_t latMin;
+    uint32_t latSec;
+    char latCP;
+    uint8_t lonDeg;
+    uint8_t lonMin;
+    uint32_t lonSec;
+    char lonCP;
+};
+
+// A struct to hold the data for a UTM coordinate, this is also used when creating an MGRS coordinate.
+struct UTM 
+{
+    uint8_t zone;
+    char band;
+    uint32_t easting;
+    uint32_t northing;
+};
+
+// A struct to hold the data for a MGRS coordinate.
+struct MGRS
+{
+    uint8_t zone;
+    char band;
+    char east100k;
+    char north100k;
+    uint32_t easting;
+    uint32_t northing;
+};
+
+// A struct to hold the data for a OSGR coordiante
+struct OSGR {
+    char e100k;
+    char n100k;
+    uint32_t easting;
+    uint32_t northing;
+};
+
+// A struct to hold the data for a OLC coordinate
+struct OLC {
+    char code[OLC_CODE_LEN + 1]; // +1 for null termination
+};
+
+class GeoCoord {
+    private:
+        int32_t _latitude = 0;
+        int32_t _longitude = 0;
+        int32_t _altitude = 0;
+
+        DMS _dms;
+        UTM _utm;
+        MGRS _mgrs;
+        OSGR _osgr;
+        OLC _olc;
+
+        bool _dirty = true;
+
+        void setCoords();
+
+    public:
+        GeoCoord();
+        GeoCoord(int32_t lat, int32_t lon, int32_t alt);
+        GeoCoord(double lat, double lon, int32_t alt);
+        GeoCoord(float lat, float lon, int32_t alt);
+
+        void updateCoords(const int32_t lat, const int32_t lon, const int32_t alt);
+        void updateCoords(const double lat, const double lon, const int32_t alt);
+        void updateCoords(const float lat, const float lon, const int32_t alt);
+
+        // Conversions
+        static void latLongToDMS(const double lat, const double lon, DMS &dms);
+        static void latLongToUTM(const double lat, const double lon, UTM &utm);
+        static void latLongToMGRS(const double lat, const double lon, MGRS &mgrs);
+        static void latLongToOSGR(const double lat, const double lon, OSGR &osgr);
+        static void latLongToOLC(const double lat, const double lon, OLC &olc);
+        static void convertWGS84ToOSGB36(const double lat, const double lon, double &osgb_Latitude, double &osgb_Longitude);
+        static float latLongToMeter(double lat_a, double lng_a, double lat_b, double lng_b);
+        static float bearing(double lat1, double lon1, double lat2, double lon2);
+        static float rangeRadiansToMeters(double range_radians);
+        static float rangeMetersToRadians(double range_meters);
+
+        // Point to point conversions
+        int32_t distanceTo(GeoCoord pointB);
+        int32_t bearingTo(GeoCoord pointB);
+        std::shared_ptr<GeoCoord> pointAtDistance(double bearing, double range);
+
+        // Lat lon alt getters
+        int32_t getLatitude() const { return _latitude; }
+        int32_t getLongitude() const { return _longitude; }
+        int32_t getAltitude() const { return _altitude; }
+
+        // DMS getters
+        uint8_t getDMSLatDeg() const { return _dms.latDeg; }
+        uint8_t getDMSLatMin() const { return _dms.latMin; }
+        uint32_t getDMSLatSec() const { return _dms.latSec; }
+        char getDMSLatCP() const { return _dms.latCP; }
+        uint8_t getDMSLonDeg() const { return _dms.lonDeg; }
+        uint8_t getDMSLonMin() const { return _dms.lonMin; }
+        uint32_t getDMSLonSec() const { return _dms.lonSec; }
+        char getDMSLonCP() const { return _dms.lonCP; }
+
+        // UTM getters
+        uint8_t getUTMZone() const { return _utm.zone; }
+        char getUTMBand() const { return _utm.band; }
+        uint32_t getUTMEasting() const { return _utm.easting; }
+        uint32_t getUTMNorthing() const { return _utm.northing; }
+
+        // MGRS getters
+        uint8_t getMGRSZone() const { return _mgrs.zone; }
+        char getMGRSBand() const { return _mgrs.band; }
+        char getMGRSEast100k() const { return _mgrs.east100k; }
+        char getMGRSNorth100k() const { return _mgrs.north100k; }
+        uint32_t getMGRSEasting() const { return _mgrs.easting; }
+        uint32_t getMGRSNorthing() const { return _mgrs.northing; }
+
+        // OSGR getters
+        char getOSGRE100k() const { return _osgr.e100k; }
+        char getOSGRN100k() const { return _osgr.n100k; }
+        uint32_t getOSGREasting() const { return _osgr.easting; }
+        uint32_t getOSGRNorthing() const { return _osgr.northing; }
+
+        // OLC getter
+        void getOLCCode(char* code) { strncpy(code, _olc.code, OLC_CODE_LEN + 1); } // +1 for null termination
+};
+

src/gps/NMEAGPS.cpp

@@ -2,6 +2,12 @@
 #include "NMEAGPS.h"
 #include "RTC.h"
 
+#include <TinyGPS++.h>
+
+// GPS solutions older than this will be rejected - see TinyGPSDatum::age()
+#define GPS_SOL_EXPIRY_MS 300   // in millis
+#define NMEA_MSG_GXGSA "GNGSA"  // GSA message (GPGSA, GNGSA etc)
+
 static int32_t toDegInt(RawDegrees d)
 {
     int32_t degMult = 10000000; // 1e7
@@ -21,6 +27,17 @@ bool NMEAGPS::setupGPS()
     pinMode(PIN_GPS_PPS, INPUT);
 #endif
 
+// Currently disabled per issue #525 (TinyGPS++ crash bug)
+// when fixed upstream, can be un-disabled to enable 3D FixType and PDOP
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+    // see NMEAGPS.h
+    gsafixtype.begin(reader, NMEA_MSG_GXGSA, 2);
+    gsapdop.begin(reader, NMEA_MSG_GXGSA, 15);
+    DEBUG_MSG("Using " NMEA_MSG_GXGSA " for 3DFIX and PDOP\n");
+#else
+    DEBUG_MSG("GxGSA NOT available\n");
+#endif
+
     return true;
 }
 
@@ -48,7 +65,7 @@ The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of s
         t.tm_year = d.year() - 1900;
         t.tm_isdst = false;
         DEBUG_MSG("NMEA GPS time %d\n", t.tm_sec);
-        
+
         perhapsSetRTC(RTCQualityGPS, t);
 
         return true;
@@ -64,47 +81,122 @@ The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of s
  */
 bool NMEAGPS::lookForLocation()
 {
-    bool foundLocation = false;
+    // By default, TinyGPS++ does not parse GPGSA lines, which give us 
+    //   the 2D/3D fixType (see NMEAGPS.h)
+    // At a minimum, use the fixQuality indicator in GPGGA (FIXME?)
+    fixQual = reader.fixQuality();
 
-    // uint8_t fixtype = reader.fixQuality();
-    // hasValidLocation = ((fixtype >= 1) && (fixtype <= 5));
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+    fixType = atoi(gsafixtype.value());  // will set to zero if no data
+    DEBUG_MSG("FIX QUAL=%d, TYPE=%d\n", fixQual, fixType);
+#endif
 
+    // check if GPS has an acceptable lock
+    if (! hasLock())
+        return false;
+
+    // check if a complete GPS solution set is available for reading
+    //   tinyGPSDatum::age() also includes isValid() test
+    // FIXME
+    if (! ((reader.location.age() < GPS_SOL_EXPIRY_MS) &&
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+            (gsafixtype.age() < GPS_SOL_EXPIRY_MS) &&
+#endif
+            (reader.time.age() < GPS_SOL_EXPIRY_MS) &&
+            (reader.date.age() < GPS_SOL_EXPIRY_MS)))
+    {
+        // DEBUG_MSG("SOME data is TOO OLD\n");
+        return false;
+    }
+
+    // Is this a new point or are we re-reading the previous one?
+    if (! reader.location.isUpdated())
+        return false;
+
+    // Start reading the data
+    auto loc = reader.location.value();
+
+    // Some GPSes (Air530) seem to send a zero longitude when the current fix is bogus
+    // Bail out EARLY to avoid overwriting previous good data (like #857)
+    if(toDegInt(loc.lat) == 0) {
+        DEBUG_MSG("Ignoring bogus NMEA position\n");
+        return false;
+    }
+
+    // Dilution of precision (an accuracy metric) is reported in 10^2 units, so we need to scale down when we use it
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+    dop = TinyGPSPlus::parseDecimal(gsapdop.value());
+#else
+    // FIXME! naive PDOP emulation (assumes VDOP==HDOP)
+    // correct formula is PDOP = SQRT(HDOP^2 + VDOP^2)
+    dop = 1.41 * reader.hdop.value();
+#endif
+
+    // Discard incomplete or erroneous readings
+    if (dop == 0)
+        return false;
+
+    latitude = toDegInt(loc.lat);
+    longitude = toDegInt(loc.lng);
+
+    geoidal_height = reader.geoidHeight.meters();
+#ifdef GPS_ALTITUDE_HAE
+    altitude = reader.altitude.meters() + geoidal_height;
+#else
+    altitude = reader.altitude.meters();
+#endif
+
+    // positional timestamp
+    struct tm t;
+    t.tm_sec = reader.time.second();
+    t.tm_min = reader.time.minute();
+    t.tm_hour = reader.time.hour();
+    t.tm_mday = reader.date.day();
+    t.tm_mon = reader.date.month() - 1;
+    t.tm_year = reader.date.year() - 1900;
+    t.tm_isdst = false;
+    pos_timestamp = mktime(&t);
+
+    // Nice to have, if available
     if (reader.satellites.isUpdated()) {
         setNumSatellites(reader.satellites.value());
     }
 
-    // Diminution of precision (an accuracy metric) is reported in 10^2 units, so we need to scale down when we use it
-    if (reader.hdop.isUpdated()) {
-        dop = reader.hdop.value();
-    }
-    if (reader.course.isUpdated()) {
-        heading = reader.course.value() * 1e3; // Scale the heading (in degrees * 10^-2) to match the expected degrees * 10^-5
-    }
-
-    if (reader.altitude.isUpdated())
-        altitude = reader.altitude.meters();
-
-    if (reader.location.isUpdated()) {
-
-        auto loc = reader.location.value();
-        latitude = toDegInt(loc.lat);
-        longitude = toDegInt(loc.lng);
-
-        // Some GPSes (Air530) seem to send a zero longitude when the current fix is bogus
-        if(longitude == 0)
-            DEBUG_MSG("Ignoring bogus NMEA position\n");
-        else {
-            foundLocation = true;
-
-            // expect gps pos lat=37.520825, lon=-122.309162, alt=158
-            DEBUG_MSG("new NMEA GPS pos lat=%f, lon=%f, alt=%d, hdop=%g, heading=%f\n", latitude * 1e-7, longitude * 1e-7, altitude,
-                    dop * 1e-2, heading * 1e-5);
+    if (reader.course.isUpdated() && reader.course.isValid()) {
+        if (reader.course.value() < 36000) {  // sanity check
+            heading = reader.course.value() * 1e3; // Scale the heading (in degrees * 10^-2) to match the expected degrees * 10^-5
+        } else {
+            DEBUG_MSG("BOGUS course.value() REJECTED: %d\n",
+                        reader.course.value());
         }
     }
 
-    return foundLocation;
+/*
+    // REDUNDANT?
+    // expect gps pos lat=37.520825, lon=-122.309162, alt=158
+    DEBUG_MSG("new NMEA GPS pos lat=%f, lon=%f, alt=%d, dop=%g, heading=%f\n",
+              latitude * 1e-7, longitude * 1e-7, altitude, dop * 1e-2,
+              heading * 1e-5);
+*/
+    return true;
 }
 
+
+bool NMEAGPS::hasLock()
+{
+    // Using GPGGA fix quality indicator
+    if (fixQual >= 1 && fixQual <= 5) {
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+        // Use GPGSA fix type 2D/3D (better) if available
+        if (fixType == 3 || fixType == 0)  // zero means "no data received"
+#endif
+            return true;
+    }
+
+    return false;
+}
+
+
 bool NMEAGPS::whileIdle()
 {
     bool isValid = false;

src/gps/NMEAGPS.h

@@ -12,6 +12,15 @@
 class NMEAGPS : public GPS
 {
     TinyGPSPlus reader;
+    uint8_t fixQual = 0;  // fix quality from GPGGA
+
+#ifndef TINYGPS_OPTION_NO_CUSTOM_FIELDS
+    // (20210908) TinyGps++ can only read the GPGSA "FIX TYPE" field
+    // via optional feature "custom fields", currently disabled (bug #525)
+    TinyGPSCustom gsafixtype;  // custom extract fix type from GPGSA
+    TinyGPSCustom gsapdop;     // custom extract PDOP from GPGSA
+    uint8_t fixType = 0;  // fix type from GPGSA
+#endif
 
   public:
     virtual bool setupGPS();
@@ -38,4 +47,6 @@ class NMEAGPS : public GPS
      * @return true if we've acquired a new location
      */
     virtual bool lookForLocation();
+
+    virtual bool hasLock();
 };

src/gps/UBloxGPS.cpp

@@ -5,6 +5,13 @@
 #include "sleep.h"
 #include <assert.h>
 
+// if gps_update_interval below this value, do not powercycle the GPS
+#define UBLOX_POWEROFF_THRESHOLD 90
+
+#define PDOP_INVALID 9999
+
+extern RadioConfig radioConfig;
+
 UBloxGPS::UBloxGPS() {}
 
 bool UBloxGPS::tryConnect()
@@ -111,19 +118,18 @@ bool UBloxGPS::factoryReset()
 /** Idle processing while GPS is looking for lock */
 void UBloxGPS::whileActive()
 {
+    ublox.flushPVT();  // reset ALL freshness flags first
+
     ublox.getT(maxWait()); // ask for new time data - hopefully ready when we come back
 
     // Ask for a new position fix - hopefully it will have results ready by next time
     // the order here is important, because we only check for has latitude when reading
-    ublox.getSIV(maxWait());
-    ublox.getPDOP(maxWait());
-    ublox.getP(maxWait());
 
-    // Update fixtype
-    if (ublox.moduleQueried.fixType) {
-        fixType = ublox.getFixType(0);
-        // DEBUG_MSG("GPS fix type %d, numSats %d\n", fixType, numSatellites);
-    }
+    //ublox.getSIV(maxWait());  // redundant with getPDOP below
+    ublox.getPDOP(maxWait());  // will trigger getSOL on NEO6, getP on others
+    ublox.getP(maxWait());     // will trigger getPosLLH on NEO6, getP on others
+
+    // the fixType flag will be checked and updated in lookForLocation()
 }
 
 /**
@@ -164,33 +170,88 @@ bool UBloxGPS::lookForLocation()
 {
     bool foundLocation = false;
 
-    if (ublox.moduleQueried.SIV)
-        setNumSatellites(ublox.getSIV(0));
+    // catch fixType changes here, instead of whileActive()
+    if (ublox.moduleQueried.fixType) {
+        fixType = ublox.getFixType();
+    }
 
-    if (ublox.moduleQueried.pDOP)
-        dop = ublox.getPDOP(0); // PDOP (an accuracy metric) is reported in 10^2 units so we have to scale down when we use it
+    // check if GPS has an acceptable lock
+    if (! hasLock()) {
+        return false;
+    }
 
-    // we only notify if position has changed due to a new fix
-    if ((fixType >= 3 && fixType <= 4)) {
-        if (ublox.moduleQueried.latitude) // rd fixes only
-        {
-            latitude = ublox.getLatitude(0);
-            longitude = ublox.getLongitude(0);
-            altitude = ublox.getAltitudeMSL(0) / 1000; // in mm convert to meters
+    // check if a complete GPS solution set is available for reading
+    // (some of these, like lat/lon are redundant and can be removed)
+    if ( ! (ublox.moduleQueried.latitude && 
+            ublox.moduleQueried.longitude &&
+            ublox.moduleQueried.altitude &&
+            ublox.moduleQueried.pDOP &&
+            ublox.moduleQueried.gpsiTOW)) 
+    {
+        // Not ready? No problem! We'll try again later.
+        return false;
+    }
 
-            // Note: heading is only currently implmented in the ublox for the 8m chipset - therefore
-            // don't read it here - it will generate an ignored getPVT command on the 6ms
-            // heading = ublox.getHeading(0);
+    // read lat/lon/alt/dop data into temporary variables to avoid
+    // overwriting global variables with potentially invalid data
+    int32_t tmp_dop = ublox.getPDOP(0); // PDOP (an accuracy metric) is reported in 10^2 units so we have to scale down when we use it
+    int32_t tmp_lat = ublox.getLatitude(0);
+    int32_t tmp_lon = ublox.getLongitude(0);
+    int32_t tmp_alt_msl = ublox.getAltitudeMSL(0);
+    int32_t tmp_alt_hae = ublox.getAltitude(0);
+    // Note: heading is only currently implmented in the ublox for the 8m chipset - therefore
+    // don't read it here - it will generate an ignored getPVT command on the 6ms
+    // heading = ublox.getHeading(0);
 
-            // bogus lat lon is reported as 0 or 0 (can be bogus just for one)
-            // Also: apparently when the GPS is initially reporting lock it can output a bogus latitude > 90 deg!
-            foundLocation = (latitude != 0) && (longitude != 0) && (latitude <= 900000000 && latitude >= -900000000);
-        }
+    // read positional timestamp
+    struct tm t;
+    t.tm_sec = ublox.getSecond(0);
+    t.tm_min = ublox.getMinute(0);
+    t.tm_hour = ublox.getHour(0);
+    t.tm_mday = ublox.getDay(0);
+    t.tm_mon = ublox.getMonth(0) - 1;
+    t.tm_year = ublox.getYear(0) - 1900;
+    t.tm_isdst = false;
+
+    time_t tmp_ts = mktime(&t);
+
+    // SIV number is nice-to-have if it's available
+    if (ublox.moduleQueried.SIV) {
+        uint16_t gSIV = ublox.getSIV(0);
+        setNumSatellites(gSIV);
+    }
+
+    // bogus lat lon is reported as 0 or 0 (can be bogus just for one)
+    // Also: apparently when the GPS is initially reporting lock it can output a bogus latitude > 90 deg!
+    // FIXME - NULL ISLAND is a real location on Earth!
+    foundLocation = (tmp_lat != 0) && (tmp_lon != 0) && 
+                    (tmp_lat <= 900000000) && (tmp_lat >= -900000000) &&
+                    (tmp_dop < PDOP_INVALID);
+
+    // only if entire dataset is valid, update globals from temp vars
+    if (foundLocation) {
+        longitude = tmp_lon;
+        latitude = tmp_lat;
+#ifdef GPS_ALTITUDE_HAE
+        altitude = tmp_alt_hae / 1000;
+#else
+        altitude = tmp_alt_msl / 1000;
+#endif
+        geoidal_height = (tmp_alt_hae - tmp_alt_msl) / 1000;
+        pos_timestamp = tmp_ts;
+        dop = tmp_dop;
+    } else {
+        DEBUG_MSG("Invalid location discarded\n");
     }
 
     return foundLocation;
 }
 
+bool UBloxGPS::hasLock()
+{
+    return (fixType >= 3 && fixType <= 4);
+}
+
 bool UBloxGPS::whileIdle()
 {
     // if using i2c or serial look too see if any chars are ready
@@ -201,15 +262,20 @@ bool UBloxGPS::whileIdle()
 /// Note: ublox doesn't need a wake method, because as soon as we send chars to the GPS it will wake up
 void UBloxGPS::sleep()
 {
-    // Tell GPS to power down until we send it characters on serial port (we leave vcc connected)
-    ublox.powerOff();
-    // setGPSPower(false);
+    if (radioConfig.preferences.gps_update_interval > UBLOX_POWEROFF_THRESHOLD) {
+        // Tell GPS to power down until we send it characters on serial port (we leave vcc connected)
+        ublox.powerOff();
+        // setGPSPower(false);
+    }
 }
 
 void UBloxGPS::wake()
 {
-    fixType = 0; // assume we hace no fix yet
+    if (radioConfig.preferences.gps_update_interval > UBLOX_POWEROFF_THRESHOLD) {
+        fixType = 0; // assume we have no fix yet
+    }
 
+    // this is idempotent
     setGPSPower(true);
 
     // Note: no delay needed because now we leave gps power on always and instead use ublox.powerOff()

src/gps/UBloxGPS.h

@@ -54,6 +54,7 @@ class UBloxGPS : public GPS
      * @return true if we've acquired a new location
      */
     virtual bool lookForLocation();
+    virtual bool hasLock();
 
     /// If possible force the GPS into sleep/low power mode
     virtual void sleep();

src/graphics/Screen.cpp

@@ -35,6 +35,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "plugins/TextMessagePlugin.h"
 #include "target_specific.h"
 #include "utils.h"
+#include "gps/GeoCoord.h"
 
 #ifndef NO_ESP32
 #include "mesh/http/WiFiAPClient.h"
@@ -72,6 +73,9 @@ std::vector<MeshPlugin *> pluginFrames;
 // Stores the last 4 of our hardware ID, to make finding the device for pairing easier
 static char ourId[5];
 
+// GeoCoord object for the screen
+GeoCoord geoCoord;
+
 #ifdef SHOW_REDRAWS
 static bool heartbeat = false;
 #endif
@@ -333,6 +337,11 @@ static void drawNodes(OLEDDisplay *display, int16_t x, int16_t y, NodeStatus *no
 // Draw GPS status summary
 static void drawGPS(OLEDDisplay *display, int16_t x, int16_t y, const GPSStatus *gps)
 {
+    if (radioConfig.preferences.fixed_position) {
+        // GPS coordinates are currently fixed
+        display->drawString(x - 1, y - 2, "Fixed GPS");
+        return;
+    }
     if (!gps->getIsConnected()) {
         display->drawString(x, y - 2, "No GPS");
         return;
@@ -367,15 +376,15 @@ static void drawGPS(OLEDDisplay *display, int16_t x, int16_t y, const GPSStatus
 static void drawGPSAltitude(OLEDDisplay *display, int16_t x, int16_t y, const GPSStatus *gps)
 {
     String displayLine = "";
-    if (!gps->getIsConnected()) {
+    if (!gps->getIsConnected() && !radioConfig.preferences.fixed_position) {
         // displayLine = "No GPS Module";
         // display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(displayLine))) / 2, y, displayLine);
-    } else if (!gps->getHasLock()) {
+    } else if (!gps->getHasLock() && !radioConfig.preferences.fixed_position) {
         // displayLine = "No GPS Lock";
         // display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(displayLine))) / 2, y, displayLine);
     } else {
-
-        displayLine = "Altitude: " + String(gps->getAltitude()) + "m";
+        geoCoord.updateCoords(int32_t(gps->getLatitude()), int32_t(gps->getLongitude()), int32_t(gps->getAltitude()));
+        displayLine = "Altitude: " + String(geoCoord.getAltitude()) + "m";
         display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(displayLine))) / 2, y, displayLine);
     }
 }
@@ -383,76 +392,51 @@ static void drawGPSAltitude(OLEDDisplay *display, int16_t x, int16_t y, const GP
 // Draw GPS status coordinates
 static void drawGPScoordinates(OLEDDisplay *display, int16_t x, int16_t y, const GPSStatus *gps)
 {
+    auto gpsFormat = radioConfig.preferences.gps_format;
     String displayLine = "";
-    if (!gps->getIsConnected()) {
+
+    if (!gps->getIsConnected() && !radioConfig.preferences.fixed_position) {
         displayLine = "No GPS Module";
         display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(displayLine))) / 2, y, displayLine);
-    } else if (!gps->getHasLock()) {
+    } else if (!gps->getHasLock() && !radioConfig.preferences.fixed_position) {
         displayLine = "No GPS Lock";
         display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(displayLine))) / 2, y, displayLine);
     } else {
-        char coordinateLine[22];
-        sprintf(coordinateLine, "%f %f", gps->getLatitude() * 1e-7, gps->getLongitude() * 1e-7);
-        display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(coordinateLine))) / 2, y, coordinateLine);
+        if (gpsFormat != GpsCoordinateFormat_GpsFormatDMS) {
+            char coordinateLine[22];
+            geoCoord.updateCoords(int32_t(gps->getLatitude()), int32_t(gps->getLongitude()), int32_t(gps->getAltitude()));
+            if (gpsFormat == GpsCoordinateFormat_GpsFormatDec) { // Decimal Degrees
+                sprintf(coordinateLine, "%f %f", geoCoord.getLatitude() * 1e-7, geoCoord.getLongitude() * 1e-7);
+            } else if (gpsFormat == GpsCoordinateFormat_GpsFormatUTM) { // Universal Transverse Mercator
+                sprintf(coordinateLine, "%2i%1c %06i %07i", geoCoord.getUTMZone(), geoCoord.getUTMBand(),
+                        geoCoord.getUTMEasting(), geoCoord.getUTMNorthing());
+            } else if (gpsFormat == GpsCoordinateFormat_GpsFormatMGRS) { // Military Grid Reference System
+                sprintf(coordinateLine, "%2i%1c %1c%1c %05i %05i", geoCoord.getMGRSZone(), geoCoord.getMGRSBand(), geoCoord.getMGRSEast100k(),
+                        geoCoord.getMGRSNorth100k(), geoCoord.getMGRSEasting(), geoCoord.getMGRSNorthing());
+            } else if (gpsFormat == GpsCoordinateFormat_GpsFormatOLC) { // Open Location Code
+                geoCoord.getOLCCode(coordinateLine);
+            } else if (gpsFormat == GpsCoordinateFormat_GpsFormatOSGR) { // Ordnance Survey Grid Reference
+                if (geoCoord.getOSGRE100k() == 'I' || geoCoord.getOSGRN100k() == 'I') // OSGR is only valid around the UK region
+                    sprintf(coordinateLine, "%s", "Out of Boundary");
+                else
+                    sprintf(coordinateLine, "%1c%1c %05i %05i", geoCoord.getOSGRE100k(),geoCoord.getOSGRN100k(), 
+                            geoCoord.getOSGREasting(), geoCoord.getOSGRNorthing());
+            }
+            
+            display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(coordinateLine))) / 2, y, coordinateLine);
+        } else {
+            char latLine[22];
+            char lonLine[22];
+            sprintf(latLine, "%2i° %2i' %2.4f\" %1c", geoCoord.getDMSLatDeg(), geoCoord.getDMSLatMin(), geoCoord.getDMSLatSec(),
+                    geoCoord.getDMSLatCP());
+            sprintf(lonLine, "%3i° %2i' %2.4f\" %1c", geoCoord.getDMSLonDeg(), geoCoord.getDMSLonMin(), geoCoord.getDMSLonSec(), 
+                    geoCoord.getDMSLonCP());
+            display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(latLine))) / 2, y - FONT_HEIGHT_SMALL * 1, latLine);
+            display->drawString(x + (SCREEN_WIDTH - (display->getStringWidth(lonLine))) / 2, y, lonLine);
+        }
     }
 }
 
-/// Ported from my old java code, returns distance in meters along the globe
-/// surface (by magic?)
-static float latLongToMeter(double lat_a, double lng_a, double lat_b, double lng_b)
-{
-    double pk = (180 / 3.14169);
-    double a1 = lat_a / pk;
-    double a2 = lng_a / pk;
-    double b1 = lat_b / pk;
-    double b2 = lng_b / pk;
-    double cos_b1 = cos(b1);
-    double cos_a1 = cos(a1);
-    double t1 = cos_a1 * cos(a2) * cos_b1 * cos(b2);
-    double t2 = cos_a1 * sin(a2) * cos_b1 * sin(b2);
-    double t3 = sin(a1) * sin(b1);
-    double tt = acos(t1 + t2 + t3);
-    if (isnan(tt))
-        tt = 0.0; // Must have been the same point?
-
-    return (float)(6366000 * tt);
-}
-
-static inline double toRadians(double deg)
-{
-    return deg * PI / 180;
-}
-
-static inline double toDegrees(double r)
-{
-    return r * 180 / PI;
-}
-
-/**
- * Computes the bearing in degrees between two points on Earth.  Ported from my
- * old Gaggle android app.
- *
- * @param lat1
- * Latitude of the first point
- * @param lon1
- * Longitude of the first point
- * @param lat2
- * Latitude of the second point
- * @param lon2
- * Longitude of the second point
- * @return Bearing between the two points in radians. A value of 0 means due
- * north.
- */
-static float bearing(double lat1, double lon1, double lat2, double lon2)
-{
-    double lat1Rad = toRadians(lat1);
-    double lat2Rad = toRadians(lat2);
-    double deltaLonRad = toRadians(lon2 - lon1);
-    double y = sin(deltaLonRad) * cos(lat2Rad);
-    double x = cos(lat1Rad) * sin(lat2Rad) - (sin(lat1Rad) * cos(lat2Rad) * cos(deltaLonRad));
-    return atan2(y, x);
-}
-
 namespace
 {
 
@@ -513,11 +497,11 @@ static float estimatedHeading(double lat, double lon)
         return b;
     }
 
-    float d = latLongToMeter(oldLat, oldLon, lat, lon);
+    float d = GeoCoord::latLongToMeter(oldLat, oldLon, lat, lon);
     if (d < 10) // haven't moved enough, just keep current bearing
         return b;
 
-    b = bearing(oldLat, oldLon, lat, lon);
+    b = GeoCoord::bearing(oldLat, oldLon, lat, lon);
     oldLat = lat;
     oldLon = lon;
 
@@ -637,7 +621,7 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
             // display direction toward node
             hasNodeHeading = true;
             Position &p = node->position;
-            float d = latLongToMeter(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
+            float d = GeoCoord::latLongToMeter(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
             if (d < 2000)
                 snprintf(distStr, sizeof(distStr), "%.0f m", d);
             else
@@ -645,7 +629,7 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
 
             // FIXME, also keep the guess at the operators heading and add/substract
             // it.  currently we don't do this and instead draw north up only.
-            float bearingToOther = bearing(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
+            float bearingToOther = GeoCoord::bearing(DegD(p.latitude_i), DegD(p.longitude_i), DegD(op.latitude_i), DegD(op.longitude_i));
             headingRadian = bearingToOther - myHeading;
             drawNodeHeading(display, compassX, compassY, headingRadian);
         }
@@ -946,7 +930,9 @@ void Screen::setFrames()
         normalFrames[numframes++] = drawTextMessageFrame;
 
     // then all the nodes
-    for (size_t i = 0; i < numnodes; i++)
+    // We only show a few nodes in our scrolling list - because meshes with many nodes would have too many screens
+    size_t numToShow = min(numnodes, 4U);
+    for (size_t i = 0; i < numToShow; i++)
         normalFrames[numframes++] = drawNodeInfo;
 
     // then the debug info
@@ -1328,7 +1314,8 @@ void DebugInfo::drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *stat
 #endif
 
     // Line 3
-    drawGPSAltitude(display, x, y + FONT_HEIGHT_SMALL * 2, gpsStatus);
+    if (radioConfig.preferences.gps_format != GpsCoordinateFormat_GpsFormatDMS) // if DMS then don't draw altitude
+        drawGPSAltitude(display, x, y + FONT_HEIGHT_SMALL * 2, gpsStatus);
 
     // Line 4
     drawGPScoordinates(display, x, y + FONT_HEIGHT_SMALL * 3, gpsStatus);

src/graphics/Screen.h

@@ -22,6 +22,8 @@ class Screen
 
 #include <OLEDDisplayUi.h>
 
+#include "../configuration.h"
+
 #ifdef USE_SH1106
 #include <SH1106Wire.h>
 #elif defined(USE_ST7567)

src/main.cpp

@@ -25,9 +25,10 @@
 #include <Wire.h>
 // #include <driver/rtc_io.h>
 
+#include "mesh/http/WiFiAPClient.h"
+
 #ifndef NO_ESP32
 #include "mesh/http/WebServer.h"
-#include "mesh/http/WiFiAPClient.h"
 #include "nimble/BluetoothUtil.h"
 #endif
 
@@ -38,6 +39,7 @@
 
 #include "RF95Interface.h"
 #include "SX1262Interface.h"
+#include "SX1268Interface.h"
 
 #ifdef NRF52_SERIES
 #include "variant.h"
@@ -337,9 +339,10 @@ void setup()
     digitalWrite(RESET_OLED, 1);
 #endif
 
+    bool forceSoftAP = 0;
+
 #ifdef BUTTON_PIN
 #ifndef NO_ESP32
-    bool forceSoftAP = 0;
 
     // If the button is connected to GPIO 12, don't enable the ability to use
     // meshtasticAdmin on the device.
@@ -489,10 +492,10 @@ void setup()
         }
     }
 
-#ifdef SX1262_ANT_SW
-    // make analog PA vs not PA switch on SX1262 eval board work properly
-    pinMode(SX1262_ANT_SW, OUTPUT);
-    digitalWrite(SX1262_ANT_SW, 1);
+#ifdef SX126X_ANT_SW
+    // make analog PA vs not PA switch on SX126x eval board work properly
+    pinMode(SX126X_ANT_SW, OUTPUT);
+    digitalWrite(SX126X_ANT_SW, 1);
 #endif
 
     // radio init MUST BE AFTER service.init, so we have our radio config settings (from nodedb init)
@@ -510,9 +513,9 @@ void setup()
     }
 #endif
 
-#if defined(SX1262_CS)
+#if defined(USE_SX1262)
     if (!rIf) {
-        rIf = new SX1262Interface(SX1262_CS, SX1262_DIO1, SX1262_RESET, SX1262_BUSY, SPI);
+        rIf = new SX1262Interface(SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY, SPI);
         if (!rIf->init()) {
             DEBUG_MSG("Warning: Failed to find SX1262 radio\n");
             delete rIf;
@@ -523,6 +526,19 @@ void setup()
     }
 #endif
 
+#if defined(USE_SX1268)
+    if (!rIf) {
+        rIf = new SX1268Interface(SX126X_CS, SX126X_DIO1, SX126X_RESET, SX126X_BUSY, SPI);
+        if (!rIf->init()) {
+            DEBUG_MSG("Warning: Failed to find SX1268 radio\n");
+            delete rIf;
+            rIf = NULL;
+        } else {
+            DEBUG_MSG("SX1268 Radio init succeeded, using SX1268 radio\n");
+        }
+    }
+#endif
+
 #ifdef USE_SIM_RADIO
     if (!rIf) {
         rIf = new SimRadio;
@@ -536,10 +552,14 @@ void setup()
     }
 #endif
 
-#ifndef NO_ESP32
+#if defined(PORTDUINO) || defined(HAS_WIFI)
+    mqttInit();
+#endif
+
     // Initialize Wifi
     initWifi(forceSoftAP);
 
+#ifndef NO_ESP32
     // Start web server thread.
     webServerThread = new WebServerThread();
 #endif
@@ -548,10 +568,6 @@ void setup()
     initApiServer();
 #endif
 
-#if defined(PORTDUINO) || defined(HAS_WIFI)
-    mqttInit();
-#endif
-
     // Start airtime logger thread.
     airTime = new AirTime();
 
@@ -646,7 +662,9 @@ void loop()
                   mainController.nextThread->tillRun(millis())); */
 
     // We want to sleep as long as possible here - because it saves power
-    if (!runASAP && loopCanSleep())
+    if (!runASAP && loopCanSleep()) {
+        // if(delayMsec > 100) DEBUG_MSG("sleeping %ld\n", delayMsec);
         mainDelay.delay(delayMsec);
+    }
     // if (didWake) DEBUG_MSG("wake!\n");
 }

src/mesh/CryptoEngine.cpp

@@ -32,6 +32,10 @@ void CryptoEngine::decrypt(uint32_t fromNode, uint64_t packetNum, size_t numByte
 void CryptoEngine::initNonce(uint32_t fromNode, uint64_t packetNum)
 {
     memset(nonce, 0, sizeof(nonce));
-    *((uint64_t *)&nonce[0]) = packetNum;
-    *((uint32_t *)&nonce[8]) = fromNode;
+
+    // use memcpy to avoid breaking strict-aliasing
+    memcpy(nonce, &packetNum, sizeof(uint64_t));
+    memcpy(nonce + sizeof(uint64_t), &fromNode, sizeof(uint32_t));
+    //*((uint64_t *)&nonce[0]) = packetNum;
+    //*((uint32_t *)&nonce[8]) = fromNode;
 }

src/mesh/InterfacesTemplates.cpp

@@ -0,0 +1,6 @@
+#include "SX126xInterface.h"
+#include "SX126xInterface.cpp"
+
+// We need this declaration for proper linking in derived classes
+template class SX126xInterface<SX1262>;
+template class SX126xInterface<SX1268>;

src/mesh/MeshPacketQueue.cpp

@@ -4,14 +4,14 @@
 #include <algorithm>
 
 /// @return the priority of the specified packet
-inline uint32_t getPriority(MeshPacket *p)
+inline uint32_t getPriority(const MeshPacket *p)
 {
     auto pri = p->priority;
     return pri;
 }
 
 /// @return "true" if "p1" is ordered before "p2"
-bool CompareMeshPacket::operator()(MeshPacket *p1, MeshPacket *p2)
+bool CompareMeshPacketFunc(const MeshPacket *p1, const MeshPacket *p2)
 {
     assert(p1 && p2);
     auto p1p = getPriority(p1), p2p = getPriority(p2);
@@ -25,7 +25,12 @@ bool CompareMeshPacket::operator()(MeshPacket *p1, MeshPacket *p2)
 
 MeshPacketQueue::MeshPacketQueue(size_t _maxLen) : maxLen(_maxLen) {}
 
-/** Some clients might not properly set priority, therefore we fix it here.
+bool MeshPacketQueue::empty() {
+    return queue.empty();
+}
+
+/**
+ * Some clients might not properly set priority, therefore we fix it here.
  */
 void fixPriority(MeshPacket *p)
 {
@@ -34,7 +39,7 @@ void fixPriority(MeshPacket *p)
     if (p->priority == MeshPacket_Priority_UNSET) {
         // if acks give high priority
         // if a reliable message give a bit higher default priority
-        p->priority = (p->decoded.portnum == PortNum_ROUTING_APP) ? MeshPacket_Priority_ACK :                
+        p->priority = (p->decoded.portnum == PortNum_ROUTING_APP) ? MeshPacket_Priority_ACK :
                           (p->want_ack ? MeshPacket_Priority_RELIABLE : MeshPacket_Priority_DEFAULT);
     }
 }
@@ -42,51 +47,70 @@ void fixPriority(MeshPacket *p)
 /** enqueue a packet, return false if full */
 bool MeshPacketQueue::enqueue(MeshPacket *p)
 {
-
     fixPriority(p);
 
-    // fixme if there is something lower priority in the queue that can be deleted to make space, delete that instead
-    if (size() >= maxLen)
-        return false;
-    else {
-        push(p);
-        return true;
+    // no space - try to replace a lower priority packet in the queue
+    if (queue.size() >= maxLen) {
+        return replaceLowerPriorityPacket(p);
     }
+
+    queue.push_back(p);
+    std::push_heap(queue.begin(), queue.end(), &CompareMeshPacketFunc);
+    return true;
 }
 
 MeshPacket *MeshPacketQueue::dequeue()
 {
-    if (empty())
+    if (empty()) {
         return NULL;
-    else {
-        auto p = top();
-        pop(); // remove the first item
-        return p;
     }
+
+    auto *p = queue.front();
+    std::pop_heap(queue.begin(), queue.end(), &CompareMeshPacketFunc);
+    queue.pop_back();
+
+    return p;
 }
 
-// this is kinda yucky, but I'm not sure if all arduino c++ compilers support closuers.  And we only have one
-// thread that can run at a time - so safe
-static NodeNum findFrom;
-static PacketId findId;
-
-static bool isMyPacket(MeshPacket *p)
-{
-    return p->id == findId && getFrom(p) == findFrom;
-}
-
-/** Attempt to find and remove a packet from this queue.  Returns true the packet which was removed from the queue */
+/** Attempt to find and remove a packet from this queue.  Returns a pointer to the removed packet, or NULL if not found */
 MeshPacket *MeshPacketQueue::remove(NodeNum from, PacketId id)
 {
-    findFrom = from;
-    findId = id;
-    auto it = std::find_if(this->c.begin(), this->c.end(), isMyPacket);
-    if (it != this->c.end()) {
-        auto p = *it;
-        this->c.erase(it);
-        std::make_heap(this->c.begin(), this->c.end(), this->comp);
-        return p;
-    } else {
-        return NULL;
+    for (auto it = queue.begin(); it != queue.end(); it++) {
+        auto p = (*it);
+        if (getFrom(p) == from && p->id == id) {
+            queue.erase(it);
+            std::make_heap(queue.begin(), queue.end(), &CompareMeshPacketFunc);
+            return p;
+        }
     }
+
+    return NULL;
+}
+
+/** Attempt to find and remove a packet from this queue.  Returns the packet which was removed from the queue */
+bool MeshPacketQueue::replaceLowerPriorityPacket(MeshPacket *p) {
+    std::sort_heap(queue.begin(), queue.end(), &CompareMeshPacketFunc); // sort ascending based on priority (0 -> 127)
+
+    // find first packet which does not compare less (in priority) than parameter packet
+    auto low = std::lower_bound(queue.begin(), queue.end(), p, &CompareMeshPacketFunc);
+
+    if (low == queue.begin()) { // if already at start, there are no packets with lower priority
+        return false;
+    }
+
+    if (low == queue.end()) {
+        // all priorities in the vector are smaller than the incoming packet. Replace the lowest priority (first) element
+        low = queue.begin();
+    } else {
+        // 'low' iterator points to first packet which does not compare less than parameter
+        --low; // iterate to lower priority packet
+    }
+
+    if (getPriority(p) > getPriority(*low)) {
+        packetPool.release(*low); // deallocate and drop the packet we're replacing
+        *low = p; // replace low-pri packet at this position with incoming packet with higher priority
+    }
+
+    std::make_heap(queue.begin(), queue.end(), &CompareMeshPacketFunc);
+    return true;
 }

src/mesh/MeshPacketQueue.h

@@ -5,29 +5,29 @@
 #include <assert.h>
 #include <queue>
 
-// this is an strucure which implements the
-// operator overloading
-struct CompareMeshPacket {
-    bool operator()(MeshPacket *p1, MeshPacket *p2);
-};
 
 /**
- * A priority queue of packets.
- *
+ * A priority queue of packets
  */
-class MeshPacketQueue : public std::priority_queue<MeshPacket *, std::vector<MeshPacket *>, CompareMeshPacket>
+class MeshPacketQueue
 {
     size_t maxLen;
+    std::vector<MeshPacket *> queue;
+
+    /** Replace a lower priority package in the queue with 'mp' (provided there are lower pri packages). Return true if replaced. */
+    bool replaceLowerPriorityPacket(MeshPacket *mp);
+
   public:
     MeshPacketQueue(size_t _maxLen);
 
     /** enqueue a packet, return false if full */
     bool enqueue(MeshPacket *p);
 
-    // bool isEmpty();
+    /** return true if the queue is empty */
+    bool empty();
 
     MeshPacket *dequeue();
 
-    /** Attempt to find and remove a packet from this queue.  Returns true the packet which was removed from the queue */
+    /** Attempt to find and remove a packet from this queue.  Returns the packet which was removed from the queue */
     MeshPacket *remove(NodeNum from, PacketId id);
 };

src/mesh/MeshPlugin.cpp

@@ -66,7 +66,7 @@ MeshPacket *MeshPlugin::allocErrorResponse(Routing_Error err, const MeshPacket *
     return r;
 }
 
-void MeshPlugin::callPlugins(const MeshPacket &mp)
+void MeshPlugin::callPlugins(const MeshPacket &mp, RxSource src)
 {
     // DEBUG_MSG("In call plugins\n");
     bool pluginFound = false;
@@ -79,6 +79,7 @@ void MeshPlugin::callPlugins(const MeshPacket &mp)
     // Was this message directed to us specifically?  Will be false if we are sniffing someone elses packets
     auto ourNodeNum = nodeDB.getNodeNum();
     bool toUs = mp.to == NODENUM_BROADCAST || mp.to == ourNodeNum;
+
     for (auto i = plugins->begin(); i != plugins->end(); ++i) {
         auto &pi = **i;
 
@@ -87,6 +88,11 @@ void MeshPlugin::callPlugins(const MeshPacket &mp)
         /// We only call plugins that are interested in the packet (and the message is destined to us or we are promiscious)
         bool wantsPacket = (isDecoded || pi.encryptedOk) && (pi.isPromiscuous || toUs) && pi.wantPacket(&mp);
 
+        if ((src == RX_SRC_LOCAL) && !(pi.loopbackOk)) {
+            // new case, monitor separately for now, then FIXME merge above
+            wantsPacket = false;
+        }
+
         assert(!pi.myReply); // If it is !null it means we have a bug, because it should have been sent the previous time
 
         if (wantsPacket) {
@@ -116,7 +122,7 @@ void MeshPlugin::callPlugins(const MeshPacket &mp)
                     printPacket("packet on wrong channel, but can't respond", &mp);
             } else {
 
-                bool handled = pi.handleReceived(mp);
+                ProcessMessage handled = pi.handleReceived(mp);
 
                 // Possibly send replies (but only if the message was directed to us specifically, i.e. not for promiscious
                 // sniffing) also: we only let the one plugin send a reply, once that happens, remaining plugins are not
@@ -140,7 +146,7 @@ void MeshPlugin::callPlugins(const MeshPacket &mp)
                     pi.myReply = NULL;
                 }
 
-                if (handled) {
+                if (handled == ProcessMessage::STOP) {
                     DEBUG_MSG("Plugin %s handled and skipped other processing\n", pi.name);
                     break;
                 }
@@ -169,7 +175,9 @@ void MeshPlugin::callPlugins(const MeshPacket &mp)
     }
 
     if (!pluginFound)
-        DEBUG_MSG("No plugins interested in portnum=%d\n", mp.decoded.portnum);
+        DEBUG_MSG("No plugins interested in portnum=%d, src=%s\n",
+                    mp.decoded.portnum, 
+                    (src == RX_SRC_LOCAL) ? "LOCAL":"REMOTE");
 }
 
 MeshPacket *MeshPlugin::allocReply()

src/mesh/MeshPlugin.h

@@ -9,6 +9,18 @@
 #include <OLEDDisplayUi.h>
 #endif
 
+/** handleReceived return enumeration
+ * 
+ * Use ProcessMessage::CONTINUE to allows other modules to process a message.
+ * 
+ * Use ProcessMessage::STOP to stop further message processing.
+ */
+enum class ProcessMessage
+{
+  CONTINUE = 0,
+  STOP = 1,
+};
+
 /** A baseclass for any mesh "plugin".
  *
  * A plugin allows you to add new features to meshtastic device code, without needing to know messaging details.
@@ -33,7 +45,7 @@ class MeshPlugin
 
     /** For use only by MeshService
      */
-    static void callPlugins(const MeshPacket &mp);
+    static void callPlugins(const MeshPacket &mp, RxSource src = RX_SRC_RADIO);
 
     static std::vector<MeshPlugin *> GetMeshPluginsWithUIFrames();
 #ifndef NO_SCREEN
@@ -48,6 +60,10 @@ class MeshPlugin
     */
     bool isPromiscuous = false;
 
+    /** Also receive a copy of LOCALLY GENERATED messages - most plugins should leave
+     *  this setting disabled - see issue #877 */
+    bool loopbackOk = false;
+
     /** Most plugins only understand decrypted packets.  For plugins that also want to see encrypted packets, they should set this
      * flag */
     bool encryptedOk = false;
@@ -87,9 +103,9 @@ class MeshPlugin
 
     /** Called to handle a particular incoming message
 
-    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceived(const MeshPacket &mp) { return false; }
+    virtual ProcessMessage handleReceived(const MeshPacket &mp) { return ProcessMessage::CONTINUE; }
 
     /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
      * so that subclasses can (optionally) send a response back to the original sender.

src/mesh/MeshService.cpp

@@ -66,7 +66,7 @@ void MeshService::init()
 
 int MeshService::handleFromRadio(const MeshPacket *mp)
 {
-    powerFSM.trigger(EVENT_RECEIVED_PACKET); // Possibly keep the node from sleeping
+    powerFSM.trigger(EVENT_PACKET_FOR_PHONE); // Possibly keep the node from sleeping
 
     printPacket("Forwarding to phone", mp);
     nodeDB.updateFrom(*mp); // update our DB state based off sniffing every RX packet from the radio

src/mesh/MeshTypes.h

@@ -15,6 +15,14 @@ typedef uint32_t PacketId; // A packet sequence number
 #define ERRNO_UNKNOWN 32  // pick something that doesn't conflict with RH_ROUTER_ERROR_UNABLE_TO_DELIVER
 #define ERRNO_DISABLED 34 // the itnerface is disabled
 
+/*
+ * Source of a received message
+ */
+enum RxSource {
+    RX_SRC_LOCAL,  // message was generated locally
+    RX_SRC_RADIO   // message was received from radio mesh
+};
+
 /**
  * the max number of hops a message can pass through, used as the default max for hop_limit in MeshPacket.
  *

src/mesh/PhoneAPI.h

@@ -81,6 +81,9 @@ class PhoneAPI
 
     bool isConnected() { return state != STATE_SEND_NOTHING; }
 
+    /// emit a debugging log character, FIXME - implement
+    void debugOut(char c) { }
+
   protected:
     /// Our fromradio packet while it is being assembled
     FromRadio fromRadioScratch;

src/mesh/ProtobufPlugin.h

@@ -28,7 +28,7 @@ template <class T> class ProtobufPlugin : protected SinglePortPlugin
      * In general decoded will always be !NULL.  But in some special applications (where you have handling packets
      * for multiple port numbers, decoding will ONLY be attempted for packets where the portnum matches our expected ourPortNum.
      */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const T *decoded) = 0;
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, T *decoded) = 0;
 
     /**
      * Return a mesh packet which has been preinited with a particular protobuf data payload and port number.
@@ -49,9 +49,9 @@ template <class T> class ProtobufPlugin : protected SinglePortPlugin
   private:
     /** Called to handle a particular incoming message
 
-    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceived(const MeshPacket &mp)
+    virtual ProcessMessage handleReceived(const MeshPacket &mp)
     {
         // FIXME - we currently update position data in the DB only if the message was a broadcast or destined to us
         // it would be better to update even if the message was destined to others.
@@ -70,6 +70,6 @@ template <class T> class ProtobufPlugin : protected SinglePortPlugin
                 DEBUG_MSG("Error decoding protobuf plugin!\n");
         }
 
-        return handleReceivedProtobuf(mp, decoded);
+        return handleReceivedProtobuf(mp, decoded) ? ProcessMessage::STOP : ProcessMessage::CONTINUE;
     }
 };

src/mesh/RF95Interface.cpp

@@ -67,9 +67,15 @@ bool RF95Interface::init()
 #endif
     setTransmitEnable(false);
 
-    int res = lora->begin(freq, bw, sf, cr, syncWord, power, currentLimit, preambleLength);
+    int res = lora->begin(getFreq(), bw, sf, cr, syncWord, power, currentLimit, preambleLength);
     DEBUG_MSG("RF95 init result %d\n", res);
 
+    // current limit was removed from module' ctor
+    // override default value (60 mA)
+    res = lora->setCurrentLimit(currentLimit);
+    DEBUG_MSG("Current limit set to %f\n", currentLimit);
+    DEBUG_MSG("Current limit set result %d\n", res);
+
     if (res == ERR_NONE)
         res = lora->setCRC(SX126X_LORA_CRC_ON);
 
@@ -113,7 +119,7 @@ bool RF95Interface::reconfigure()
     err = lora->setPreambleLength(preambleLength);
     assert(err == ERR_NONE);
 
-    err = lora->setFrequency(freq);
+    err = lora->setFrequency(getFreq());
     if (err != ERR_NONE)
         RECORD_CRITICALERROR(CriticalErrorCode_InvalidRadioSetting);
 

src/mesh/RadioInterface.cpp

@@ -318,18 +318,18 @@ void RadioInterface::applyModemConfig()
     // If user has manually specified a channel num, then use that, otherwise generate one by hashing the name
     const char *channelName = channels.getName(channels.getPrimaryIndex());
     int channel_num = channelSettings.channel_num ? channelSettings.channel_num - 1 : hash(channelName) % myRegion->numChannels;
-    freq = myRegion->freq + radioConfig.preferences.frequency_offset + myRegion->spacing * channel_num;
+    float freq = myRegion->freq + radioConfig.preferences.frequency_offset + myRegion->spacing * channel_num;
+
+    saveChannelNum(channel_num);
+    saveFreq(freq);
 
     DEBUG_MSG("Set radio: name=%s, config=%u, ch=%d, power=%d\n", channelName, channelSettings.modem_config, channel_num, power);
     DEBUG_MSG("Radio myRegion->freq: %f\n", myRegion->freq);
     DEBUG_MSG("Radio myRegion->spacing: %f\n", myRegion->spacing);
     DEBUG_MSG("Radio myRegion->numChannels: %d\n", myRegion->numChannels);
     DEBUG_MSG("Radio channel_num: %d\n", channel_num);
-    DEBUG_MSG("Radio frequency: %f\n", freq);
+    DEBUG_MSG("Radio frequency: %f\n", getFreq()); // the frequency could be overridden in RadioInterface::getFreq() for some modules
     DEBUG_MSG("Short packet time: %u msec\n", shortPacketMsec);
-
-    saveChannelNum(channel_num);
-    saveFreq(freq);
 }
 
 /**

src/mesh/RadioInterface.h

@@ -78,8 +78,6 @@ class RadioInterface
     void deliverToReceiver(MeshPacket *p);
 
   public:
-    float freq = 915.0;
-
     /** pool is the pool we will alloc our rx packets from
      */
     RadioInterface();
@@ -149,7 +147,7 @@ class RadioInterface
     /**
      * Get the frequency we saved.
      */
-    float getFreq();
+    virtual float getFreq();
 
     /// Some boards (1st gen Pinetab Lora module) have broken IRQ wires, so we need to poll via i2c registers
     virtual bool isIRQPending() { return false; }

src/mesh/RadioLibRF95.cpp

@@ -10,15 +10,21 @@
 
 RadioLibRF95::RadioLibRF95(Module *mod) : SX1278(mod) {}
 
-int16_t RadioLibRF95::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power, uint8_t currentLimit,
+int16_t RadioLibRF95::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power,
                             uint16_t preambleLength, uint8_t gain)
 {
     // execute common part
-    int16_t state = SX127x::begin(RF95_CHIP_VERSION, syncWord, currentLimit, preambleLength);
+    int16_t state = SX127x::begin(RF95_CHIP_VERSION, syncWord, preambleLength);
     if (state != ERR_NONE)
-        state = SX127x::begin(RF95_ALT_VERSION, syncWord, currentLimit, preambleLength);
+        state = SX127x::begin(RF95_ALT_VERSION, syncWord, preambleLength);
     RADIOLIB_ASSERT(state);
 
+    // current limit was removed from module' ctor
+    // override default value (60 mA)
+    state = setCurrentLimit(currentLimit);
+    DEBUG_MSG("Current limit set to %f\n", currentLimit);
+    DEBUG_MSG("Current limit set result %d\n", state);
+
     // configure settings not accessible by API
     state = config();
     RADIOLIB_ASSERT(state);

src/mesh/RadioLibRF95.h

@@ -35,9 +35,6 @@ class RadioLibRF95: public SX1278 {
 
       \param power Transmission output power in dBm. Allowed values range from 2 to 17 dBm.
 
-      \param currentLimit Trim value for OCP (over current protection) in mA. Can be set to multiplies of 5 in range 45 to 120 mA and to multiples of 10 in range 120 to 240 mA.
-      Set to 0 to disable OCP (not recommended).
-
       \param preambleLength Length of %LoRa transmission preamble in symbols. The actual preamble length is 4.25 symbols longer than the set number.
       Allowed values range from 6 to 65535.
 
@@ -46,7 +43,7 @@ class RadioLibRF95: public SX1278 {
 
       \returns \ref status_codes
     */
-    int16_t begin(float freq = 915.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX127X_SYNC_WORD, int8_t power = 17, uint8_t currentLimit = 100, uint16_t preambleLength = 8, uint8_t gain = 0);
+    int16_t begin(float freq = 915.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX127X_SYNC_WORD, int8_t power = 17, uint16_t preambleLength = 8, uint8_t gain = 0);
 
     // configuration methods
 
@@ -65,6 +62,11 @@ class RadioLibRF95: public SX1278 {
     /// For debugging
     uint8_t readReg(uint8_t addr); 
 
+  protected:
+    // since default current limit for SX126x/127x in updated RadioLib is 60mA
+    // use the previous value
+    float currentLimit = 100;
+
 #ifndef RADIOLIB_GODMODE
   private:
 #endif

src/mesh/Router.cpp

@@ -161,7 +161,7 @@ ErrorCode Router::sendLocal(MeshPacket *p)
         // If we are sending a broadcast, we also treat it as if we just received it ourself
         // this allows local apps (and PCs) to see broadcasts sourced locally
         if (p->to == NODENUM_BROADCAST) {
-            handleReceived(p);
+            handleReceived(p, RX_SRC_LOCAL);
         }
 
         return send(p);
@@ -324,7 +324,7 @@ NodeNum Router::getNodeNum()
  * Handle any packet that is received by an interface on this node.
  * Note: some packets may merely being passed through this node and will be forwarded elsewhere.
  */
-void Router::handleReceived(MeshPacket *p)
+void Router::handleReceived(MeshPacket *p, RxSource src)
 {
     // Also, we should set the time from the ISR and it should have msec level resolution
     p->rx_time = getValidTime(RTCQualityFromNet); // store the arrival timestamp for the phone
@@ -333,13 +333,16 @@ void Router::handleReceived(MeshPacket *p)
     bool decoded = perhapsDecode(p);
     if (decoded) {
         // parsing was successful, queue for our recipient
-        printPacket("handleReceived", p);
+        if (src == RX_SRC_LOCAL)
+            printPacket("handleReceived(local)", p);
+        else
+            printPacket("handleReceived(remote)", p);
     } else {
         printPacket("packet decoding failed (no PSK?)", p);
     }
 
     // call plugins here
-    MeshPlugin::callPlugins(*p);
+    MeshPlugin::callPlugins(*p, src);
 }
 
 void Router::perhapsHandleReceived(MeshPacket *p)

src/mesh/Router.h

@@ -122,7 +122,7 @@ class Router : protected concurrency::OSThread
      * Note: this packet will never be called for messages sent/generated by this node.
      * Note: this method will free the provided packet.
      */
-    void handleReceived(MeshPacket *p);
+    void handleReceived(MeshPacket *p, RxSource src = RX_SRC_RADIO);
 
     /** Frees the provided packet, and generates a NAK indicating the speicifed error while sending */
     void abortSendAndNak(Routing_Error err, MeshPacket *p);

src/mesh/SX1262Interface.cpp

@@ -2,248 +2,8 @@
 #include "SX1262Interface.h"
 #include "error.h"
 
-// Particular boards might define a different max power based on what their hardware can do
-#ifndef SX1262_MAX_POWER
-#define SX1262_MAX_POWER 22
-#endif
-
 SX1262Interface::SX1262Interface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy,
                                  SPIClass &spi)
-    : RadioLibInterface(cs, irq, rst, busy, spi, &lora), lora(&module)
+    : SX126xInterface(cs, irq, rst, busy, spi)
 {
-}
-
-/// Initialise the Driver transport hardware and software.
-/// Make sure the Driver is properly configured before calling init().
-/// \return true if initialisation succeeded.
-bool SX1262Interface::init()
-{
-#ifdef SX1262_POWER_EN
-    digitalWrite(SX1262_POWER_EN, HIGH);
-    pinMode(SX1262_POWER_EN, OUTPUT);
-#endif
-
-#ifdef SX1262_RXEN                  // set not rx or tx mode
-    digitalWrite(SX1262_RXEN, LOW); // Set low before becoming an output
-    pinMode(SX1262_RXEN, OUTPUT);
-#endif
-#ifdef SX1262_TXEN
-    digitalWrite(SX1262_TXEN, LOW);
-    pinMode(SX1262_TXEN, OUTPUT);
-#endif
-
-#ifndef SX1262_E22
-    float tcxoVoltage = 0; // None - we use an XTAL
-#else
-    // Use DIO3 to power tcxo per https://github.com/jgromes/RadioLib/issues/12#issuecomment-520695575
-    float tcxoVoltage = 1.8;
-#endif
-    bool useRegulatorLDO = false; // Seems to depend on the connection to pin 9/DCC_SW - if an inductor DCDC?
-
-    RadioLibInterface::init();
-
-    if (power == 0)
-        power = SX1262_MAX_POWER;
-
-    if (power > SX1262_MAX_POWER) // This chip has lower power limits than some
-        power = SX1262_MAX_POWER;
-
-    limitPower();
-
-    int res = lora.begin(freq, bw, sf, cr, syncWord, power, currentLimit, preambleLength, tcxoVoltage, useRegulatorLDO);
-    DEBUG_MSG("SX1262 init result %d\n", res);
-
-#ifdef SX1262_TXEN
-    // lora.begin sets Dio2 as RF switch control, which is not true if we are manually controlling RX and TX
-    if (res == ERR_NONE)
-        res = lora.setDio2AsRfSwitch(false);
-#endif
-
-#if 0
-    // Read/write a register we are not using (only used for FSK mode) to test SPI comms
-    uint8_t crcLSB = 0;
-    int err = lora.readRegister(SX126X_REG_CRC_POLYNOMIAL_LSB, &crcLSB, 1);
-    if(err != ERR_NONE)
-        RECORD_CRITICALERROR(CriticalErrorCode_SX1262Failure);
-
-    //if(crcLSB != 0x0f)
-    //    RECORD_CRITICALERROR(CriticalErrorCode_SX1262Failure);
-    
-    crcLSB = 0x5a;
-    err = lora.writeRegister(SX126X_REG_CRC_POLYNOMIAL_LSB, &crcLSB, 1);
-    if(err != ERR_NONE)
-        RECORD_CRITICALERROR(CriticalErrorCode_SX1262Failure);  
-
-    err = lora.readRegister(SX126X_REG_CRC_POLYNOMIAL_LSB, &crcLSB, 1);
-    if(err != ERR_NONE)
-        RECORD_CRITICALERROR(CriticalErrorCode_SX1262Failure);
-
-    if(crcLSB != 0x5a)
-        RECORD_CRITICALERROR(CriticalErrorCode_SX1262Failure);
-    // If we got this far register accesses (and therefore SPI comms) are good
-#endif
-
-    if (res == ERR_NONE)
-        res = lora.setCRC(SX126X_LORA_CRC_ON);
-
-    if (res == ERR_NONE)
-        startReceive(); // start receiving
-
-    return res == ERR_NONE;
-}
-
-bool SX1262Interface::reconfigure()
-{
-    RadioLibInterface::reconfigure();
-
-    // set mode to standby
-    setStandby();
-
-    // configure publicly accessible settings
-    int err = lora.setSpreadingFactor(sf);
-    if (err != ERR_NONE)
-        RECORD_CRITICALERROR(CriticalErrorCode_InvalidRadioSetting);
-
-    err = lora.setBandwidth(bw);
-    if (err != ERR_NONE)
-        RECORD_CRITICALERROR(CriticalErrorCode_InvalidRadioSetting);
-
-    err = lora.setCodingRate(cr);
-    if (err != ERR_NONE)
-        RECORD_CRITICALERROR(CriticalErrorCode_InvalidRadioSetting);
-
-    // Hmm - seems to lower SNR when the signal levels are high.  Leaving off for now...
-    err = lora.setRxGain(true);
-    assert(err == ERR_NONE);
-
-    err = lora.setSyncWord(syncWord);
-    assert(err == ERR_NONE);
-
-    err = lora.setCurrentLimit(currentLimit);
-    assert(err == ERR_NONE);
-
-    err = lora.setPreambleLength(preambleLength);
-    assert(err == ERR_NONE);
-
-    err = lora.setFrequency(freq);
-    if (err != ERR_NONE)
-        RECORD_CRITICALERROR(CriticalErrorCode_InvalidRadioSetting);
-
-    if (power > 22) // This chip has lower power limits than some
-        power = 22;
-    err = lora.setOutputPower(power);
-    assert(err == ERR_NONE);
-
-    startReceive(); // restart receiving
-
-    return ERR_NONE;
-}
-
-void INTERRUPT_ATTR SX1262Interface::disableInterrupt()
-{
-    lora.clearDio1Action();
-}
-
-void SX1262Interface::setStandby()
-{
-    int err = lora.standby();
-    assert(err == ERR_NONE);
-
-#ifdef SX1262_RXEN // we have RXEN/TXEN control - turn off RX and TX power
-    digitalWrite(SX1262_RXEN, LOW);
-#endif
-#ifdef SX1262_TXEN
-    digitalWrite(SX1262_TXEN, LOW);
-#endif
-
-    isReceiving = false; // If we were receiving, not any more
-    disableInterrupt();
-    completeSending(); // If we were sending, not anymore
-}
-
-/**
- * Add SNR data to received messages
- */
-void SX1262Interface::addReceiveMetadata(MeshPacket *mp)
-{
-    // DEBUG_MSG("PacketStatus %x\n", lora.getPacketStatus());
-    mp->rx_snr = lora.getSNR();
-    mp->rx_rssi = lround(lora.getRSSI());
-}
-
-/** We override to turn on transmitter power as needed.
- */
-void SX1262Interface::configHardwareForSend()
-{
-#ifdef SX1262_TXEN // we have RXEN/TXEN control - turn on TX power / off RX power
-    digitalWrite(SX1262_TXEN, HIGH);
-#endif
-
-    RadioLibInterface::configHardwareForSend();
-}
-
-// For power draw measurements, helpful to force radio to stay sleeping
-// #define SLEEP_ONLY
-
-void SX1262Interface::startReceive()
-{
-#ifdef SLEEP_ONLY
-    sleep();
-#else
-
-    setStandby();
-
-#ifdef SX1262_RXEN // we have RXEN/TXEN control - turn on RX power / off TX power
-    digitalWrite(SX1262_RXEN, HIGH);
-#endif
-
-    // int err = lora.startReceive();
-    int err = lora.startReceiveDutyCycleAuto(); // We use a 32 bit preamble so this should save some power by letting radio sit in
-                                                // standby mostly.
-    assert(err == ERR_NONE);
-
-    isReceiving = true;
-
-    // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register bits
-    enableInterrupt(isrRxLevel0);
-#endif
-}
-
-/** Could we send right now (i.e. either not actively receving or transmitting)? */
-bool SX1262Interface::isActivelyReceiving()
-{
-    // The IRQ status will be cleared when we start our read operation.  Check if we've started a header, but haven't yet
-    // received and handled the interrupt for reading the packet/handling errors.
-    // FIXME: it would be better to check for preamble, but we currently have our ISR not set to fire for packets that
-    // never even get a valid header, so we don't want preamble to get set and stay set due to noise on the network.
-
-    uint16_t irq = lora.getIrqStatus();
-    bool hasPreamble = (irq & SX126X_IRQ_HEADER_VALID);
-
-    // this is not correct - often always true - need to add an extra conditional
-    // size_t bytesPending = lora.getPacketLength();
-
-    // if (hasPreamble) DEBUG_MSG("rx hasPreamble\n");
-    return hasPreamble;
-}
-
-bool SX1262Interface::sleep()
-{
-    // Not keeping config is busted - next time nrf52 board boots lora sending fails  tcxo related? - see datasheet
-    DEBUG_MSG("sx1262 entering sleep mode (FIXME, don't keep config)\n");
-    setStandby(); // Stop any pending operations
-
-    // turn off TCXO if it was powered
-    // FIXME - this isn't correct
-    // lora.setTCXO(0);
-
-    // put chipset into sleep mode (we've already disabled interrupts by now)
-    bool keepConfig = true;
-    lora.sleep(keepConfig); // Note: we do not keep the config, full reinit will be needed
-
-#ifdef SX1262_POWER_EN
-    digitalWrite(SX1262_POWER_EN, LOW);
-#endif
-
-    return true;
 }

src/mesh/SX1262Interface.h

@@ -1,62 +1,12 @@
 #pragma once
 
-#include "RadioLibInterface.h"
+#include "SX126xInterface.h"
 
 /**
  * Our adapter for SX1262 radios
  */
-class SX1262Interface : public RadioLibInterface
+class SX1262Interface : public SX126xInterface<SX1262>
 {
-    SX1262 lora;
-
   public:
     SX1262Interface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy, SPIClass &spi);
-
-    /// Initialise the Driver transport hardware and software.
-    /// Make sure the Driver is properly configured before calling init().
-    /// \return true if initialisation succeeded.
-    virtual bool init();
-
-    /// Apply any radio provisioning changes
-    /// Make sure the Driver is properly configured before calling init().
-    /// \return true if initialisation succeeded.
-    virtual bool reconfigure();
-
-    /// Prepare hardware for sleep.  Call this _only_ for deep sleep, not needed for light sleep.
-    virtual bool sleep();
-
-    bool isIRQPending() { return lora.getIrqStatus() != 0; }
-
-  protected:
-    /**
-     * Glue functions called from ISR land
-     */
-    virtual void disableInterrupt();
-
-    /**
-     * Enable a particular ISR callback glue function
-     */
-    virtual void enableInterrupt(void (*callback)()) { lora.setDio1Action(callback); }
-
-    /** are we actively receiving a packet (only called during receiving state) */
-    virtual bool isActivelyReceiving();
-
-    /**
-     * Start waiting to receive a message
-     */
-    virtual void startReceive();
-
-    /**
-     *  We override to turn on transmitter power as needed.
-     */
-    virtual void configHardwareForSend();
-
-    /**
-     * Add SNR data to received messages
-     */
-    virtual void addReceiveMetadata(MeshPacket *mp);
-
-    virtual void setStandby();
-
-  private:
 };

src/mesh/SX1268Interface.cpp

@@ -0,0 +1,9 @@
+#include "configuration.h"
+#include "SX1268Interface.h"
+#include "error.h"
+
+SX1268Interface::SX1268Interface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy,
+                                 SPIClass &spi)
+    : SX126xInterface(cs, irq, rst, busy, spi)
+{
+}

src/mesh/SX1268Interface.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "SX126xInterface.h"
+
+/**
+ * Our adapter for SX1268 radios
+ */
+class SX1268Interface : public SX126xInterface<SX1268>
+{
+  public:
+    /// override frequency of the SX1268 module regardless of the region (use EU433 value)
+    virtual float getFreq() { return 433.175f; }
+
+    SX1268Interface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy, SPIClass &spi);
+};

src/mesh/SX126xInterface.cpp

@@ -0,0 +1,269 @@
+#include "configuration.h"
+#include "SX126xInterface.h"
+#include "error.h"
+
+// Particular boards might define a different max power based on what their hardware can do
+#ifndef SX126X_MAX_POWER
+#define SX126X_MAX_POWER 22
+#endif
+
+template<typename T>
+SX126xInterface<T>::SX126xInterface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy,
+                                 SPIClass &spi)
+    : RadioLibInterface(cs, irq, rst, busy, spi, &lora), lora(&module)
+{
+}
+
+/// Initialise the Driver transport hardware and software.
+/// Make sure the Driver is properly configured before calling init().
+/// \return true if initialisation succeeded.
+template<typename T>
+bool SX126xInterface<T>::init()
+{
+#ifdef SX126X_POWER_EN
+    digitalWrite(SX126X_POWER_EN, HIGH);
+    pinMode(SX126X_POWER_EN, OUTPUT);
+#endif
+
+#ifdef SX126X_RXEN                  // set not rx or tx mode
+    digitalWrite(SX126X_RXEN, LOW); // Set low before becoming an output
+    pinMode(SX126X_RXEN, OUTPUT);
+#endif
+#ifdef SX126X_TXEN
+    digitalWrite(SX126X_TXEN, LOW);
+    pinMode(SX126X_TXEN, OUTPUT);
+#endif
+
+#ifndef SX126X_E22
+    float tcxoVoltage = 0; // None - we use an XTAL
+#else
+    // Use DIO3 to power tcxo per https://github.com/jgromes/RadioLib/issues/12#issuecomment-520695575
+    float tcxoVoltage = 1.8;
+#endif
+    bool useRegulatorLDO = false; // Seems to depend on the connection to pin 9/DCC_SW - if an inductor DCDC?
+
+    RadioLibInterface::init();
+
+    if (power == 0)
+        power = SX126X_MAX_POWER;
+
+    if (power > SX126X_MAX_POWER) // This chip has lower power limits than some
+        power = SX126X_MAX_POWER;
+
+    limitPower();
+
+    int res = lora.begin(getFreq(), bw, sf, cr, syncWord, power, preambleLength, tcxoVoltage, useRegulatorLDO);
+    // \todo Display actual typename of the adapter, not just `SX126x`
+    DEBUG_MSG("SX126x init result %d\n", res);
+
+    // current limit was removed from module' ctor
+    // override default value (60 mA)
+    res = lora.setCurrentLimit(currentLimit);
+    DEBUG_MSG("Current limit set to %f\n", currentLimit);
+    DEBUG_MSG("Current limit set result %d\n", res);
+
+#ifdef SX126X_TXEN
+    // lora.begin sets Dio2 as RF switch control, which is not true if we are manually controlling RX and TX
+    if (res == ERR_NONE)
+        res = lora.setDio2AsRfSwitch(false);
+#endif
+
+#if 0
+    // Read/write a register we are not using (only used for FSK mode) to test SPI comms
+    uint8_t crcLSB = 0;
+    int err = lora.readRegister(SX126X_REG_CRC_POLYNOMIAL_LSB, &crcLSB, 1);
+    if(err != ERR_NONE)
+        RECORD_CRITICALERROR(CriticalErrorCode_SX1262Failure);
+
+    //if(crcLSB != 0x0f)
+    //    RECORD_CRITICALERROR(CriticalErrorCode_SX1262Failure);
+    
+    crcLSB = 0x5a;
+    err = lora.writeRegister(SX126X_REG_CRC_POLYNOMIAL_LSB, &crcLSB, 1);
+    if(err != ERR_NONE)
+        RECORD_CRITICALERROR(CriticalErrorCode_SX1262Failure);  
+
+    err = lora.readRegister(SX126X_REG_CRC_POLYNOMIAL_LSB, &crcLSB, 1);
+    if(err != ERR_NONE)
+        RECORD_CRITICALERROR(CriticalErrorCode_SX1262Failure);
+
+    if(crcLSB != 0x5a)
+        RECORD_CRITICALERROR(CriticalErrorCode_SX1262Failure);
+    // If we got this far register accesses (and therefore SPI comms) are good
+#endif
+
+    if (res == ERR_NONE)
+        res = lora.setCRC(SX126X_LORA_CRC_ON);
+
+    if (res == ERR_NONE)
+        startReceive(); // start receiving
+
+    return res == ERR_NONE;
+}
+
+template<typename T>
+bool SX126xInterface<T>::reconfigure()
+{
+    RadioLibInterface::reconfigure();
+
+    // set mode to standby
+    setStandby();
+
+    // configure publicly accessible settings
+    int err = lora.setSpreadingFactor(sf);
+    if (err != ERR_NONE)
+        RECORD_CRITICALERROR(CriticalErrorCode_InvalidRadioSetting);
+
+    err = lora.setBandwidth(bw);
+    if (err != ERR_NONE)
+        RECORD_CRITICALERROR(CriticalErrorCode_InvalidRadioSetting);
+
+    err = lora.setCodingRate(cr);
+    if (err != ERR_NONE)
+        RECORD_CRITICALERROR(CriticalErrorCode_InvalidRadioSetting);
+
+    // Hmm - seems to lower SNR when the signal levels are high.  Leaving off for now...
+    err = lora.setRxGain(true);
+    assert(err == ERR_NONE);
+
+    err = lora.setSyncWord(syncWord);
+    assert(err == ERR_NONE);
+
+    err = lora.setCurrentLimit(currentLimit);
+    assert(err == ERR_NONE);
+
+    err = lora.setPreambleLength(preambleLength);
+    assert(err == ERR_NONE);
+
+    err = lora.setFrequency(getFreq());
+    if (err != ERR_NONE)
+        RECORD_CRITICALERROR(CriticalErrorCode_InvalidRadioSetting);
+
+    if (power > 22) // This chip has lower power limits than some
+        power = 22;
+    err = lora.setOutputPower(power);
+    assert(err == ERR_NONE);
+
+    startReceive(); // restart receiving
+
+    return ERR_NONE;
+}
+
+template<typename T>
+void INTERRUPT_ATTR SX126xInterface<T>::disableInterrupt()
+{
+    lora.clearDio1Action();
+}
+
+template<typename T>
+void SX126xInterface<T>::setStandby()
+{
+    checkNotification(); // handle any pending interrupts before we force standby
+    
+    int err = lora.standby();
+    assert(err == ERR_NONE);
+
+#ifdef SX126X_RXEN // we have RXEN/TXEN control - turn off RX and TX power
+    digitalWrite(SX126X_RXEN, LOW);
+#endif
+#ifdef SX126X_TXEN
+    digitalWrite(SX126X_TXEN, LOW);
+#endif
+
+    isReceiving = false; // If we were receiving, not any more
+    disableInterrupt();
+    completeSending(); // If we were sending, not anymore
+}
+
+/**
+ * Add SNR data to received messages
+ */
+template<typename T>
+void SX126xInterface<T>::addReceiveMetadata(MeshPacket *mp)
+{
+    // DEBUG_MSG("PacketStatus %x\n", lora.getPacketStatus());
+    mp->rx_snr = lora.getSNR();
+    mp->rx_rssi = lround(lora.getRSSI());
+}
+
+/** We override to turn on transmitter power as needed.
+ */
+template<typename T>
+void SX126xInterface<T>::configHardwareForSend()
+{
+#ifdef SX126X_TXEN // we have RXEN/TXEN control - turn on TX power / off RX power
+    digitalWrite(SX126X_TXEN, HIGH);
+#endif
+
+    RadioLibInterface::configHardwareForSend();
+}
+
+// For power draw measurements, helpful to force radio to stay sleeping
+// #define SLEEP_ONLY
+
+template<typename T>
+void SX126xInterface<T>::startReceive()
+{
+#ifdef SLEEP_ONLY
+    sleep();
+#else
+
+    setStandby();
+
+#ifdef SX126X_RXEN // we have RXEN/TXEN control - turn on RX power / off TX power
+    digitalWrite(SX126X_RXEN, HIGH);
+#endif
+
+    // int err = lora.startReceive();
+    int err = lora.startReceiveDutyCycleAuto(); // We use a 32 bit preamble so this should save some power by letting radio sit in
+                                                // standby mostly.
+    assert(err == ERR_NONE);
+
+    isReceiving = true;
+
+    // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register bits
+    enableInterrupt(isrRxLevel0);
+#endif
+}
+
+/** Could we send right now (i.e. either not actively receving or transmitting)? */
+template<typename T>
+bool SX126xInterface<T>::isActivelyReceiving()
+{
+    // The IRQ status will be cleared when we start our read operation.  Check if we've started a header, but haven't yet
+    // received and handled the interrupt for reading the packet/handling errors.
+    // FIXME: it would be better to check for preamble, but we currently have our ISR not set to fire for packets that
+    // never even get a valid header, so we don't want preamble to get set and stay set due to noise on the network.
+
+    uint16_t irq = lora.getIrqStatus();
+    bool hasPreamble = (irq & SX126X_IRQ_HEADER_VALID);
+
+    // this is not correct - often always true - need to add an extra conditional
+    // size_t bytesPending = lora.getPacketLength();
+
+    // if (hasPreamble) DEBUG_MSG("rx hasPreamble\n");
+    return hasPreamble;
+}
+
+template<typename T>
+bool SX126xInterface<T>::sleep()
+{
+    // Not keeping config is busted - next time nrf52 board boots lora sending fails  tcxo related? - see datasheet
+    // \todo Display actual typename of the adapter, not just `SX126x`
+    DEBUG_MSG("sx126x entering sleep mode (FIXME, don't keep config)\n");
+    setStandby(); // Stop any pending operations
+
+    // turn off TCXO if it was powered
+    // FIXME - this isn't correct
+    // lora.setTCXO(0);
+
+    // put chipset into sleep mode (we've already disabled interrupts by now)
+    bool keepConfig = true;
+    lora.sleep(keepConfig); // Note: we do not keep the config, full reinit will be needed
+
+#ifdef SX126X_POWER_EN
+    digitalWrite(SX126X_POWER_EN, LOW);
+#endif
+
+    return true;
+}

src/mesh/SX126xInterface.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "RadioLibInterface.h"
+
+/**
+ * \brief Adapter for SX126x radio family. Implements common logic for child classes.
+ * \tparam T RadioLib module type for SX126x: SX1262, SX1268.
+ */
+template<class T>
+class SX126xInterface : public RadioLibInterface
+{
+  public:
+    SX126xInterface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy, SPIClass &spi);
+
+    /// Initialise the Driver transport hardware and software.
+    /// Make sure the Driver is properly configured before calling init().
+    /// \return true if initialisation succeeded.
+    virtual bool init();
+
+    /// Apply any radio provisioning changes
+    /// Make sure the Driver is properly configured before calling init().
+    /// \return true if initialisation succeeded.
+    virtual bool reconfigure();
+
+    /// Prepare hardware for sleep.  Call this _only_ for deep sleep, not needed for light sleep.
+    virtual bool sleep();
+
+    bool isIRQPending() { return lora.getIrqStatus() != 0; }
+
+  protected:
+
+    /**
+     * Specific module instance 
+     */
+    T lora;
+
+    /**
+     * Glue functions called from ISR land
+     */
+    virtual void disableInterrupt();
+
+    /**
+     * Enable a particular ISR callback glue function
+     */
+    virtual void enableInterrupt(void (*callback)()) { lora.setDio1Action(callback); }
+
+    /** are we actively receiving a packet (only called during receiving state) */
+    virtual bool isActivelyReceiving();
+
+    /**
+     * Start waiting to receive a message
+     */
+    virtual void startReceive();
+
+    /**
+     *  We override to turn on transmitter power as needed.
+     */
+    virtual void configHardwareForSend();
+
+    /**
+     * Add SNR data to received messages
+     */
+    virtual void addReceiveMetadata(MeshPacket *mp);
+
+    virtual void setStandby();
+
+  private:
+};

src/mesh/StreamAPI.cpp

@@ -26,7 +26,11 @@ int32_t StreamAPI::readStream()
         return recentRx ? 5 : 250;
     } else {
         while (stream->available()) { // Currently we never want to block
-            uint8_t c = stream->read();
+            int cInt = stream->read();
+            if(cInt < 0)
+                break; // We ran out of characters (even though available said otherwise) - this can happen on rf52 adafruit arduino
+
+            uint8_t c = (uint8_t) cInt;
 
             // Use the read pointer for a little state machine, first look for framing, then length bytes, then payload
             size_t ptr = rxPtr;

src/mesh/StreamAPI.h

@@ -68,7 +68,7 @@ class StreamAPI : public PhoneAPI, protected concurrency::OSThread
     void emitRebooted();
 
     virtual void onConnectionChanged(bool connected);
-    
+
     /// Check the current underlying physical link to see if the client is currently connected
     virtual bool checkIsConnected() = 0;
 

src/mesh/generated/admin.pb.h

@@ -79,7 +79,7 @@ extern const pb_msgdesc_t AdminMessage_msg;
 #define AdminMessage_fields &AdminMessage_msg
 
 /* Maximum encoded size of messages (where known) */
-#define AdminMessage_size                        397
+#define AdminMessage_size                        407
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/deviceonly.pb.c

@@ -12,7 +12,7 @@ PB_BIND(LegacyRadioConfig, LegacyRadioConfig, AUTO)
 PB_BIND(LegacyRadioConfig_LegacyPreferences, LegacyRadioConfig_LegacyPreferences, AUTO)
 
 
-PB_BIND(DeviceState, DeviceState, 2)
+PB_BIND(DeviceState, DeviceState, 4)
 
 
 PB_BIND(ChannelFile, ChannelFile, 2)

src/mesh/generated/deviceonly.pb.h

@@ -125,7 +125,7 @@ extern const pb_msgdesc_t ChannelFile_msg;
 /* Maximum encoded size of messages (where known) */
 #define LegacyRadioConfig_size                   4
 #define LegacyRadioConfig_LegacyPreferences_size 2
-#define DeviceState_size                         5190
+#define DeviceState_size                         10054
 #define ChannelFile_size                         832
 
 #ifdef __cplusplus

src/mesh/generated/mesh.pb.c

@@ -49,3 +49,5 @@ PB_BIND(ToRadio_PeerInfo, ToRadio_PeerInfo, AUTO)
 
 
 
+
+

src/mesh/generated/mesh.pb.h

@@ -29,7 +29,8 @@ typedef enum _HardwareModel {
     HardwareModel_GENIEBLOCKS = 35,
     HardwareModel_NRF52_UNKNOWN = 36,
     HardwareModel_PORTDUINO = 37,
-    HardwareModel_ANDROID_SIM = 38
+    HardwareModel_ANDROID_SIM = 38,
+    HardwareModel_DIY_V1 = 39
 } HardwareModel;
 
 typedef enum _Constants {
@@ -52,6 +53,21 @@ typedef enum _CriticalErrorCode {
     CriticalErrorCode_RadioSpiBug = 11
 } CriticalErrorCode;
 
+typedef enum _Position_LocSource {
+    Position_LocSource_LOCSRC_UNSPECIFIED = 0,
+    Position_LocSource_LOCSRC_MANUAL_ENTRY = 1,
+    Position_LocSource_LOCSRC_GPS_INTERNAL = 2,
+    Position_LocSource_LOCSRC_GPS_EXTERNAL = 3
+} Position_LocSource;
+
+typedef enum _Position_AltSource {
+    Position_AltSource_ALTSRC_UNSPECIFIED = 0,
+    Position_AltSource_ALTSRC_MANUAL_ENTRY = 1,
+    Position_AltSource_ALTSRC_GPS_INTERNAL = 2,
+    Position_AltSource_ALTSRC_GPS_EXTERNAL = 3,
+    Position_AltSource_ALTSRC_BAROMETRIC = 4
+} Position_AltSource;
+
 typedef enum _Routing_Error {
     Routing_Error_NONE = 0,
     Routing_Error_NO_ROUTE = 1,
@@ -126,6 +142,29 @@ typedef struct _Position {
     int32_t altitude;
     int32_t battery_level;
     uint32_t time;
+    Position_LocSource location_source;
+    Position_AltSource altitude_source;
+    uint32_t pos_timestamp;
+    int32_t pos_time_millis;
+    int32_t altitude_hae;
+    int32_t alt_geoid_sep;
+    uint32_t PDOP;
+    uint32_t HDOP;
+    uint32_t VDOP;
+    uint32_t gps_accuracy;
+    uint32_t ground_speed;
+    uint32_t ground_track;
+    uint32_t fix_quality;
+    uint32_t fix_type;
+    uint32_t sats_in_view;
+    uint32_t sensor_id;
+    uint32_t heading;
+    int32_t roll;
+    int32_t pitch;
+    uint32_t air_speed;
+    uint32_t ground_distance_cm;
+    uint32_t pos_next_update;
+    uint32_t pos_seq_number;
 } Position;
 
 typedef struct _RouteDiscovery {
@@ -211,8 +250,8 @@ typedef struct _ToRadio {
 
 /* Helper constants for enums */
 #define _HardwareModel_MIN HardwareModel_UNSET
-#define _HardwareModel_MAX HardwareModel_ANDROID_SIM
-#define _HardwareModel_ARRAYSIZE ((HardwareModel)(HardwareModel_ANDROID_SIM+1))
+#define _HardwareModel_MAX HardwareModel_DIY_V1
+#define _HardwareModel_ARRAYSIZE ((HardwareModel)(HardwareModel_DIY_V1+1))
 
 #define _Constants_MIN Constants_Unused
 #define _Constants_MAX Constants_DATA_PAYLOAD_LEN
@@ -222,6 +261,14 @@ typedef struct _ToRadio {
 #define _CriticalErrorCode_MAX CriticalErrorCode_RadioSpiBug
 #define _CriticalErrorCode_ARRAYSIZE ((CriticalErrorCode)(CriticalErrorCode_RadioSpiBug+1))
 
+#define _Position_LocSource_MIN Position_LocSource_LOCSRC_UNSPECIFIED
+#define _Position_LocSource_MAX Position_LocSource_LOCSRC_GPS_EXTERNAL
+#define _Position_LocSource_ARRAYSIZE ((Position_LocSource)(Position_LocSource_LOCSRC_GPS_EXTERNAL+1))
+
+#define _Position_AltSource_MIN Position_AltSource_ALTSRC_UNSPECIFIED
+#define _Position_AltSource_MAX Position_AltSource_ALTSRC_BAROMETRIC
+#define _Position_AltSource_ARRAYSIZE ((Position_AltSource)(Position_AltSource_ALTSRC_BAROMETRIC+1))
+
 #define _Routing_Error_MIN Routing_Error_NONE
 #define _Routing_Error_MAX Routing_Error_NOT_AUTHORIZED
 #define _Routing_Error_ARRAYSIZE ((Routing_Error)(Routing_Error_NOT_AUTHORIZED+1))
@@ -240,7 +287,7 @@ extern "C" {
 #endif
 
 /* Initializer values for message structs */
-#define Position_init_default                    {0, 0, 0, 0, 0}
+#define Position_init_default                    {0, 0, 0, 0, 0, _Position_LocSource_MIN, _Position_AltSource_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define User_init_default                        {"", "", "", {0}, _HardwareModel_MIN, 0}
 #define RouteDiscovery_init_default              {0, {0, 0, 0, 0, 0, 0, 0, 0}}
 #define Routing_init_default                     {0, {RouteDiscovery_init_default}}
@@ -252,7 +299,7 @@ extern "C" {
 #define FromRadio_init_default                   {0, 0, {MyNodeInfo_init_default}}
 #define ToRadio_init_default                     {0, {MeshPacket_init_default}}
 #define ToRadio_PeerInfo_init_default            {0, 0}
-#define Position_init_zero                       {0, 0, 0, 0, 0}
+#define Position_init_zero                       {0, 0, 0, 0, 0, _Position_LocSource_MIN, _Position_AltSource_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 #define User_init_zero                           {"", "", "", {0}, _HardwareModel_MIN, 0}
 #define RouteDiscovery_init_zero                 {0, {0, 0, 0, 0, 0, 0, 0, 0}}
 #define Routing_init_zero                        {0, {RouteDiscovery_init_zero}}
@@ -294,6 +341,29 @@ extern "C" {
 #define Position_altitude_tag                    3
 #define Position_battery_level_tag               4
 #define Position_time_tag                        9
+#define Position_location_source_tag             10
+#define Position_altitude_source_tag             11
+#define Position_pos_timestamp_tag               12
+#define Position_pos_time_millis_tag             13
+#define Position_altitude_hae_tag                14
+#define Position_alt_geoid_sep_tag               15
+#define Position_PDOP_tag                        16
+#define Position_HDOP_tag                        17
+#define Position_VDOP_tag                        18
+#define Position_gps_accuracy_tag                19
+#define Position_ground_speed_tag                20
+#define Position_ground_track_tag                21
+#define Position_fix_quality_tag                 22
+#define Position_fix_type_tag                    23
+#define Position_sats_in_view_tag                24
+#define Position_sensor_id_tag                   25
+#define Position_heading_tag                     30
+#define Position_roll_tag                        31
+#define Position_pitch_tag                       32
+#define Position_air_speed_tag                   33
+#define Position_ground_distance_cm_tag          34
+#define Position_pos_next_update_tag             40
+#define Position_pos_seq_number_tag              41
 #define RouteDiscovery_route_tag                 2
 #define ToRadio_PeerInfo_app_version_tag         1
 #define ToRadio_PeerInfo_mqtt_gateway_tag        2
@@ -341,7 +411,30 @@ X(a, STATIC,   SINGULAR, SFIXED32, latitude_i,        1) \
 X(a, STATIC,   SINGULAR, SFIXED32, longitude_i,       2) \
 X(a, STATIC,   SINGULAR, INT32,    altitude,          3) \
 X(a, STATIC,   SINGULAR, INT32,    battery_level,     4) \
-X(a, STATIC,   SINGULAR, FIXED32,  time,              9)
+X(a, STATIC,   SINGULAR, FIXED32,  time,              9) \
+X(a, STATIC,   SINGULAR, UENUM,    location_source,  10) \
+X(a, STATIC,   SINGULAR, UENUM,    altitude_source,  11) \
+X(a, STATIC,   SINGULAR, FIXED32,  pos_timestamp,    12) \
+X(a, STATIC,   SINGULAR, INT32,    pos_time_millis,  13) \
+X(a, STATIC,   SINGULAR, SINT32,   altitude_hae,     14) \
+X(a, STATIC,   SINGULAR, SINT32,   alt_geoid_sep,    15) \
+X(a, STATIC,   SINGULAR, UINT32,   PDOP,             16) \
+X(a, STATIC,   SINGULAR, UINT32,   HDOP,             17) \
+X(a, STATIC,   SINGULAR, UINT32,   VDOP,             18) \
+X(a, STATIC,   SINGULAR, UINT32,   gps_accuracy,     19) \
+X(a, STATIC,   SINGULAR, UINT32,   ground_speed,     20) \
+X(a, STATIC,   SINGULAR, UINT32,   ground_track,     21) \
+X(a, STATIC,   SINGULAR, UINT32,   fix_quality,      22) \
+X(a, STATIC,   SINGULAR, UINT32,   fix_type,         23) \
+X(a, STATIC,   SINGULAR, UINT32,   sats_in_view,     24) \
+X(a, STATIC,   SINGULAR, UINT32,   sensor_id,        25) \
+X(a, STATIC,   SINGULAR, UINT32,   heading,          30) \
+X(a, STATIC,   SINGULAR, SINT32,   roll,             31) \
+X(a, STATIC,   SINGULAR, SINT32,   pitch,            32) \
+X(a, STATIC,   SINGULAR, UINT32,   air_speed,        33) \
+X(a, STATIC,   SINGULAR, UINT32,   ground_distance_cm,  34) \
+X(a, STATIC,   SINGULAR, UINT32,   pos_next_update,  40) \
+X(a, STATIC,   SINGULAR, UINT32,   pos_seq_number,   41)
 #define Position_CALLBACK NULL
 #define Position_DEFAULT NULL
 
@@ -491,13 +584,13 @@ extern const pb_msgdesc_t ToRadio_PeerInfo_msg;
 #define ToRadio_PeerInfo_fields &ToRadio_PeerInfo_msg
 
 /* Maximum encoded size of messages (where known) */
-#define Position_size                            37
+#define Position_size                            188
 #define User_size                                76
 #define RouteDiscovery_size                      40
 #define Routing_size                             42
 #define Data_size                                260
 #define MeshPacket_size                          309
-#define NodeInfo_size                            133
+#define NodeInfo_size                            285
 #define MyNodeInfo_size                          101
 #define LogRecord_size                           81
 #define FromRadio_size                           318

src/mesh/generated/radioconfig.pb.c

@@ -18,3 +18,5 @@ PB_BIND(RadioConfig_UserPreferences, RadioConfig_UserPreferences, 2)
 
 
 
+
+

src/mesh/generated/radioconfig.pb.h

@@ -51,12 +51,34 @@ typedef enum _GpsOperation {
     GpsOperation_GpsOpDisabled = 4
 } GpsOperation;
 
+typedef enum _GpsCoordinateFormat {
+    GpsCoordinateFormat_GpsFormatDec = 0,
+    GpsCoordinateFormat_GpsFormatDMS = 1,
+    GpsCoordinateFormat_GpsFormatUTM = 2,
+    GpsCoordinateFormat_GpsFormatMGRS = 3,
+    GpsCoordinateFormat_GpsFormatOLC = 4,
+    GpsCoordinateFormat_GpsFormatOSGR = 5
+} GpsCoordinateFormat;
+
 typedef enum _LocationSharing {
     LocationSharing_LocUnset = 0,
     LocationSharing_LocEnabled = 1,
     LocationSharing_LocDisabled = 2
 } LocationSharing;
 
+typedef enum _PositionFlags {
+    PositionFlags_POS_UNDEFINED = 0,
+    PositionFlags_POS_ALTITUDE = 1,
+    PositionFlags_POS_ALT_MSL = 2,
+    PositionFlags_POS_GEO_SEP = 4,
+    PositionFlags_POS_DOP = 8,
+    PositionFlags_POS_HVDOP = 16,
+    PositionFlags_POS_BATTERY = 32,
+    PositionFlags_POS_SATINVIEW = 64,
+    PositionFlags_POS_SEQ_NOS = 128,
+    PositionFlags_POS_TIMESTAMP = 256
+} PositionFlags;
+
 typedef enum _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType {
     RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_DHT11 = 0
 } RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType;
@@ -89,6 +111,7 @@ typedef struct _RadioConfig_UserPreferences {
     float frequency_offset;
     char mqtt_server[32];
     bool mqtt_disabled;
+    GpsCoordinateFormat gps_format;
     bool factory_reset;
     bool debug_log_enabled;
     pb_size_t ignore_incoming_count;
@@ -118,6 +141,7 @@ typedef struct _RadioConfig_UserPreferences {
     RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType environmental_measurement_plugin_sensor_type;
     uint32_t environmental_measurement_plugin_sensor_pin;
     bool store_forward_plugin_enabled;
+    uint32_t position_flags;
 } RadioConfig_UserPreferences;
 
 typedef struct _RadioConfig {
@@ -139,10 +163,18 @@ typedef struct _RadioConfig {
 #define _GpsOperation_MAX GpsOperation_GpsOpDisabled
 #define _GpsOperation_ARRAYSIZE ((GpsOperation)(GpsOperation_GpsOpDisabled+1))
 
+#define _GpsCoordinateFormat_MIN GpsCoordinateFormat_GpsFormatDec
+#define _GpsCoordinateFormat_MAX GpsCoordinateFormat_GpsFormatOSGR
+#define _GpsCoordinateFormat_ARRAYSIZE ((GpsCoordinateFormat)(GpsCoordinateFormat_GpsFormatOSGR+1))
+
 #define _LocationSharing_MIN LocationSharing_LocUnset
 #define _LocationSharing_MAX LocationSharing_LocDisabled
 #define _LocationSharing_ARRAYSIZE ((LocationSharing)(LocationSharing_LocDisabled+1))
 
+#define _PositionFlags_MIN PositionFlags_POS_UNDEFINED
+#define _PositionFlags_MAX PositionFlags_POS_TIMESTAMP
+#define _PositionFlags_ARRAYSIZE ((PositionFlags)(PositionFlags_POS_TIMESTAMP+1))
+
 #define _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_DHT11
 #define _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MAX RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_DHT11
 #define _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_ARRAYSIZE ((RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType)(RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_DHT11+1))
@@ -154,9 +186,9 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define RadioConfig_init_default                 {false, RadioConfig_UserPreferences_init_default}
-#define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0}
+#define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, _GpsCoordinateFormat_MIN, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0, 0}
 #define RadioConfig_init_zero                    {false, RadioConfig_UserPreferences_init_zero}
-#define RadioConfig_UserPreferences_init_zero    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0}
+#define RadioConfig_UserPreferences_init_zero    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, _GpsCoordinateFormat_MIN, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0, 0}
 
 /* Field tags (for use in manual encoding/decoding) */
 #define RadioConfig_UserPreferences_position_broadcast_secs_tag 1
@@ -185,6 +217,7 @@ extern "C" {
 #define RadioConfig_UserPreferences_frequency_offset_tag 41
 #define RadioConfig_UserPreferences_mqtt_server_tag 42
 #define RadioConfig_UserPreferences_mqtt_disabled_tag 43
+#define RadioConfig_UserPreferences_gps_format_tag 44
 #define RadioConfig_UserPreferences_factory_reset_tag 100
 #define RadioConfig_UserPreferences_debug_log_enabled_tag 101
 #define RadioConfig_UserPreferences_ignore_incoming_tag 103
@@ -213,6 +246,7 @@ extern "C" {
 #define RadioConfig_UserPreferences_environmental_measurement_plugin_sensor_type_tag 146
 #define RadioConfig_UserPreferences_environmental_measurement_plugin_sensor_pin_tag 147
 #define RadioConfig_UserPreferences_store_forward_plugin_enabled_tag 148
+#define RadioConfig_UserPreferences_position_flags_tag 150
 #define RadioConfig_preferences_tag              1
 
 /* Struct field encoding specification for nanopb */
@@ -249,6 +283,7 @@ X(a, STATIC,   SINGULAR, BOOL,     serial_disabled,  40) \
 X(a, STATIC,   SINGULAR, FLOAT,    frequency_offset,  41) \
 X(a, STATIC,   SINGULAR, STRING,   mqtt_server,      42) \
 X(a, STATIC,   SINGULAR, BOOL,     mqtt_disabled,    43) \
+X(a, STATIC,   SINGULAR, UENUM,    gps_format,       44) \
 X(a, STATIC,   SINGULAR, BOOL,     factory_reset,   100) \
 X(a, STATIC,   SINGULAR, BOOL,     debug_log_enabled, 101) \
 X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103) \
@@ -276,7 +311,8 @@ X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_recovery_int
 X(a, STATIC,   SINGULAR, BOOL,     environmental_measurement_plugin_display_farenheit, 145) \
 X(a, STATIC,   SINGULAR, UENUM,    environmental_measurement_plugin_sensor_type, 146) \
 X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_sensor_pin, 147) \
-X(a, STATIC,   SINGULAR, BOOL,     store_forward_plugin_enabled, 148)
+X(a, STATIC,   SINGULAR, BOOL,     store_forward_plugin_enabled, 148) \
+X(a, STATIC,   SINGULAR, UINT32,   position_flags,  150)
 #define RadioConfig_UserPreferences_CALLBACK NULL
 #define RadioConfig_UserPreferences_DEFAULT NULL
 
@@ -288,8 +324,8 @@ extern const pb_msgdesc_t RadioConfig_UserPreferences_msg;
 #define RadioConfig_UserPreferences_fields &RadioConfig_UserPreferences_msg
 
 /* Maximum encoded size of messages (where known) */
-#define RadioConfig_size                         394
-#define RadioConfig_UserPreferences_size         391
+#define RadioConfig_size                         404
+#define RadioConfig_UserPreferences_size         401
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/http/ContentHandler.cpp

@@ -4,7 +4,6 @@
 #include "airtime.h"
 #include "main.h"
 #include "mesh/http/ContentHelper.h"
-#include "mesh/http/ContentStatic.h"
 #include "mesh/http/WiFiAPClient.h"
 #include "power.h"
 #include "sleep.h"
@@ -79,19 +78,17 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
 
     ResourceNode *nodeHotspotApple = new ResourceNode("/hotspot-detect.html", "GET", &handleHotspot);
     ResourceNode *nodeHotspotAndroid = new ResourceNode("/generate_204", "GET", &handleHotspot);
-    ResourceNode *nodeFavicon = new ResourceNode("/favicon.ico", "GET", &handleFavicon);
-    ResourceNode *nodeRoot = new ResourceNode("/", "GET", &handleRoot);
-    ResourceNode *nodeStaticBrowse = new ResourceNode("/static", "GET", &handleStaticBrowse);
-    ResourceNode *nodeStaticPOST = new ResourceNode("/static", "POST", &handleStaticPost);
-    ResourceNode *nodeStatic = new ResourceNode("/static/*", "GET", &handleStatic);
+
     ResourceNode *nodeRestart = new ResourceNode("/restart", "POST", &handleRestart);
-    ResourceNode *node404 = new ResourceNode("", "GET", &handle404);
     ResourceNode *nodeFormUpload = new ResourceNode("/upload", "POST", &handleFormUpload);
+
     ResourceNode *nodeJsonScanNetworks = new ResourceNode("/json/scanNetworks", "GET", &handleScanNetworks);
     ResourceNode *nodeJsonBlinkLED = new ResourceNode("/json/blink", "POST", &handleBlinkLED);
     ResourceNode *nodeJsonReport = new ResourceNode("/json/report", "GET", &handleReport);
     ResourceNode *nodeJsonSpiffsBrowseStatic = new ResourceNode("/json/spiffs/browse/static", "GET", &handleSpiffsBrowseStatic);
     ResourceNode *nodeJsonDelete = new ResourceNode("/json/spiffs/delete/static", "DELETE", &handleSpiffsDeleteStatic);
+    
+    ResourceNode *nodeRoot = new ResourceNode("/*", "GET", &handleStatic);
 
     // Secure nodes
     secureServer->registerNode(nodeAPIv1ToRadioOptions);
@@ -99,11 +96,6 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     secureServer->registerNode(nodeAPIv1FromRadio);
     secureServer->registerNode(nodeHotspotApple);
     secureServer->registerNode(nodeHotspotAndroid);
-    secureServer->registerNode(nodeFavicon);
-    secureServer->registerNode(nodeRoot);
-    secureServer->registerNode(nodeStaticBrowse);
-    secureServer->registerNode(nodeStaticPOST);
-    secureServer->registerNode(nodeStatic);
     secureServer->registerNode(nodeRestart);
     secureServer->registerNode(nodeFormUpload);
     secureServer->registerNode(nodeJsonScanNetworks);
@@ -111,7 +103,7 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     secureServer->registerNode(nodeJsonSpiffsBrowseStatic);
     secureServer->registerNode(nodeJsonDelete);
     secureServer->registerNode(nodeJsonReport);
-    secureServer->setDefaultNode(node404);
+    secureServer->registerNode(nodeRoot);
 
     secureServer->addMiddleware(&middlewareSpeedUp240);
 
@@ -121,11 +113,6 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     insecureServer->registerNode(nodeAPIv1FromRadio);
     insecureServer->registerNode(nodeHotspotApple);
     insecureServer->registerNode(nodeHotspotAndroid);
-    insecureServer->registerNode(nodeFavicon);
-    insecureServer->registerNode(nodeRoot);
-    insecureServer->registerNode(nodeStaticBrowse);
-    insecureServer->registerNode(nodeStaticPOST);
-    insecureServer->registerNode(nodeStatic);
     insecureServer->registerNode(nodeRestart);
     insecureServer->registerNode(nodeFormUpload);
     insecureServer->registerNode(nodeJsonScanNetworks);
@@ -133,7 +120,7 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     insecureServer->registerNode(nodeJsonSpiffsBrowseStatic);
     insecureServer->registerNode(nodeJsonDelete);
     insecureServer->registerNode(nodeJsonReport);
-    insecureServer->setDefaultNode(node404);
+    insecureServer->registerNode(nodeRoot);
 
     insecureServer->addMiddleware(&middlewareSpeedUp160);
 }
@@ -180,11 +167,8 @@ void handleAPIv1FromRadio(HTTPRequest *req, HTTPResponse *res)
 
     /*
         For documentation, see:
-            https://github.com/meshtastic/Meshtastic-device/wiki/HTTP-REST-API-discussion
-            https://github.com/meshtastic/Meshtastic-device/blob/master/docs/software/device-api.md
-
-        Example:
-            http://10.10.30.198/api/v1/fromradio
+            https://meshtastic.org/docs/developers/device/http-api
+            https://meshtastic.org/docs/developers/device/device-api
     */
 
     // Get access to the parameters
@@ -233,24 +217,20 @@ void handleAPIv1ToRadio(HTTPRequest *req, HTTPResponse *res)
 
     /*
         For documentation, see:
-            https://github.com/meshtastic/Meshtastic-device/wiki/HTTP-REST-API-discussion
-            https://github.com/meshtastic/Meshtastic-device/blob/master/docs/software/device-api.md
-
-        Example:
-            http://10.10.30.198/api/v1/toradio
+            https://meshtastic.org/docs/developers/device/http-api
+            https://meshtastic.org/docs/developers/device/device-api
     */
 
-    // Status code is 200 OK by default.
-
     res->setHeader("Content-Type", "application/x-protobuf");
     res->setHeader("Access-Control-Allow-Headers", "Content-Type");
     res->setHeader("Access-Control-Allow-Origin", "*");
     res->setHeader("Access-Control-Allow-Methods", "PUT, OPTIONS");
     res->setHeader("X-Protobuf-Schema", "https://raw.githubusercontent.com/meshtastic/Meshtastic-protobufs/master/mesh.proto");
 
+
     if (req->getMethod() == "OPTIONS") {
         res->setStatusCode(204); // Success with no content
-        res->print("");
+        // res->print(""); @todo remove
         return;
     }
 
@@ -264,86 +244,8 @@ void handleAPIv1ToRadio(HTTPRequest *req, HTTPResponse *res)
     DEBUG_MSG("--------------- webAPI handleAPIv1ToRadio\n");
 }
 
-void handleFavicon(HTTPRequest *req, HTTPResponse *res)
-{
-    // Set Content-Type
-    res->setHeader("Content-Type", "image/vnd.microsoft.icon");
-    // Write data from header file
-    res->write(FAVICON_DATA, FAVICON_LENGTH);
-}
-
-void handleStaticPost(HTTPRequest *req, HTTPResponse *res)
-{
-    // Assume POST request. Contains submitted data.
-    res->println("<html><head><title>File Edited</title><meta http-equiv=\"refresh\" content=\"1;url=/static\" "
-                 "/><head><body><h1>File Edited</h1>");
-
-    // The form is submitted with the x-www-form-urlencoded content type, so we need the
-    // HTTPURLEncodedBodyParser to read the fields.
-    // Note that the content of the file's content comes from a <textarea>, so we
-    // can use the URL encoding here, since no file upload from an <input type="file"
-    // is involved.
-    HTTPURLEncodedBodyParser parser(req);
-
-    // The bodyparser will consume the request body. That means you can iterate over the
-    // fields only ones. For that reason, we need to create variables for all fields that
-    // we expect. So when parsing is done, you can process the field values from your
-    // temporary variables.
-    std::string filename;
-    bool savedFile = false;
-
-    // Iterate over the fields from the request body by calling nextField(). This function
-    // will update the field name and value of the body parsers. If the last field has been
-    // reached, it will return false and the while loop stops.
-    while (parser.nextField()) {
-        // Get the field name, so that we can decide what the value is for
-        std::string name = parser.getFieldName();
-
-        if (name == "filename") {
-            // Read the filename from the field's value, add the /public prefix and store it in
-            // the filename variable.
-            char buf[512];
-            size_t readLength = parser.read((byte *)buf, 512);
-            // filename = std::string("/public/") + std::string(buf, readLength);
-            filename = std::string(buf, readLength);
-
-        } else if (name == "content") {
-            // Browsers must return the fields in the order that they are placed in
-            // the HTML form, so if the broweser behaves correctly, this condition will
-            // never be true. We include it for safety reasons.
-            if (filename == "") {
-                res->println("<p>Error: form contained content before filename.</p>");
-                break;
-            }
-
-            // With parser.read() and parser.endOfField(), we can stream the field content
-            // into a buffer. That allows handling arbitrarily-sized field contents. Here,
-            // we use it and write the file contents directly to the SPIFFS:
-            size_t fieldLength = 0;
-            File file = SPIFFS.open(filename.c_str(), "w");
-            savedFile = true;
-            while (!parser.endOfField()) {
-                byte buf[512];
-                size_t readLength = parser.read(buf, 512);
-                file.write(buf, readLength);
-                fieldLength += readLength;
-            }
-            file.close();
-            res->printf("<p>Saved %d bytes to %s</p>", int(fieldLength), filename.c_str());
-
-        } else {
-            res->printf("<p>Unexpected field %s</p>", name.c_str());
-        }
-    }
-    if (!savedFile) {
-        res->println("<p>No file to save...</p>");
-    }
-    res->println("</body></html>");
-}
-
 void handleSpiffsBrowseStatic(HTTPRequest *req, HTTPResponse *res)
 {
-    // jm
 
     res->setHeader("Content-Type", "application/json");
     res->setHeader("Access-Control-Allow-Origin", "*");
@@ -422,206 +324,6 @@ void handleSpiffsDeleteStatic(HTTPRequest *req, HTTPResponse *res)
     }
 }
 
-/*
-    To convert text to c strings:
-
-    https://tomeko.net/online_tools/cpp_text_escape.php?lang=en
-*/
-void handleRoot(HTTPRequest *req, HTTPResponse *res)
-{
-    res->setHeader("Content-Type", "text/html");
-
-    res->setHeader("Set-Cookie",
-                   "mt_session=" + httpsserver::intToString(random(1, 9999999)) + "; Expires=Wed, 20 Apr 2049 4:20:00 PST");
-
-    std::string cookie = req->getHeader("Cookie");
-    // String cookieString = cookie.c_str();
-    // uint8_t nameIndex = cookieString.indexOf("mt_session");
-    // DEBUG_MSG(cookie.c_str());
-
-    std::string filename = "/static/index.html";
-    std::string filenameGzip = "/static/index.html.gz";
-
-    if (!SPIFFS.exists(filename.c_str()) && !SPIFFS.exists(filenameGzip.c_str())) {
-        // Send "404 Not Found" as response, as the file doesn't seem to exist
-        res->setStatusCode(404);
-        res->setStatusText("Not found");
-        res->println("404 Not Found");
-        res->printf("<p>File not found: %s</p>\n", filename.c_str());
-        res->printf("<p></p>\n");
-        res->printf("<p>You have gotten this error because the filesystem for the web server has not been loaded.</p>\n");
-        res->printf("<p>Please review the 'Common Problems' section of the <a "
-                    "href=https://github.com/meshtastic/Meshtastic-device/wiki/"
-                    "How-to-use-the-Meshtastic-Web-Interface-over-WiFi>web interface</a> documentation.</p>\n");
-        return;
-    }
-
-    // Try to open the file from SPIFFS
-    File file;
-
-    if (SPIFFS.exists(filename.c_str())) {
-        file = SPIFFS.open(filename.c_str());
-        if (!file.available()) {
-            DEBUG_MSG("File not available - %s\n", filename.c_str());
-        }
-
-    } else if (SPIFFS.exists(filenameGzip.c_str())) {
-        file = SPIFFS.open(filenameGzip.c_str());
-        res->setHeader("Content-Encoding", "gzip");
-        if (!file.available()) {
-            DEBUG_MSG("File not available\n");
-        }
-    }
-
-    // Read the file from SPIFFS and write it to the HTTP response body
-    size_t length = 0;
-    do {
-        char buffer[256];
-        length = file.read((uint8_t *)buffer, 256);
-        std::string bufferString(buffer, length);
-        res->write((uint8_t *)bufferString.c_str(), bufferString.size());
-    } while (length > 0);
-}
-
-void handleStaticBrowse(HTTPRequest *req, HTTPResponse *res)
-{
-    // Get access to the parameters
-    ResourceParameters *params = req->getParams();
-    std::string paramValDelete;
-    std::string paramValEdit;
-
-    DEBUG_MSG("Static Browse - Disabling keep-alive\n");
-    res->setHeader("Connection", "close");
-
-    // Set a default content type
-    res->setHeader("Content-Type", "text/html");
-
-    if (params->getQueryParameter("delete", paramValDelete)) {
-        std::string pathDelete = "/" + paramValDelete;
-        if (SPIFFS.remove(pathDelete.c_str())) {
-            Serial.println(pathDelete.c_str());
-            res->println("<html><head><meta http-equiv=\"refresh\" content=\"1;url=/static\" /><title>File "
-                         "deleted!</title></head><body><h1>File deleted!</h1>");
-            res->println("<meta http-equiv=\"refresh\" 1;url=/static\" />\n");
-            res->println("</body></html>");
-
-            return;
-        } else {
-            Serial.println(pathDelete.c_str());
-            res->println("<html><head><meta http-equiv=\"refresh\" content=\"1;url=/static\" /><title>Error deleteing "
-                         "file!</title></head><body><h1>Error deleteing file!</h1>");
-            res->println("Error deleteing file!<br>");
-
-            return;
-        }
-    }
-
-    if (params->getQueryParameter("edit", paramValEdit)) {
-        std::string pathEdit = "/" + paramValEdit;
-        res->println("<html><head><title>Edit "
-                     "file</title></head><body><h1>Edit file - ");
-
-        res->println(pathEdit.c_str());
-
-        res->println("</h1>");
-        res->println("<form method=post action=/static enctype=application/x-www-form-urlencoded>");
-        res->printf("<input name=\"filename\" type=\"hidden\" value=\"%s\">", pathEdit.c_str());
-        res->print("<textarea id=id name=content rows=20 cols=80>");
-
-        // Try to open the file from SPIFFS
-        File file = SPIFFS.open(pathEdit.c_str());
-
-        if (file.available()) {
-            // Read the file from SPIFFS and write it to the HTTP response body
-            size_t length = 0;
-            do {
-                char buffer[256];
-                length = file.read((uint8_t *)buffer, 256);
-                std::string bufferString(buffer, length);
-
-                // Escape gt and lt
-                replaceAll(bufferString, "<", "&lt;");
-                replaceAll(bufferString, ">", "&gt;");
-
-                res->write((uint8_t *)bufferString.c_str(), bufferString.size());
-            } while (length > 0);
-        } else {
-            res->println("Error: File not found");
-        }
-
-        res->println("</textarea><br>");
-        res->println("<input type=submit value=Submit>");
-        res->println("</form>");
-        res->println("</body></html>");
-
-        return;
-    }
-
-    res->println("<h2>Upload new file</h2>");
-    res->println("<p>This form allows you to upload files. Keep your filenames small and files under 200k.</p>");
-    res->println("<form method=\"POST\" action=\"/upload\" enctype=\"multipart/form-data\">");
-    res->println("file: <input type=\"file\" name=\"file\"><br>");
-    res->println("<input type=\"submit\" value=\"Upload\">");
-    res->println("</form>");
-
-    res->println("<h2>All Files</h2>");
-
-    File root = SPIFFS.open("/");
-    if (root.isDirectory()) {
-        res->println("<script type=\"text/javascript\">function confirm_delete() {return confirm('Are you sure?');}</script>");
-
-        res->println("<table>");
-        res->println("<tr>");
-        res->println("<td>File");
-        res->println("</td>");
-        res->println("<td>Size");
-        res->println("</td>");
-        res->println("<td colspan=2>Actions");
-        res->println("</td>");
-        res->println("</tr>");
-
-        File file = root.openNextFile();
-        while (file) {
-            String filePath = String(file.name());
-            if (filePath.indexOf("/static") == 0) {
-                res->println("<tr>");
-                res->println("<td>");
-
-                if (String(file.name()).substring(1).endsWith(".gz")) {
-                    String modifiedFile = String(file.name()).substring(1);
-                    modifiedFile.remove((modifiedFile.length() - 3), 3);
-                    res->print("<a href=\"" + modifiedFile + "\">" + String(file.name()).substring(1) + "</a>");
-                } else {
-                    res->print("<a href=\"" + String(file.name()).substring(1) + "\">" + String(file.name()).substring(1) +
-                               "</a>");
-                }
-                res->println("</td>");
-                res->println("<td>");
-                res->print(String(file.size()));
-                res->println("</td>");
-                res->println("<td>");
-                res->print("<a href=\"/static?delete=" + String(file.name()).substring(1) +
-                           "\" onclick=\"return confirm_delete()\">Delete</a> ");
-                res->println("</td>");
-                res->println("<td>");
-                if (!String(file.name()).substring(1).endsWith(".gz")) {
-                    res->print("<a href=\"/static?edit=" + String(file.name()).substring(1) + "\">Edit</a>");
-                }
-                res->println("</td>");
-                res->println("</tr>");
-            }
-
-            file = root.openNextFile();
-        }
-        res->println("</table>");
-
-        res->print("<br>");
-        // res->print("Total : " + String(SPIFFS.totalBytes()) + " Bytes<br>");
-        res->print("Used : " + String(SPIFFS.usedBytes()) + " Bytes<br>");
-        res->print("Free : " + String(SPIFFS.totalBytes() - SPIFFS.usedBytes()) + " Bytes<br>");
-    }
-}
-
 void handleStatic(HTTPRequest *req, HTTPResponse *res)
 {
     // Get access to the parameters
@@ -634,35 +336,33 @@ void handleStatic(HTTPRequest *req, HTTPResponse *res)
         std::string filename = "/static/" + parameter1;
         std::string filenameGzip = "/static/" + parameter1 + ".gz";
 
-        if (!SPIFFS.exists(filename.c_str()) && !SPIFFS.exists(filenameGzip.c_str())) {
-            // Send "404 Not Found" as response, as the file doesn't seem to exist
-            res->setStatusCode(404);
-            res->setStatusText("Not found");
-            res->println("404 Not Found");
-            res->printf("<p>File not found: %s</p>\n", filename.c_str());
-            return;
-        }
 
         // Try to open the file from SPIFFS
         File file;
 
+        bool has_set_content_type = false;
+
         if (SPIFFS.exists(filename.c_str())) {
             file = SPIFFS.open(filename.c_str());
             if (!file.available()) {
                 DEBUG_MSG("File not available - %s\n", filename.c_str());
             }
-
         } else if (SPIFFS.exists(filenameGzip.c_str())) {
             file = SPIFFS.open(filenameGzip.c_str());
             res->setHeader("Content-Encoding", "gzip");
             if (!file.available()) {
                 DEBUG_MSG("File not available\n");
             }
+        } else {
+            has_set_content_type = true;
+            filenameGzip = "/static/index.html.gz";
+            file = SPIFFS.open(filenameGzip.c_str());
+            res->setHeader("Content-Encoding", "gzip");
+            res->setHeader("Content-Type", "text/html");
         }
 
         res->setHeader("Content-Length", httpsserver::intToString(file.size()));
 
-        bool has_set_content_type = false;
         // Content-Type is guessed using the definition of the contentTypes-table defined above
         int cTypeIdx = 0;
         do {
@@ -949,30 +649,6 @@ void handleReport(HTTPRequest *req, HTTPResponse *res)
     res->println("}");
 }
 
-// --------
-
-void handle404(HTTPRequest *req, HTTPResponse *res)
-{
-
-    // Discard request body, if we received any
-    // We do this, as this is the default node and may also server POST/PUT requests
-    req->discardRequestBody();
-
-    // Set the response status
-    res->setStatusCode(404);
-    res->setStatusText("Not Found");
-
-    // Set content type of the response
-    res->setHeader("Content-Type", "text/html");
-
-    // Write a tiny HTTP page
-    res->println("<!DOCTYPE html>");
-    res->println("<html>");
-    res->println("<head><title>Not Found</title></head>");
-    res->println("<body><h1>404 Not Found</h1><p>The requested resource was not found on this server.</p></body>");
-    res->println("</html>");
-}
-
 /*
     This supports the Apple Captive Network Assistant (CNA) Portal
 */

src/mesh/http/ContentHandler.h

@@ -5,25 +5,18 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer);
 // Declare some handler functions for the various URLs on the server
 void handleAPIv1FromRadio(HTTPRequest *req, HTTPResponse *res);
 void handleAPIv1ToRadio(HTTPRequest *req, HTTPResponse *res);
-void handleStyleCSS(HTTPRequest *req, HTTPResponse *res);
 void handleHotspot(HTTPRequest *req, HTTPResponse *res);
-void handleRoot(HTTPRequest *req, HTTPResponse *res);
-void handleStaticBrowse(HTTPRequest *req, HTTPResponse *res);
-void handleStaticPost(HTTPRequest *req, HTTPResponse *res);
 void handleStatic(HTTPRequest *req, HTTPResponse *res);
 void handleRestart(HTTPRequest *req, HTTPResponse *res);
-void handle404(HTTPRequest *req, HTTPResponse *res);
 void handleFormUpload(HTTPRequest *req, HTTPResponse *res);
 void handleScanNetworks(HTTPRequest *req, HTTPResponse *res);
 void handleSpiffsBrowseStatic(HTTPRequest *req, HTTPResponse *res);
 void handleSpiffsDeleteStatic(HTTPRequest *req, HTTPResponse *res);
 void handleBlinkLED(HTTPRequest *req, HTTPResponse *res);
 void handleReport(HTTPRequest *req, HTTPResponse *res);
-void handleFavicon(HTTPRequest *req, HTTPResponse *res);
 
 void middlewareSpeedUp240(HTTPRequest *req, HTTPResponse *res, std::function<void()> next);
 void middlewareSpeedUp160(HTTPRequest *req, HTTPResponse *res, std::function<void()> next);
-void middlewareSession(HTTPRequest *req, HTTPResponse *res, std::function<void()> next);
 
 uint32_t getTimeSpeedUp();
 void setTimeSpeedUp();

src/mesh/http/ContentStatic.h

@@ -1,119 +0,0 @@
-#include <Arduino.h>
-#include <functional>
-
-/*
-  This file contains static content.
-*/
-
-// Length of the binary data
-const int FAVICON_LENGTH = 2238;
-
-// Binary data for the favicon
-const byte FAVICON_DATA[] = {
-    0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x20, 0x20, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0xA8, 0x08, 0x00, 0x00, 0x16, 0x00, 0x00,
-    0x00, 0x28, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x84,
-    0xDC, 0x3D, 0x00, 0x84, 0xDC, 0x3C, 0x00, 0x85, 0xDC, 0x3F, 0x00, 0x86, 0xDD, 0x40, 0x00, 0x83, 0xDC, 0x3C, 0x00, 0x85, 0xDC,
-    0x3E, 0x00, 0x82, 0xDC, 0x3A, 0x00, 0x8B, 0xDE, 0x49, 0x00, 0x84, 0xDB, 0x3E, 0x00, 0x82, 0xD9, 0x3C, 0x00, 0x89, 0xDD, 0x45,
-    0x00, 0x83, 0xDB, 0x3C, 0x00, 0x83, 0xD8, 0x3D, 0x00, 0x81, 0xD8, 0x3A, 0x00, 0x8D, 0xE0, 0x49, 0x00, 0x88, 0xE4, 0x3F, 0x00,
-    0x89, 0xE9, 0x3E, 0x00, 0x84, 0xD8, 0x40, 0x00, 0x85, 0xDF, 0x3C, 0x00, 0x8E, 0xF2, 0x40, 0x00, 0x8D, 0xF6, 0x3D, 0x00, 0x90,
-    0xEA, 0x49, 0x00, 0x82, 0xD5, 0x3E, 0x00, 0x78, 0xC1, 0x3A, 0x00, 0x90, 0xE9, 0x4A, 0x00, 0x8E, 0xF5, 0x3D, 0x00, 0x84, 0xDD,
-    0x3D, 0x00, 0x91, 0xF7, 0x43, 0x00, 0x87, 0xE5, 0x3D, 0x00, 0x6C, 0xA2, 0x38, 0x00, 0x53, 0x65, 0x31, 0x00, 0x41, 0x39, 0x2E,
-    0x00, 0x3A, 0x27, 0x2B, 0x00, 0x34, 0x1A, 0x2A, 0x00, 0x41, 0x38, 0x2E, 0x00, 0x82, 0xD8, 0x3D, 0x00, 0x88, 0xE7, 0x3D, 0x00,
-    0x8E, 0xF3, 0x41, 0x00, 0x69, 0x95, 0x39, 0x00, 0x3E, 0x33, 0x2C, 0x00, 0x31, 0x11, 0x29, 0x00, 0x2E, 0x0A, 0x29, 0x00, 0x2D,
-    0x0B, 0x27, 0x00, 0x30, 0x10, 0x29, 0x00, 0x34, 0x18, 0x2A, 0x00, 0x3E, 0x31, 0x2C, 0x00, 0x68, 0x95, 0x39, 0x00, 0x88, 0xE7,
-    0x3E, 0x00, 0x82, 0xD7, 0x3C, 0x00, 0x84, 0xDD, 0x3C, 0x00, 0x8B, 0xEE, 0x3E, 0x00, 0x85, 0xDF, 0x3D, 0x00, 0x47, 0x48, 0x2E,
-    0x00, 0x30, 0x0F, 0x29, 0x00, 0x31, 0x13, 0x29, 0x00, 0x48, 0x4D, 0x2E, 0x00, 0x61, 0x7F, 0x39, 0x00, 0x6A, 0x9C, 0x38, 0x00,
-    0x75, 0xB8, 0x39, 0x00, 0x85, 0xDE, 0x3D, 0x00, 0x8C, 0xEF, 0x3E, 0x00, 0x89, 0xDE, 0x44, 0x00, 0x80, 0xD1, 0x3C, 0x00, 0x3A,
-    0x28, 0x2C, 0x00, 0x32, 0x16, 0x2A, 0x00, 0x33, 0x17, 0x2A, 0x00, 0x4B, 0x50, 0x30, 0x00, 0x76, 0xBA, 0x3A, 0x00, 0x8A, 0xEF,
-    0x3C, 0x00, 0x9A, 0xFE, 0x4D, 0x00, 0x95, 0xFF, 0x43, 0x00, 0x93, 0xFF, 0x40, 0x00, 0x4B, 0x52, 0x30, 0x00, 0x7E, 0xCE, 0x3C,
-    0x00, 0x87, 0xD9, 0x44, 0x00, 0x34, 0x1B, 0x2A, 0x00, 0x65, 0x90, 0x36, 0x00, 0x8E, 0xF6, 0x3D, 0x00, 0x8F, 0xF7, 0x40, 0x00,
-    0x8B, 0xDD, 0x48, 0x00, 0x73, 0xB1, 0x3A, 0x00, 0x66, 0x95, 0x35, 0x00, 0x66, 0x93, 0x35, 0x00, 0x35, 0x1B, 0x2A, 0x00, 0x8D,
-    0xE8, 0x45, 0x00, 0x82, 0xD9, 0x3B, 0x00, 0x72, 0xAA, 0x3C, 0x00, 0x95, 0xFD, 0x46, 0x00, 0x8D, 0xF0, 0x40, 0x00, 0x57, 0x70,
-    0x32, 0x00, 0x3C, 0x2D, 0x2C, 0x00, 0x2F, 0x0D, 0x29, 0x00, 0x81, 0xD4, 0x3D, 0x00, 0x8D, 0xF1, 0x40, 0x00, 0x94, 0xFC, 0x46,
-    0x00, 0x73, 0xAE, 0x3D, 0x00, 0x45, 0x44, 0x2D, 0x00, 0x94, 0xF5, 0x49, 0x00, 0x90, 0xF0, 0x45, 0x00, 0x73, 0xAF, 0x3B, 0x00,
-    0x38, 0x21, 0x2C, 0x00, 0x30, 0x11, 0x29, 0x00, 0x2F, 0x0F, 0x28, 0x00, 0x72, 0xAC, 0x3B, 0x00, 0x6A, 0x93, 0x3D, 0x00, 0x2E,
-    0x0D, 0x27, 0x00, 0x35, 0x1C, 0x2B, 0x00, 0x36, 0x20, 0x2A, 0x00, 0x5E, 0x77, 0x39, 0x00, 0x78, 0xBE, 0x3B, 0x00, 0x36, 0x21,
-    0x2A, 0x00, 0x71, 0xAB, 0x3B, 0x00, 0x4C, 0x54, 0x30, 0x00, 0x3D, 0x31, 0x2B, 0x00, 0x82, 0xD6, 0x3D, 0x00, 0x79, 0xC5, 0x39,
-    0x00, 0x9A, 0xFF, 0x4D, 0x00, 0x8A, 0xE8, 0x40, 0x00, 0x8A, 0xE7, 0x40, 0x00, 0x7A, 0xC6, 0x39, 0x00, 0x3D, 0x2E, 0x2C, 0x00,
-    0x81, 0xD5, 0x3D, 0x00, 0x77, 0xBC, 0x3A, 0x00, 0x31, 0x12, 0x2A, 0x00, 0x69, 0x9B, 0x37, 0x00, 0x8E, 0xF3, 0x40, 0x00, 0x83,
-    0xDC, 0x3B, 0x00, 0x8C, 0xF6, 0x3B, 0x00, 0x88, 0xD9, 0x45, 0x00, 0x86, 0xE1, 0x3D, 0x00, 0x85, 0xE0, 0x3D, 0x00, 0x7B, 0xC8,
-    0x39, 0x00, 0x36, 0x1F, 0x29, 0x00, 0x55, 0x6B, 0x32, 0x00, 0x8A, 0xEE, 0x3C, 0x00, 0x48, 0x4B, 0x2E, 0x00, 0x51, 0x61, 0x31,
-    0x00, 0x8C, 0xE0, 0x48, 0x00, 0x8B, 0xDE, 0x47, 0x00, 0x98, 0xEE, 0x55, 0x00, 0x5D, 0x79, 0x36, 0x00, 0x3A, 0x2A, 0x2B, 0x00,
-    0x3A, 0x29, 0x2B, 0x00, 0x5C, 0x78, 0x36, 0x00, 0x60, 0x7C, 0x3A, 0x00, 0x3D, 0x30, 0x2C, 0x00, 0x99, 0xFD, 0x4C, 0x00, 0x66,
-    0x8A, 0x3C, 0x00, 0x2D, 0x0C, 0x27, 0x00, 0x42, 0x3C, 0x2E, 0x00, 0x84, 0xDA, 0x3E, 0x00, 0x88, 0xE5, 0x3F, 0x00, 0x37, 0x22,
-    0x2B, 0x00, 0x2E, 0x0B, 0x28, 0x00, 0x6A, 0x9B, 0x37, 0x00, 0x72, 0xAF, 0x3A, 0x00, 0x32, 0x15, 0x29, 0x00, 0x2A, 0x00, 0x28,
-    0x00, 0x5B, 0x75, 0x35, 0x00, 0x89, 0xE8, 0x3D, 0x00, 0x78, 0xBF, 0x3A, 0x00, 0x73, 0xB4, 0x38, 0x00, 0x83, 0xDA, 0x3C, 0x00,
-    0x84, 0xDE, 0x3C, 0x00, 0x85, 0xDD, 0x3E, 0x00, 0x86, 0xDE, 0x40, 0x00, 0x84, 0xDE, 0x3B, 0x00, 0x86, 0xE2, 0x3C, 0x00, 0x85,
-    0xDD, 0x3F, 0x00, 0x87, 0xE2, 0x3F, 0x00, 0x87, 0xE1, 0x3E, 0x00, 0x85, 0xDE, 0x3E, 0x00, 0x89, 0xE2, 0x41, 0x00, 0x89, 0xE2,
-    0x43, 0x00, 0x84, 0xDC, 0x3E, 0x00, 0x83, 0xD8, 0x3E, 0x00, 0x90, 0xF6, 0x41, 0x00, 0x2B, 0x04, 0x28, 0x00, 0x8C, 0xE3, 0x47,
-    0x00, 0x8B, 0xDE, 0x48, 0x00, 0x8A, 0xDC, 0x47, 0x00, 0x8A, 0xDD, 0x47, 0x00, 0x8D, 0xDD, 0x4A, 0x00, 0x8A, 0xDE, 0x47, 0x00,
-    0x8B, 0xDD, 0x49, 0x00, 0x8B, 0xE0, 0x46, 0x00, 0x9A, 0xF2, 0x55, 0x00, 0x59, 0x70, 0x35, 0x00, 0x8F, 0xDE, 0x4F, 0x00, 0x82,
-    0xDC, 0x3B, 0x00, 0x82, 0xDB, 0x39, 0x00, 0x7F, 0xD7, 0x38, 0x00, 0x92, 0xF0, 0x48, 0x00, 0x33, 0x19, 0x29, 0x00, 0x87, 0xDD,
-    0x42, 0x00, 0x87, 0xDD, 0x41, 0x00, 0x92, 0xEC, 0x4B, 0x00, 0x78, 0xBD, 0x3C, 0x00, 0x86, 0xDD, 0x3F, 0x00, 0x81, 0xD9, 0x39,
-    0x00, 0x7B, 0xC4, 0x3C, 0x00, 0x34, 0x1A, 0x29, 0x00, 0x89, 0xDD, 0x44, 0x00, 0x86, 0xDC, 0x40, 0x00, 0x88, 0xDD, 0x44, 0x00,
-    0x87, 0xDE, 0x41, 0x00, 0x99, 0xFA, 0x4F, 0x00, 0x7B, 0xC3, 0x3E, 0x00, 0x83, 0xD7, 0x3F, 0x00, 0x8B, 0xED, 0x3E, 0x00, 0x40,
-    0x33, 0x2F, 0x00, 0x39, 0x27, 0x2B, 0x00, 0x81, 0xD7, 0x3B, 0x00, 0x3B, 0x2C, 0x2A, 0x00, 0x33, 0x18, 0x29, 0x00, 0x38, 0x22,
-    0x2B, 0x00, 0x85, 0xDA, 0x40, 0x00, 0x89, 0xEA, 0x3D, 0x00, 0x6F, 0xA9, 0x38, 0x00, 0x70, 0xAB, 0x38, 0x00, 0x85, 0xDD, 0x3D,
-    0x00, 0x88, 0xE1, 0x40, 0x00, 0x36, 0x1F, 0x2B, 0x00, 0x30, 0x13, 0x28, 0x00, 0x68, 0x9A, 0x36, 0x00, 0x90, 0xFB, 0x3F, 0x00,
-    0x8A, 0xDD, 0x46, 0x00, 0x8D, 0xE9, 0x45, 0x00, 0x5A, 0x71, 0x36, 0x00, 0x27, 0x00, 0x24, 0x00, 0x73, 0x9F, 0x45, 0x00, 0x97,
-    0xFE, 0x4A, 0x00, 0x86, 0xD8, 0x43, 0x00, 0x73, 0xA1, 0x45, 0x00, 0x8E, 0xDF, 0x4C, 0x00, 0x85, 0xDB, 0x40, 0x00, 0x72, 0xB5,
-    0x37, 0x00, 0x95, 0xF4, 0x4B, 0x00, 0x73, 0xB6, 0x37, 0x00, 0x88, 0xE9, 0x3C, 0x00, 0x8A, 0xDB, 0x48, 0x00, 0x8C, 0xDE, 0x49,
-    0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x01, 0x02, 0x03, 0x04, 0xAE, 0x06, 0xF1, 0x02, 0x04, 0x04, 0x02, 0xF1, 0x06, 0xAE, 0x04, 0x03, 0x02, 0x01, 0x00, 0x01,
-    0x0A, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0xAE, 0xC7, 0xF1, 0x02, 0x04,
-    0x04, 0x02, 0xF1, 0xC7, 0xAE, 0x04, 0x03, 0x02, 0x01, 0x00, 0x01, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x01, 0x02, 0x03, 0x0B, 0xAE, 0xEF, 0xF0, 0x02, 0x01, 0x01, 0x02, 0xB4, 0xEF, 0xAE, 0x0B, 0x03, 0x02, 0x01, 0x00,
-    0x01, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x05, 0xEB, 0xA7, 0xD1, 0xEC, 0xED, 0x96,
-    0x04, 0x04, 0x96, 0xED, 0xEE, 0xD1, 0xA7, 0xEB, 0x05, 0x04, 0x01, 0x04, 0xCA, 0x04, 0x01, 0x01, 0x01, 0xCA, 0xCA, 0xCA, 0xCA,
-    0xCA, 0xCA, 0xCA, 0xCC, 0xE2, 0x8A, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE8, 0xE7, 0xE9, 0xE5, 0xBB, 0xE3, 0x8A, 0xE2, 0xCC,
-    0xCA, 0xCC, 0xEA, 0xCC, 0xCA, 0xCA, 0xCA, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x08, 0xDD, 0x55, 0xDE, 0x2C, 0xDF,
-    0xE0, 0xE1, 0xE1, 0xE0, 0xDF, 0x2C, 0xDE, 0x55, 0xDD, 0x08, 0x04, 0x01, 0x04, 0xCA, 0x04, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x01, 0xC6, 0xD8, 0xD9, 0xAB, 0x78, 0x6A, 0x28, 0xDA, 0xDB, 0x28, 0x6A, 0x5A, 0xDC, 0xD9, 0xD8, 0xC6,
-    0x01, 0x00, 0x01, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x05, 0x03, 0xD4, 0xD1, 0x31,
-    0xD5, 0xD6, 0x98, 0xD7, 0xD6, 0xD5, 0x0B, 0x32, 0xD4, 0x03, 0x05, 0x04, 0x01, 0x04, 0xCA, 0x04, 0x01, 0x01, 0x01, 0x02, 0x02,
-    0x02, 0x02, 0x02, 0x02, 0x02, 0x05, 0xC3, 0xC2, 0xA4, 0xD0, 0xD1, 0xB3, 0xD2, 0xD3, 0xD3, 0xD2, 0x4F, 0x32, 0xD0, 0xA4, 0xC2,
-    0xC3, 0x05, 0x02, 0x05, 0xB7, 0x05, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0xCB, 0xC2, 0xCC, 0x02, 0xCD,
-    0x79, 0xCE, 0xCF, 0xC1, 0xC1, 0xCF, 0xCE, 0x79, 0xCD, 0x02, 0xCC, 0xC2, 0xCB, 0x03, 0xCB, 0xB3, 0xCB, 0x03, 0x03, 0x03, 0x04,
-    0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x7E, 0x05, 0xC6, 0x7E, 0x00, 0xC7, 0x15, 0xC8, 0xC9, 0xC9, 0xC8, 0x15, 0xC7, 0x00, 0x7E,
-    0xC6, 0x05, 0x7E, 0x04, 0x7E, 0xCA, 0x7E, 0x04, 0x04, 0x04, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0xAE, 0x00, 0x03, 0xC3, 0x00,
-    0x05, 0x55, 0xC4, 0xC5, 0xC1, 0xC1, 0xC5, 0xC4, 0x55, 0x05, 0x00, 0xC3, 0x03, 0x00, 0xAE, 0x00, 0x3D, 0x00, 0xAE, 0xAE, 0xAE,
-    0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0x7E, 0xBE, 0x00, 0x05, 0xBE, 0x7E, 0xBF, 0xC0, 0x5C, 0xC1, 0xC1, 0x5C, 0xC0, 0xBF, 0x7E,
-    0xBE, 0x05, 0x00, 0xBE, 0x7E, 0xBE, 0xC2, 0x06, 0xBD, 0xBD, 0xBD, 0xB3, 0xB3, 0xB3, 0xB4, 0xB5, 0xB3, 0xB3, 0xB5, 0xB6, 0xB6,
-    0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0x6B, 0x6B, 0xBB, 0xBA, 0xB9, 0xB8, 0xB7, 0xB6, 0xB6, 0xB5, 0xB3, 0xB5, 0xBC, 0xB4, 0xB3, 0xB3,
-    0xB3, 0x02, 0x02, 0xA8, 0xA9, 0xAA, 0xA8, 0x02, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0x8F, 0xB1, 0x71, 0x2D, 0xB1, 0x9E, 0xB0,
-    0xAF, 0xAE, 0xAD, 0xAC, 0xAB, 0x02, 0xA4, 0xB2, 0xAA, 0xA8, 0x02, 0x02, 0x04, 0x31, 0xA3, 0x04, 0x31, 0x82, 0x3B, 0xA3, 0xA4,
-    0xA5, 0xA6, 0x82, 0xA7, 0x8E, 0x20, 0x78, 0x78, 0x20, 0x8E, 0xA7, 0x82, 0xA6, 0xA5, 0xA4, 0xA3, 0x3B, 0x82, 0x3D, 0x04, 0xA3,
-    0x31, 0x04, 0x09, 0x9F, 0xA0, 0x21, 0x2C, 0xA1, 0x47, 0x52, 0x5B, 0x5A, 0xA2, 0x1C, 0x81, 0x8D, 0x8E, 0x91, 0x91, 0x8E, 0x8D,
-    0x81, 0x1C, 0xA2, 0x5A, 0x5B, 0x52, 0x47, 0xA1, 0x2C, 0x21, 0xA0, 0x9F, 0x09, 0x96, 0x97, 0x16, 0x98, 0x99, 0x9A, 0x46, 0x9B,
-    0x28, 0x9C, 0x6D, 0x76, 0x7D, 0x8C, 0x9D, 0x8E, 0x8E, 0x9D, 0x9E, 0x7D, 0x75, 0x6D, 0x9C, 0x65, 0x9B, 0x46, 0x39, 0x99, 0x98,
-    0x16, 0x97, 0x96, 0x4F, 0x89, 0x15, 0x1F, 0x69, 0x38, 0x45, 0x8A, 0x78, 0x66, 0x6C, 0x74, 0x4A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F,
-    0x8B, 0x80, 0x45, 0x90, 0x66, 0x91, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x15, 0x89, 0x4F, 0x7E, 0x0D, 0x14, 0x1E, 0x29, 0x37, 0x44,
-    0x14, 0x59, 0x65, 0x6B, 0x73, 0x7F, 0x80, 0x25, 0x81, 0x82, 0x25, 0x80, 0x7F, 0x83, 0x84, 0x65, 0x85, 0x4D, 0x86, 0x87, 0x29,
-    0x88, 0x14, 0x0D, 0x7E, 0x05, 0x0C, 0x13, 0x1D, 0x28, 0x2C, 0x43, 0x4E, 0x72, 0x64, 0x53, 0x5A, 0x73, 0x74, 0x75, 0x1C, 0x1C,
-    0x76, 0x74, 0x77, 0x78, 0x6A, 0x64, 0x79, 0x4E, 0x7A, 0x2C, 0x7B, 0x7C, 0x7D, 0x0C, 0x05, 0x04, 0x0B, 0x12, 0x1C, 0x27, 0x36,
-    0x42, 0x4D, 0x5D, 0x63, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x1A, 0x1A, 0x6D, 0x6C, 0x6E, 0x53, 0x69, 0x6F, 0x5D, 0x19, 0x70, 0x36,
-    0x71, 0x24, 0x12, 0x0B, 0x04, 0x03, 0x03, 0x11, 0x1B, 0x2E, 0x35, 0x41, 0x4C, 0x5E, 0x62, 0x63, 0x64, 0x65, 0x66, 0x2C, 0x5A,
-    0x5A, 0x2C, 0x66, 0x65, 0x64, 0x67, 0x62, 0x5E, 0x52, 0x40, 0x65, 0x68, 0x1B, 0x11, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x25,
-    0x34, 0x40, 0x4B, 0x56, 0x57, 0x58, 0x16, 0x59, 0x5A, 0x41, 0x5B, 0x5B, 0x41, 0x5A, 0x59, 0x5C, 0x5D, 0x5E, 0x5F, 0x21, 0x41,
-    0x60, 0x61, 0x05, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x09, 0x24, 0x33, 0x3F, 0x2C, 0x4B, 0x4C, 0x4D, 0x4E, 0x14, 0x4F, 0x50,
-    0x51, 0x51, 0x50, 0x4F, 0x14, 0x4E, 0x4D, 0x52, 0x53, 0x2C, 0x3F, 0x01, 0x54, 0x55, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x1A,
-    0x23, 0x32, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x47, 0x46, 0x45, 0x44, 0x43, 0x48, 0x41, 0x40, 0x3F,
-    0x49, 0x3C, 0x4A, 0x1A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1A, 0x30, 0x32, 0x33, 0x34, 0x35, 0x36, 0x2C, 0x37, 0x38,
-    0x39, 0x3A, 0x3A, 0x39, 0x38, 0x37, 0x2C, 0x36, 0x35, 0x34, 0x3B, 0x3C, 0x30, 0x3D, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x1A, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2C, 0x2B, 0x2A, 0x29, 0x28, 0x2D, 0x2E, 0x13,
-    0x2F, 0x30, 0x31, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1A, 0x09, 0x02, 0x1B, 0x1C, 0x1D, 0x1E,
-    0x1F, 0x20, 0x21, 0x21, 0x20, 0x22, 0x1E, 0x1D, 0x1C, 0x1B, 0x02, 0x09, 0x1A, 0x01, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x17, 0x16, 0x18, 0x19, 0x13, 0x12, 0x11,
-    0x02, 0x01, 0x00, 0x01, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x0B, 0x0C,
-    0x0D, 0x0E, 0x0F, 0x10, 0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x03, 0x02, 0x01, 0x00, 0x01, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04,
-    0x03, 0x02, 0x01, 0x00, 0x01, 0x0A, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

src/mesh/http/WebServer.cpp

@@ -5,7 +5,6 @@
 #include <HTTPMultipartBodyParser.hpp>
 #include <HTTPURLEncodedBodyParser.hpp>
 
-
 #include <WebServer.h>
 #include <WiFi.h>
 
@@ -13,7 +12,6 @@
 #include "esp_task_wdt.h"
 #endif
 
-
 // Persistant Data Storage
 #include <Preferences.h>
 Preferences prefs;
@@ -42,46 +40,41 @@ Preferences prefs;
 using namespace httpsserver;
 #include "mesh/http/ContentHandler.h"
 
-SSLCert *cert;
-HTTPSServer *secureServer;
-HTTPServer *insecureServer;
+static SSLCert *cert;
+static HTTPSServer *secureServer;
+static HTTPServer *insecureServer;
 
+volatile bool isWebServerReady;
+volatile bool isCertReady;
 
-
-
-bool isWebServerReady = 0;
-bool isCertReady = 0;
-
-
-void handleWebResponse()
+static void handleWebResponse()
 {
-    if (isWifiAvailable() == 0) {
-        return;
-    }
+    if (isWifiAvailable()) {
 
-    if (isWebServerReady) {
-        // We're going to handle the DNS responder here so it
-        // will be ignored by the NRF boards.
-        handleDNSResponse();
+        if (isWebServerReady) {
+            // We're going to handle the DNS responder here so it
+            // will be ignored by the NRF boards.
+            handleDNSResponse();
 
-        secureServer->loop();
-        insecureServer->loop();
-    }
+            if(secureServer)
+                secureServer->loop();
+            insecureServer->loop();
+        }
 
-    /*
-        Slow down the CPU if we have not received a request within the last few
-        seconds.
-    */
-   
-    if (millis() - getTimeSpeedUp() >= (25 * 1000)) {
-        setCpuFrequencyMhz(80);
-        setTimeSpeedUp();
+        /*
+            Slow down the CPU if we have not received a request within the last few
+            seconds.
+        */
+
+        if (millis() - getTimeSpeedUp() >= (25 * 1000)) {
+            setCpuFrequencyMhz(80);
+            setTimeSpeedUp();
+        }
     }
 }
 
-void taskCreateCert(void *parameter)
+static void taskCreateCert(void *parameter)
 {
-
     prefs.begin("MeshtasticHTTPS", false);
 
     // Delete the saved certs
@@ -92,13 +85,32 @@ void taskCreateCert(void *parameter)
         prefs.remove("cert");
     }
 
+    DEBUG_MSG("Checking if we have a previously saved SSL Certificate.\n");
+
     size_t pkLen = prefs.getBytesLength("PK");
     size_t certLen = prefs.getBytesLength("cert");
 
-    DEBUG_MSG("Checking if we have a previously saved SSL Certificate.\n");
-
     if (pkLen && certLen) {
         DEBUG_MSG("Existing SSL Certificate found!\n");
+
+        uint8_t *pkBuffer = new uint8_t[pkLen];
+        prefs.getBytes("PK", pkBuffer, pkLen);
+
+        uint8_t *certBuffer = new uint8_t[certLen];
+        prefs.getBytes("cert", certBuffer, certLen);
+
+        cert = new SSLCert(certBuffer, certLen, pkBuffer, pkLen);
+
+        DEBUG_MSG("Retrieved Private Key: %d Bytes\n", cert->getPKLength());
+        // DEBUG_MSG("Retrieved Private Key: " + String(cert->getPKLength()) + " Bytes");
+        // for (int i = 0; i < cert->getPKLength(); i++)
+        //  Serial.print(cert->getPKData()[i], HEX);
+        // Serial.println();
+
+        DEBUG_MSG("Retrieved Certificate: %d Bytes\n", cert->getCertLength());
+        // for (int i = 0; i < cert->getCertLength(); i++)
+        //  Serial.print(cert->getCertData()[i], HEX);
+        // Serial.println();
     } else {
         DEBUG_MSG("Creating the certificate. This may take a while. Please wait...\n");
         yield();
@@ -133,35 +145,35 @@ void taskCreateCert(void *parameter)
         }
     }
 
-    isCertReady = 1;
+    isCertReady = true;
+
+    // Must delete self, can't just fall out
     vTaskDelete(NULL);
 }
 
 void createSSLCert()
 {
+    if (isWifiAvailable() && !isCertReady) {
 
-    if (isWifiAvailable() == 0) {
-        return;
+        // Create a new process just to handle creating the cert.
+        //   This is a workaround for Bug: https://github.com/fhessel/esp32_https_server/issues/48
+        //  jm@casler.org (Oct 2020)
+        xTaskCreate(taskCreateCert, /* Task function. */
+                    "createCert",   /* String with name of task. */
+                    16384,          /* Stack size in bytes. */
+                    NULL,           /* Parameter passed as input of the task */
+                    16,             /* Priority of the task. */
+                    NULL);          /* Task handle. */
+
+        DEBUG_MSG("Waiting for SSL Cert to be generated.\n");
+        while (!isCertReady) {
+            DEBUG_MSG(".");
+            delay(1000);
+            yield();
+            esp_task_wdt_reset();
+        }
+        DEBUG_MSG("SSL Cert Ready!\n");
     }
-
-    // Create a new process just to handle creating the cert.
-    //   This is a workaround for Bug: https://github.com/fhessel/esp32_https_server/issues/48
-    //  jm@casler.org (Oct 2020)
-    xTaskCreate(taskCreateCert, /* Task function. */
-                "createCert",   /* String with name of task. */
-                16384,          /* Stack size in bytes. */
-                NULL,           /* Parameter passed as input of the task */
-                16,             /* Priority of the task. */
-                NULL);          /* Task handle. */
-
-    DEBUG_MSG("Waiting for SSL Cert to be generated.\n");
-    while (!isCertReady) {
-        DEBUG_MSG(".");
-        delay(1000);
-        yield();
-        esp_task_wdt_reset();
-    }
-    DEBUG_MSG("SSL Cert Ready!\n");
 }
 
 WebServerThread *webServerThread;
@@ -181,6 +193,8 @@ void initWebServer()
 {
     DEBUG_MSG("Initializing Web Server ...\n");
 
+#if 0
+// this seems to be a copypaste dup of taskCreateCert
     prefs.begin("MeshtasticHTTPS", false);
 
     size_t pkLen = prefs.getBytesLength("PK");
@@ -211,6 +225,7 @@ void initWebServer()
     } else {
         DEBUG_MSG("Web Server started without SSL keys! How did this happen?\n");
     }
+#endif
 
     // We can now use the new certificate to setup our server as usual.
     secureServer = new HTTPSServer(cert);
@@ -218,14 +233,16 @@ void initWebServer()
 
     registerHandlers(insecureServer, secureServer);
 
-    DEBUG_MSG("Starting Web Servers...\n");
-    secureServer->start();
+    if(secureServer) {
+        DEBUG_MSG("Starting Secure Web Server...\n");
+        secureServer->start();
+    }
+    DEBUG_MSG("Starting Insecure Web Server...\n");    
     insecureServer->start();
-    if (secureServer->isRunning() && insecureServer->isRunning()) {
-        DEBUG_MSG("HTTP and HTTPS Web Servers Ready! :-) \n");
-        isWebServerReady = 1;
+    if (insecureServer->isRunning()) {
+        DEBUG_MSG("Web Servers Ready! :-) \n");
+        isWebServerReady = true;
     } else {
-        DEBUG_MSG("HTTP and HTTPS Web Servers Failed! ;-( \n");
+        DEBUG_MSG("Web Servers Failed! ;-( \n");
     }
 }
-

src/mesh/http/WebServer.h

@@ -8,10 +8,6 @@
 void initWebServer();
 void createSSLCert();
 
-
-void handleWebResponse();
-
-
 class WebServerThread : private concurrency::OSThread
 {
 

src/mesh/http/WiFiAPClient.cpp

@@ -1,7 +1,9 @@
 #include "mesh/http/WiFiAPClient.h"
 #include "NodeDB.h"
+#include "concurrency/Periodic.h"
 #include "configuration.h"
 #include "main.h"
+#include "mqtt/MQTT.h"
 #include "mesh/http/WebServer.h"
 #include "mesh/wifi/WiFiServerAPI.h"
 #include "target_specific.h"
@@ -9,6 +11,8 @@
 #include <ESPmDNS.h>
 #include <WiFi.h>
 
+using namespace concurrency;
+
 static void WiFiEvent(WiFiEvent_t event);
 
 // DNS Server for the Captive Portal
@@ -23,6 +27,47 @@ bool forcedSoftAP = 0;
 
 bool APStartupComplete = 0;
 
+static bool needReconnect = true; // If we create our reconnector, run it once at the beginning
+
+// FIXME, veto light sleep if we have a TCP server running
+#if 0
+class WifiSleepObserver : public Observer<uint32_t> {
+protected:
+
+    /// Return 0 if sleep is okay
+    virtual int onNotify(uint32_t newValue) {
+
+    }
+};
+
+static WifiSleepObserver wifiSleepObserver;
+//preflightSleepObserver.observe(&preflightSleep);
+#endif
+
+static int32_t reconnectWiFi()
+{
+    if (radioConfig.has_preferences && needReconnect) {
+
+        const char *wifiName = radioConfig.preferences.wifi_ssid;
+        const char *wifiPsw = radioConfig.preferences.wifi_password;
+
+        if (!*wifiPsw) // Treat empty password as no password
+            wifiPsw = NULL;
+
+        if (*wifiName) {
+            needReconnect = false;
+
+            DEBUG_MSG("... Reconnecting to WiFi access point");
+            WiFi.mode(WIFI_MODE_STA);
+            WiFi.begin(wifiName, wifiPsw);
+        }
+    }
+
+    return 30 * 1000; // every 30 seconds
+}
+
+static Periodic *wifiReconnect;
+
 bool isSoftAPForced()
 {
     return forcedSoftAP;
@@ -37,15 +82,6 @@ bool isWifiAvailable()
 
     const char *wifiName = radioConfig.preferences.wifi_ssid;
 
-    // strcpy(radioConfig.preferences.wifi_ssid, "meshtastic");
-    // strcpy(radioConfig.preferences.wifi_password, "meshtastic!");
-
-    // strcpy(radioConfig.preferences.wifi_ssid, "meshtasticAdmin");
-    // strcpy(radioConfig.preferences.wifi_password, "12345678");
-
-    // radioConfig.preferences.wifi_ap_mode = true;
-    // radioConfig.preferences.wifi_ap_mode = false;
-
     if (*wifiName) {
         return true;
     } else {
@@ -74,27 +110,44 @@ void deinitWifi()
     }
 }
 
-// Startup WiFi
-void initWifi(bool forceSoftAP)
+static void onNetworkConnected()
 {
+    if (!APStartupComplete) {
+        // Start web server
+        DEBUG_MSG("... Starting network services\n");
 
-    if (forceSoftAP) {
-        // do nothing
-        // DEBUG_MSG("----- Forcing SoftAP\n");
-    } else {
-        if (isWifiAvailable() == 0) {
-            return;
+        // start mdns
+        if (!MDNS.begin("Meshtastic")) {
+            DEBUG_MSG("Error setting up MDNS responder!\n");
+        } else {
+            DEBUG_MSG("mDNS responder started\n");
+            DEBUG_MSG("mDNS Host: Meshtastic.local\n");
+            MDNS.addService("http", "tcp", 80);
+            MDNS.addService("https", "tcp", 443);
         }
-    }
 
+        initWebServer();
+        initApiServer();
+
+        APStartupComplete = true;
+    } 
+
+    // FIXME this is kinda yucky, instead we should just have an observable for 'wifireconnected'
+    if(mqtt)
+        mqtt->reconnect();
+}
+
+// Startup WiFi
+bool initWifi(bool forceSoftAP)
+{
     forcedSoftAP = forceSoftAP;
 
-    createSSLCert();
-
-    if (radioConfig.has_preferences || forceSoftAP) {
+    if ((radioConfig.has_preferences && radioConfig.preferences.wifi_ssid[0]) || forceSoftAP) {
         const char *wifiName = radioConfig.preferences.wifi_ssid;
         const char *wifiPsw = radioConfig.preferences.wifi_password;
 
+        createSSLCert();
+
         if (!*wifiPsw) // Treat empty password as no password
             wifiPsw = NULL;
 
@@ -155,29 +208,15 @@ void initWifi(bool forceSoftAP)
                     },
                     WiFiEvent_t::SYSTEM_EVENT_STA_DISCONNECTED);
 
-                DEBUG_MSG("JOINING WIFI: ssid=%s\n", wifiName);
-                if (WiFi.begin(wifiName, wifiPsw) == WL_CONNECTED) {
-                    DEBUG_MSG("MY IP ADDRESS: %s\n", WiFi.localIP().toString().c_str());
-                } else {
-                    DEBUG_MSG("Started Joining WIFI\n");
-                }
+                DEBUG_MSG("JOINING WIFI soon: ssid=%s\n", wifiName);
+                wifiReconnect = new Periodic("WifiConnect", reconnectWiFi);
             }
         }
-
-        if (!MDNS.begin("Meshtastic")) {
-            DEBUG_MSG("Error setting up MDNS responder!\n");
-
-            while (1) {
-                delay(1000);
-            }
-        }
-        DEBUG_MSG("mDNS responder started\n");
-        DEBUG_MSG("mDNS Host: Meshtastic.local\n");
-        MDNS.addService("http", "tcp", 80);
-        MDNS.addService("https", "tcp", 443);
-
-    } else
+        return true;
+    } else {
         DEBUG_MSG("Not using WIFI\n");
+        return false;
+    }
 }
 
 // Called by the Espressif SDK to
@@ -193,10 +232,10 @@ static void WiFiEvent(WiFiEvent_t event)
         DEBUG_MSG("Completed scan for access points\n");
         break;
     case SYSTEM_EVENT_STA_START:
-        DEBUG_MSG("WiFi client started\n");
+        DEBUG_MSG("WiFi station started\n");
         break;
     case SYSTEM_EVENT_STA_STOP:
-        DEBUG_MSG("WiFi clients stopped\n");
+        DEBUG_MSG("WiFi station stopped\n");
         break;
     case SYSTEM_EVENT_STA_CONNECTED:
         DEBUG_MSG("Connected to access point\n");
@@ -205,7 +244,7 @@ static void WiFiEvent(WiFiEvent_t event)
         DEBUG_MSG("Disconnected from WiFi access point\n");
         // Event 5
 
-        reconnectWiFi();
+        needReconnect = true;
         break;
     case SYSTEM_EVENT_STA_AUTHMODE_CHANGE:
         DEBUG_MSG("Authentication mode of access point has changed\n");
@@ -213,18 +252,7 @@ static void WiFiEvent(WiFiEvent_t event)
     case SYSTEM_EVENT_STA_GOT_IP:
         DEBUG_MSG("Obtained IP address: \n");
         Serial.println(WiFi.localIP());
-
-        if (!APStartupComplete) {
-            // Start web server
-            DEBUG_MSG("... Starting network services\n");
-            initWebServer();
-            initApiServer();
-
-            APStartupComplete = true;
-        } else {
-            DEBUG_MSG("... Not starting network services (They're already running)\n");
-        }
-
+        onNetworkConnected();
         break;
     case SYSTEM_EVENT_STA_LOST_IP:
         DEBUG_MSG("Lost IP address and IP address is reset to 0\n");
@@ -244,18 +272,7 @@ static void WiFiEvent(WiFiEvent_t event)
     case SYSTEM_EVENT_AP_START:
         DEBUG_MSG("WiFi access point started\n");
         Serial.println(WiFi.softAPIP());
-
-        if (!APStartupComplete) {
-            // Start web server
-            DEBUG_MSG("... Starting network services\n");
-            initWebServer();
-            initApiServer();
-
-            APStartupComplete = true;
-        } else {
-            DEBUG_MSG("... Not starting network services (They're already running)\n");
-        }
-
+        onNetworkConnected();
         break;
     case SYSTEM_EVENT_AP_STOP:
         DEBUG_MSG("WiFi access point stopped\n");
@@ -302,26 +319,6 @@ void handleDNSResponse()
     }
 }
 
-void reconnectWiFi()
-{
-    if (radioConfig.has_preferences) {
-
-        const char *wifiName = radioConfig.preferences.wifi_ssid;
-        const char *wifiPsw = radioConfig.preferences.wifi_password;
-
-        if (!*wifiPsw) // Treat empty password as no password
-            wifiPsw = NULL;
-
-        if (*wifiName) {
-
-            DEBUG_MSG("... Reconnecting to WiFi access point");
-
-            WiFi.mode(WIFI_MODE_STA);
-            WiFi.begin(wifiName, wifiPsw);
-        }
-    }
-}
-
 uint8_t getWifiDisconnectReason()
 {
     return wifiDisconnectReason;

src/mesh/http/WiFiAPClient.h

@@ -9,15 +9,15 @@
 #include <WiFi.h>
 #endif
 
-void initWifi(bool forceSoftAP);
+/// @return true if wifi is now in use
+bool initWifi(bool forceSoftAP);
+
 void deinitWifi();
 
 bool isWifiAvailable();
 
 void handleDNSResponse();
 
-void reconnectWiFi();
-
 bool isSoftAPForced();
 
 uint8_t getWifiDisconnectReason();

src/mesh/wifi/WiFiServerAPI.cpp

@@ -25,8 +25,6 @@ WiFiServerAPI::~WiFiServerAPI()
     // FIXME - delete this if the client dropps the connection!
 }
 
-
-
 /// override close to also shutdown the TCP link
 void WiFiServerAPI::close()
 {
@@ -51,6 +49,13 @@ int32_t WiFiServerAPI::runOnce()
     }
 }
 
+/// If an api server is running, we try to spit out debug 'serial' characters there
+void WiFiServerPort::debugOut(char c)
+{
+    if (apiPort && apiPort->openAPI)
+        apiPort->openAPI->debugOut(c);
+}
+
 #define MESHTASTIC_PORTNUM 4403
 
 WiFiServerPort::WiFiServerPort() : WiFiServer(MESHTASTIC_PORTNUM), concurrency::OSThread("ApiServer") {}

src/mesh/wifi/WiFiServerAPI.h

@@ -21,8 +21,8 @@ class WiFiServerAPI : public StreamAPI
     virtual void close();
 
   protected:
-
-    /// We override this method to prevent publishing EVENT_SERIAL_CONNECTED/DISCONNECTED for wifi links (we want the board to stay in the POWERED state to prevent disabling wifi)
+    /// We override this method to prevent publishing EVENT_SERIAL_CONNECTED/DISCONNECTED for wifi links (we want the board to
+    /// stay in the POWERED state to prevent disabling wifi)
     virtual void onConnectionChanged(bool connected) {}
 
     virtual int32_t runOnce(); // Check for dropped client connections
@@ -48,6 +48,10 @@ class WiFiServerPort : public WiFiServer, private concurrency::OSThread
 
     void init();
 
+    /// If an api server is running, we try to spit out debug 'serial' characters there
+    static void debugOut(char c);
+    
+  protected:
     int32_t runOnce();
 };
 

src/mqtt/MQTT.cpp

@@ -1,9 +1,11 @@
 #include "MQTT.h"
 #include "NodeDB.h"
+#include "PowerFSM.h"
 #include "main.h"
 #include "mesh/Channels.h"
 #include "mesh/Router.h"
 #include "mesh/generated/mqtt.pb.h"
+#include "sleep.h"
 #include <WiFi.h>
 #include <assert.h>
 
@@ -57,42 +59,45 @@ MQTT::MQTT() : concurrency::OSThread("mqtt"), pubSub(mqttClient)
     mqtt = this;
 
     pubSub.setCallback(mqttCallback);
+
+    // preflightSleepObserver.observe(&preflightSleep);
 }
 
 void MQTT::reconnect()
 {
-    // pubSub.setServer("devsrv.ezdevice.net", 1883); or 192.168.10.188
-    const char *serverAddr = "mqtt.meshtastic.org:1883"; // default hostname
+    if (wantsLink()) {
+        const char *serverAddr = "mqtt.meshtastic.org"; // default hostname
+        int serverPort = 1883;                          // default server port
 
-    if (*radioConfig.preferences.mqtt_server)
-        serverAddr = radioConfig.preferences.mqtt_server; // Override the default
+        if (*radioConfig.preferences.mqtt_server)
+            serverAddr = radioConfig.preferences.mqtt_server; // Override the default
 
-    String server = String(serverAddr);  
-    int delimIndex = server.indexOf(':'); 
-    if (delimIndex > 0) {
-        String host = server.substring(0, delimIndex);
-        String port = server.substring(delimIndex+1, server.length());
-        pubSub.setServer(host.c_str(), port.toInt());
+        String server = String(serverAddr);
+        int delimIndex = server.indexOf(':');
+        if (delimIndex > 0) {
+            String port = server.substring(delimIndex + 1, server.length());
+            server[delimIndex] = 0;
+            serverPort = port.toInt();
+            serverAddr = server.c_str();
+        }
+        pubSub.setServer(serverAddr, serverPort);
+
+        DEBUG_MSG("Connecting to MQTT server %s, port: %d\n", serverAddr, serverPort);
+        auto myStatus = (statusTopic + owner.id);
+        bool connected = pubSub.connect(owner.id, "meshdev", "large4cats", myStatus.c_str(), 1, true, "offline");
+        if (connected) {
+            DEBUG_MSG("MQTT connected\n");
+            enabled = true; // Start running background process again
+            runASAP = true;
+
+            /// FIXME, include more information in the status text
+            bool ok = pubSub.publish(myStatus.c_str(), "online", true);
+            DEBUG_MSG("published %d\n", ok);
+
+            sendSubscriptions();
+        } else
+            DEBUG_MSG("Failed to contact MQTT server...\n");
     }
-    else {
-        pubSub.setServer(serverAddr, 1883);
-    }
-
-    DEBUG_MSG("Connecting to MQTT server\n", serverAddr);
-    auto myStatus = (statusTopic + owner.id);
-    bool connected = pubSub.connect(owner.id, "meshdev", "large4cats", myStatus.c_str(), 1, true, "offline");
-    if (connected) {
-        DEBUG_MSG("MQTT connected\n");
-        enabled = true; // Start running background process again
-        runASAP = true;
-
-        /// FIXME, include more information in the status text
-        bool ok = pubSub.publish(myStatus.c_str(), "online", true);
-        DEBUG_MSG("published %d\n", ok);
-
-        sendSubscriptions();
-    } else
-        DEBUG_MSG("Failed to contact MQTT server...\n");
 }
 
 void MQTT::sendSubscriptions()
@@ -149,6 +154,7 @@ int32_t MQTT::runOnce()
             pubSub.disconnect();
         }
 
+        powerFSM.trigger(EVENT_CONTACT_FROM_PHONE); // Suppress entering light sleep (because that would turn off bluetooth)
         return 20;
     }
 }

src/mqtt/MQTT.h

@@ -19,6 +19,9 @@ class MQTT : private concurrency::OSThread
     WiFiClient mqttClient;
     PubSubClient pubSub;
 
+    // instead we supress sleep from our runOnce() callback
+    // CallbackObserver<MQTT, void *> preflightSleepObserver = CallbackObserver<MQTT, void *>(this, &MQTT::preflightSleepCb);
+
   public:
     MQTT();
 
@@ -32,6 +35,10 @@ class MQTT : private concurrency::OSThread
      */
     void onSend(const MeshPacket &mp, ChannelIndex chIndex);
 
+    /** Attempt to connect to server if necessary
+     */
+    void reconnect();
+    
   protected:
     virtual int32_t runOnce();
 
@@ -40,10 +47,6 @@ class MQTT : private concurrency::OSThread
      */
     bool wantsLink() const;
 
-    /** Attempt to connect to server if necessary
-     */
-    void reconnect();
-
     /** Tell the server what subscriptions we want (based on channels.downlink_enabled)
      */
     void sendSubscriptions();
@@ -53,6 +56,9 @@ class MQTT : private concurrency::OSThread
 
     /// Called when a new publish arrives from the MQTT server
     void onPublish(char *topic, byte *payload, unsigned int length);
+
+    /// Return 0 if sleep is okay, veto sleep if we are connected to pubsub server
+    // int preflightSleepCb(void *unused = NULL) { return pubSub.connected() ? 1 : 0; }    
 };
 
 void mqttInit();

src/nimble/BluetoothUtil.cpp

@@ -21,6 +21,8 @@
 static bool pinShowing;
 static uint32_t doublepressed;
 
+static bool bluetoothActive;
+
 static void startCb(uint32_t pin)
 {
     pinShowing = true;
@@ -52,23 +54,27 @@ void updateBatteryLevel(uint8_t level)
 
 void deinitBLE()
 {
-    // DEBUG_MSG("Shutting down bluetooth\n");
-    // ble_gatts_show_local();
+    if (bluetoothActive) {
+        bluetoothActive = false;
 
-    // FIXME - do we need to dealloc things? - what needs to stay alive across light sleep?
-    auto ret = nimble_port_stop();
-    assert(ret == ESP_OK);
+        // DEBUG_MSG("Shutting down bluetooth\n");
+        // ble_gatts_show_local();
 
-    nimble_port_deinit(); // teardown nimble datastructures
+        // FIXME - do we need to dealloc things? - what needs to stay alive across light sleep?
+        auto ret = nimble_port_stop();
+        assert(ret == ESP_OK);
 
-    // DEBUG_MSG("BLE port_deinit done\n");
+        nimble_port_deinit(); // teardown nimble datastructures
 
-    ret = esp_nimble_hci_and_controller_deinit();
-    assert(ret == ESP_OK);
+        // DEBUG_MSG("BLE port_deinit done\n");
 
-    // DEBUG_MSG("BLE task exiting\n");
+        ret = esp_nimble_hci_and_controller_deinit();
+        assert(ret == ESP_OK);
 
-    DEBUG_MSG("Done shutting down bluetooth\n");
+        // DEBUG_MSG("BLE task exiting\n");
+
+        DEBUG_MSG("Done shutting down bluetooth\n");
+    }
 }
 
 void loopBLE()
@@ -479,6 +485,8 @@ void disablePin()
     doublepressed = millis();
 }
 
+
+
 // This routine is called multiple times, once each time we come back from sleep
 void reinitBluetooth()
 {
@@ -536,10 +544,10 @@ void reinitBluetooth()
     ble_store_config_init();
 
     nimble_port_freertos_init(ble_host_task);
+    bluetoothActive = true;
 }
 
 bool bluetoothOn;
-bool firstTime = 1;
 
 // Enable/disable bluetooth.
 void setBluetoothEnable(bool on)
@@ -549,32 +557,15 @@ void setBluetoothEnable(bool on)
 
         bluetoothOn = on;
         if (on) {
-            Serial.printf("Pre BT: %u heap size\n", ESP.getFreeHeap());
-            // ESP_ERROR_CHECK( heap_trace_start(HEAP_TRACE_LEAKS) );
-            reinitBluetooth();
-
-            // Don't try to reconnect wifi before bluetooth is configured.
-            //   WiFi is initialized from main.cpp in setup() .
-            if (firstTime) {
-                firstTime = 0;
-            } else {
-#ifndef NO_ESP32
-                initWifi(0);
-#endif
+            if (!initWifi(0)) // if we are using wifi, don't turn on bluetooth also
+            {
+                Serial.printf("Pre BT: %u heap size\n", ESP.getFreeHeap());
+                // ESP_ERROR_CHECK( heap_trace_start(HEAP_TRACE_LEAKS) );
+                reinitBluetooth();
             }
         } else {
-
-            /*
-            // If WiFi is in use, disable shutting down the radio.
-            if (isWifiAvailable()) {
-                return;
-            }
-            */
-
             // shutdown wifi
-#ifndef NO_ESP32
             deinitWifi();
-#endif
 
             // We have to totally teardown our bluetooth objects to prevent leaks
             deinitBLE();

src/nrf52/main-nrf52.cpp

@@ -5,6 +5,7 @@
 #include <ble_gap.h>
 #include <memory.h>
 #include <stdio.h>
+// #include <Adafruit_USBD_Device.h>
 
 #include "NRF52Bluetooth.h"
 #include "error.h"
@@ -20,7 +21,10 @@ static inline void debugger_break(void)
 }
 
 bool loopCanSleep() {
-    return !tud_cdc_connected();
+    // turn off sleep only while connected via USB
+    // return true;
+    return !Serial; // the bool operator on the nrf52 serial class returns true if connected to a PC currently
+    // return !(TinyUSBDevice.mounted() && !TinyUSBDevice.suspended());
 }
 
 // handle standard gcc assert failures
@@ -37,7 +41,7 @@ void getMacAddr(uint8_t *dmac)
     ble_gap_addr_t addr;
     if (sd_ble_gap_addr_get(&addr) == NRF_SUCCESS) {
         memcpy(dmac, addr.addr, 6);
-    } else {
+    } else { 
         const uint8_t *src = (const uint8_t *)NRF_FICR->DEVICEADDR;
         dmac[5] = src[0];
         dmac[4] = src[1];
@@ -90,7 +94,7 @@ void setBluetoothEnable(bool on)
 }
 
 /**
- * Override printf to use the SEGGER output library
+ * Override printf to use the SEGGER output library (note - this does not effect the printf method on the debug console)
  */
 int printf(const char *fmt, ...)
 {

src/plugins/AdminPlugin.cpp

@@ -12,6 +12,24 @@
 
 AdminPlugin *adminPlugin;
 
+/// A special reserved string to indicate strings we can not share with external nodes.  We will use this 'reserved' word instead.
+/// Also, to make setting work correctly, if someone tries to set a string to this reserved value we assume they don't really want a change.
+static const char *secretReserved = "sekrit";
+
+/// If buf is !empty, change it to secret
+static void hideSecret(char *buf) {
+    if(*buf) {
+        strcpy(buf, secretReserved);
+    }
+}
+
+/// If buf is the reserved secret word, replace the buffer with currentVal
+static void writeSecret(char *buf, const char *currentVal) {
+    if(strcmp(buf, secretReserved) == 0) {
+        strcpy(buf, currentVal);
+    }
+}
+
 void AdminPlugin::handleGetChannel(const MeshPacket &req, uint32_t channelIndex)
 {
     if (req.decoded.want_response) {
@@ -35,13 +53,15 @@ void AdminPlugin::handleGetRadio(const MeshPacket &req)
         // using to the app (so that even old phone apps work with new device loads).
         r.get_radio_response.preferences.ls_secs = getPref_ls_secs();
         r.get_radio_response.preferences.phone_timeout_secs = getPref_phone_timeout_secs();
+        // hideSecret(r.get_radio_response.preferences.wifi_ssid); // hmm - leave public for now, because only minimally private and useful for users to know current provisioning)
+        hideSecret(r.get_radio_response.preferences.wifi_password);
 
         r.which_variant = AdminMessage_get_radio_response_tag;
         myReply = allocDataProtobuf(r);
     }
 }
 
-bool AdminPlugin::handleReceivedProtobuf(const MeshPacket &mp, const AdminMessage *r)
+bool AdminPlugin::handleReceivedProtobuf(const MeshPacket &mp, AdminMessage *r)
 {
     assert(r);
     switch (r->which_variant) {
@@ -139,8 +159,9 @@ void AdminPlugin::handleSetChannel(const Channel &cc)
     }
 }
 
-void AdminPlugin::handleSetRadio(const RadioConfig &r)
+void AdminPlugin::handleSetRadio(RadioConfig &r)
 {
+    writeSecret(r.preferences.wifi_password, radioConfig.preferences.wifi_password);
     radioConfig = r;
 
     service.reloadConfig();

src/plugins/AdminPlugin.h

@@ -17,12 +17,12 @@ class AdminPlugin : public ProtobufPlugin<AdminMessage>
 
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const AdminMessage *p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, AdminMessage *p);
 
   private:
     void handleSetOwner(const User &o);
     void handleSetChannel(const Channel &cc);
-    void handleSetRadio(const RadioConfig &r);
+    void handleSetRadio(RadioConfig &r);
 
     void handleGetChannel(const MeshPacket &req, uint32_t channelIndex);
     void handleGetRadio(const MeshPacket &req);

src/plugins/ExternalNotificationPlugin.cpp

@@ -143,7 +143,7 @@ ExternalNotificationPlugin::ExternalNotificationPlugin()
 #endif
 }
 
-bool ExternalNotificationPlugin::handleReceived(const MeshPacket &mp)
+ProcessMessage ExternalNotificationPlugin::handleReceived(const MeshPacket &mp)
 {
 #ifndef NO_ESP32
 
@@ -176,5 +176,5 @@ bool ExternalNotificationPlugin::handleReceived(const MeshPacket &mp)
 
 #endif
 
-    return false; // Very important to never return TRUE here.  TRUE means we handled the packet and we will stop letting other plugins see it
+    return ProcessMessage::CONTINUE; // Let others look at this message also if they want
 }

src/plugins/ExternalNotificationPlugin.h

@@ -24,9 +24,9 @@ class ExternalNotificationPlugin : public SinglePortPlugin, private concurrency:
 
     /** Called to handle a particular incoming message
 
-    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceived(const MeshPacket &mp);
+    virtual ProcessMessage handleReceived(const MeshPacket &mp);
 
     virtual int32_t runOnce();
 };

src/plugins/NodeInfoPlugin.cpp

@@ -8,7 +8,7 @@
 
 NodeInfoPlugin *nodeInfoPlugin;
 
-bool NodeInfoPlugin::handleReceivedProtobuf(const MeshPacket &mp, const User *pptr)
+bool NodeInfoPlugin::handleReceivedProtobuf(const MeshPacket &mp, User *pptr)
 {
     auto p = *pptr;
 

src/plugins/NodeInfoPlugin.h

@@ -26,7 +26,7 @@ class NodeInfoPlugin : public ProtobufPlugin<User>, private concurrency::OSThrea
 
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const User *p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, User *p);
 
     /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
      * so that subclasses can (optionally) send a response back to the original sender.  */

src/plugins/PositionPlugin.cpp

@@ -14,7 +14,7 @@ PositionPlugin::PositionPlugin()
     setIntervalFromNow(60 * 1000); // Send our initial position 60 seconds after we start (to give GPS time to setup)
 }
 
-bool PositionPlugin::handleReceivedProtobuf(const MeshPacket &mp, const Position *pptr)
+bool PositionPlugin::handleReceivedProtobuf(const MeshPacket &mp, Position *pptr)
 {
     auto p = *pptr;
 

src/plugins/PositionPlugin.h

@@ -33,7 +33,7 @@ class PositionPlugin : public ProtobufPlugin<Position>, private concurrency::OST
 
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const Position *p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, Position *p);
 
     /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
      * so that subclasses can (optionally) send a response back to the original sender.  */

src/plugins/RemoteHardwarePlugin.cpp

@@ -48,7 +48,7 @@ RemoteHardwarePlugin::RemoteHardwarePlugin()
 {
 }
 
-bool RemoteHardwarePlugin::handleReceivedProtobuf(const MeshPacket &req, const HardwareMessage *pptr)
+bool RemoteHardwarePlugin::handleReceivedProtobuf(const MeshPacket &req, HardwareMessage *pptr)
 {
     auto p = *pptr;
     DEBUG_MSG("Received RemoteHardware typ=%d\n", p.typ);

src/plugins/RemoteHardwarePlugin.h

@@ -27,7 +27,7 @@ class RemoteHardwarePlugin : public ProtobufPlugin<HardwareMessage>, private con
 
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const HardwareMessage *p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, HardwareMessage *p);
 
     /**
      * Periodically read the gpios we have been asked to WATCH, if they have changed,

src/plugins/RoutingPlugin.cpp

@@ -7,7 +7,7 @@
 
 RoutingPlugin *routingPlugin;
 
-bool RoutingPlugin::handleReceivedProtobuf(const MeshPacket &mp, const Routing *r)
+bool RoutingPlugin::handleReceivedProtobuf(const MeshPacket &mp, Routing *r)
 {
     printPacket("Routing sniffing", &mp);
     router->sniffReceived(&mp, r);

src/plugins/RoutingPlugin.h

@@ -22,7 +22,7 @@ class RoutingPlugin : public ProtobufPlugin<Routing>
 
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const Routing *p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, Routing *p);
 
     /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
      * so that subclasses can (optionally) send a response back to the original sender.  */

src/plugins/SerialPlugin.cpp

@@ -157,7 +157,7 @@ void SerialPluginRadio::sendPayload(NodeNum dest, bool wantReplies)
     service.sendToMesh(p);
 }
 
-bool SerialPluginRadio::handleReceived(const MeshPacket &mp)
+ProcessMessage SerialPluginRadio::handleReceived(const MeshPacket &mp)
 {
 #ifndef NO_ESP32
 
@@ -207,5 +207,5 @@ bool SerialPluginRadio::handleReceived(const MeshPacket &mp)
 
 #endif
 
-    return true; // Let others look at this message also if they want
+    return ProcessMessage::CONTINUE; // Let others look at this message also if they want
 }

src/plugins/SerialPlugin.h

@@ -45,9 +45,9 @@ class SerialPluginRadio : public SinglePortPlugin
 
     /** Called to handle a particular incoming message
 
-    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceived(const MeshPacket &mp);
+    virtual ProcessMessage handleReceived(const MeshPacket &mp);
 };
 
 extern SerialPluginRadio *serialPluginRadio;

src/plugins/TextMessagePlugin.cpp

@@ -5,7 +5,7 @@
 
 TextMessagePlugin *textMessagePlugin;
 
-bool TextMessagePlugin::handleReceived(const MeshPacket &mp)
+ProcessMessage TextMessagePlugin::handleReceived(const MeshPacket &mp)
 {
     auto &p = mp.decoded;
     DEBUG_MSG("Received text msg from=0x%0x, id=0x%x, msg=%.*s\n", mp.from, mp.id, p.payload.size, p.payload.bytes);
@@ -18,5 +18,5 @@ bool TextMessagePlugin::handleReceived(const MeshPacket &mp)
     powerFSM.trigger(EVENT_RECEIVED_TEXT_MSG);
     notifyObservers(&mp);
 
-    return false; // Let others look at this message also if they want
+    return ProcessMessage::CONTINUE; // Let others look at this message also if they want
 }

src/plugins/TextMessagePlugin.h

@@ -17,9 +17,9 @@ class TextMessagePlugin : public SinglePortPlugin, public Observable<const MeshP
 
     /** Called to handle a particular incoming message
 
-    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceived(const MeshPacket &mp);
+    virtual ProcessMessage handleReceived(const MeshPacket &mp);
 };
 
 extern TextMessagePlugin *textMessagePlugin;

src/plugins/esp32/EnvironmentalMeasurementPlugin.cpp

@@ -204,7 +204,7 @@ void EnvironmentalMeasurementPlugin::drawFrame(OLEDDisplay *display, OLEDDisplay
 
 }
 
-bool EnvironmentalMeasurementPlugin::handleReceivedProtobuf(const MeshPacket &mp, const EnvironmentalMeasurement *p)
+bool EnvironmentalMeasurementPlugin::handleReceivedProtobuf(const MeshPacket &mp, EnvironmentalMeasurement *p)
 {
     if (!(radioConfig.preferences.environmental_measurement_plugin_measurement_enabled || radioConfig.preferences.environmental_measurement_plugin_screen_enabled)){
         // If this plugin is not enabled in any capacity, don't handle the packet, and allow other plugins to consume 

src/plugins/esp32/EnvironmentalMeasurementPlugin.h

@@ -18,7 +18,7 @@ class EnvironmentalMeasurementPlugin : private concurrency::OSThread, public Pro
     /** Called to handle a particular incoming message
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const EnvironmentalMeasurement *p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, EnvironmentalMeasurement *p);
     virtual int32_t runOnce();
     /**
      * Send our EnvironmentalMeasurement into the mesh

src/plugins/esp32/RangeTestPlugin.cpp

@@ -5,6 +5,7 @@
 #include "RTC.h"
 #include "Router.h"
 #include "configuration.h"
+#include "gps/GeoCoord.h"
 #include <Arduino.h>
 #include <SPIFFS.h>
 //#include <assert.h>
@@ -123,7 +124,7 @@ void RangeTestPluginRadio::sendPayload(NodeNum dest, bool wantReplies)
     powerFSM.trigger(EVENT_CONTACT_FROM_PHONE);
 }
 
-bool RangeTestPluginRadio::handleReceived(const MeshPacket &mp)
+ProcessMessage RangeTestPluginRadio::handleReceived(const MeshPacket &mp)
 {
 #ifndef NO_ESP32
 
@@ -181,28 +182,7 @@ bool RangeTestPluginRadio::handleReceived(const MeshPacket &mp)
 
 #endif
 
-    return true; // Let others look at this message also if they want
-}
-
-/// Ported from my old java code, returns distance in meters along the globe
-/// surface (by magic?)
-float RangeTestPluginRadio::latLongToMeter(double lat_a, double lng_a, double lat_b, double lng_b)
-{
-    double pk = (180 / 3.14169);
-    double a1 = lat_a / pk;
-    double a2 = lng_a / pk;
-    double b1 = lat_b / pk;
-    double b2 = lng_b / pk;
-    double cos_b1 = cos(b1);
-    double cos_a1 = cos(a1);
-    double t1 = cos_a1 * cos(a2) * cos_b1 * cos(b2);
-    double t2 = cos_a1 * sin(a2) * cos_b1 * sin(b2);
-    double t3 = sin(a1) * sin(b1);
-    double tt = acos(t1 + t2 + t3);
-    if (isnan(tt))
-        tt = 0.0; // Must have been the same point?
-
-    return (float)(6366000 * tt);
+    return ProcessMessage::CONTINUE; // Let others look at this message also if they want
 }
 
 bool RangeTestPluginRadio::appendFile(const MeshPacket &mp)
@@ -303,7 +283,7 @@ bool RangeTestPluginRadio::appendFile(const MeshPacket &mp)
     fileToAppend.printf("%f,", mp.rx_snr); // RX SNR
 
     if (n->position.latitude_i && n->position.longitude_i && gpsStatus->getLatitude() && gpsStatus->getLongitude()) {
-        float distance = latLongToMeter(n->position.latitude_i * 1e-7, n->position.longitude_i * 1e-7,
+        float distance = GeoCoord::latLongToMeter(n->position.latitude_i * 1e-7, n->position.longitude_i * 1e-7,
                                         gpsStatus->getLatitude() * 1e-7, gpsStatus->getLongitude() * 1e-7);
         fileToAppend.printf("%f,", distance); // Distance in meters
     } else {

src/plugins/esp32/RangeTestPlugin.h

@@ -50,9 +50,9 @@ class RangeTestPluginRadio : public SinglePortPlugin
 
     /** Called to handle a particular incoming message
 
-    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceived(const MeshPacket &mp);
+    virtual ProcessMessage handleReceived(const MeshPacket &mp);
 };
 
 extern RangeTestPluginRadio *rangeTestPluginRadio;

src/plugins/esp32/StoreForwardPlugin.cpp

@@ -191,7 +191,7 @@ void StoreForwardPlugin::sendPayloadWelcome(NodeNum dest, bool wantReplies)
     service.sendToMesh(p);
 }
 
-bool StoreForwardPlugin::handleReceived(const MeshPacket &mp)
+ProcessMessage StoreForwardPlugin::handleReceived(const MeshPacket &mp)
 {
 #ifndef NO_ESP32
     if (radioConfig.preferences.store_forward_plugin_enabled) {
@@ -217,7 +217,7 @@ bool StoreForwardPlugin::handleReceived(const MeshPacket &mp)
 
 #endif
 
-    return true; // Let others look at this message also if they want
+    return ProcessMessage::CONTINUE; // Let others look at this message also if they want
 }
 
 StoreForwardPlugin::StoreForwardPlugin()

src/plugins/esp32/StoreForwardPlugin.h

@@ -51,9 +51,9 @@ class StoreForwardPlugin : public SinglePortPlugin, private concurrency::OSThrea
 
     /** Called to handle a particular incoming message
 
-    @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
+    @return ProcessMessage::STOP if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceived(const MeshPacket &mp);
+    virtual ProcessMessage handleReceived(const MeshPacket &mp);
 };
 
 extern StoreForwardPlugin *storeForwardPlugin;

src/portduino/PortduinoGlue.cpp

@@ -72,13 +72,13 @@ void portduinoSetup()
         gpioBind(loraIrq);
 
         // BUSY hw was busted on current board - just use the simulated pin (which will read low)
-        auto busy = new LinuxGPIOPin(SX1262_BUSY, "ch341", "slct", "loraBusy");
+        auto busy = new LinuxGPIOPin(SX126X_BUSY, "ch341", "slct", "loraBusy");
         busy->setSilent();
         gpioBind(busy);
 
-        gpioBind(new LinuxGPIOPin(SX1262_RESET, "ch341", "ini", "loraReset"));    
+        gpioBind(new LinuxGPIOPin(SX126X_RESET, "ch341", "ini", "loraReset"));
 
-        auto loraCs = new LinuxGPIOPin(SX1262_CS, "ch341", "cs0", "loraCs");
+        auto loraCs = new LinuxGPIOPin(SX126X_CS, "ch341", "cs0", "loraCs");
         loraCs->setSilent();
         gpioBind(loraCs);
     }
@@ -86,16 +86,16 @@ void portduinoSetup()
 #endif
 
     {
-        auto fakeBusy = new SimGPIOPin(SX1262_BUSY, "fakeBusy");
+        auto fakeBusy = new SimGPIOPin(SX126X_BUSY, "fakeBusy");
         fakeBusy->writePin(LOW);
         fakeBusy->setSilent(true);
         gpioBind(fakeBusy);
 
-        auto cs = new SimGPIOPin(SX1262_CS, "fakeLoraCS");
+        auto cs = new SimGPIOPin(SX126X_CS, "fakeLoraCS");
         cs->setSilent(true);
         gpioBind(cs);
 
-        gpioBind(new SimGPIOPin(SX1262_RESET, "fakeLoraReset"));
+        gpioBind(new SimGPIOPin(SX126X_RESET, "fakeLoraReset"));
         gpioBind(new SimGPIOPin(LORA_DIO1, "fakeLoraIrq"));
     }
 

src/power.h

@@ -37,6 +37,9 @@ class Power : private concurrency::OSThread
 
     /// Setup a simple ADC input based battery sensor
     bool analogInit();
+
+  private:
+    uint8_t low_voltage_counter;
 };
 
 extern Power *power;

src/wifi-stubs.cpp

@@ -5,7 +5,9 @@
 
 //#include "mesh/wifi/WiFiAPClient.h"
 
-void initWifi(bool forceSoftAP) {}
+bool initWifi(bool forceSoftAP) {
+    return false;
+}
 
 void deinitWifi() {}
 

variants/WisCore_RAK4631_Board/variant.h

@@ -151,13 +151,13 @@ static const uint8_t SCK = PIN_SPI_SCK;
  */
 
 // RAK4630 LoRa module
-#define SX1262_CS (42)
-#define SX1262_DIO1 (47)
-#define SX1262_BUSY (46)
-#define SX1262_RESET (38)
-#define SX1262_TXEN (39)
-#define SX1262_RXEN (37)
-#define SX1262_E22 // DIO2 controlls an antenna switch and the TCXO voltage is controlled by DIO3
+#define SX126X_CS (42)
+#define SX126X_DIO1 (47)
+#define SX126X_BUSY (46)
+#define SX126X_RESET (38)
+#define SX126X_TXEN (39)
+#define SX126X_RXEN (37)
+#define SX126X_E22 // DIO2 controlls an antenna switch and the TCXO voltage is controlled by DIO3
 
 // RAK1910 GPS module
 // If using the wisblock GPS module and pluged into Port A on WisBlock base