Merge pull request #719 from geeksville/dev

1.1.50

bin/build-all.sh

@@ -21,7 +21,7 @@ ARCHIVEDIR=release/archive
 
 rm -f $OUTDIR/firmware*
 
-mkdir -p $OUTDIR/bins
+mkdir -p $OUTDIR/bins $ARCHIVEDIR
 rm -r $OUTDIR/bins/*
 mkdir -p $OUTDIR/bins/universal $OUTDIR/elfs/universal
 

bin/exception_decoder.py

@@ -241,7 +241,7 @@ def print_addr(name, value, resolver):
 def print_stack_full(lines, resolver):
     print("stack:")
     for line in lines:
-        print(line.offset + ":")
+        print(str(line.offset) + ":")
         for content in line.content:
             print("  " + resolver.resolve_stack_addr(content))
 

docs/README.md

@@ -41,7 +41,8 @@ For an detailed walk-through aimed at beginners, we recommend [meshtastic.letsta
 
 ### Related Groups
 
-Telegram group for **Italy**-based users [t.me/meshtastic_italia](http://t.me/meshtastic_italia) (Italian language, unofficial).
+Telegram group for **Italy**-based users [t.me/meshtastic_italia](http://t.me/meshtastic_italia) (Italian language, unofficial).<br/>
+Telegram group for **Russian**-based users [t.me/meshtastic_russia](https://t.me/meshtastic_russia) (Russian language, unofficial).
 
 # Updates
 

docs/radio-settings.md

@@ -31,11 +31,75 @@ Channel zero starts at 903.08 MHz center frequency.
 
 ## Data-rates
 
-Various data-rates are selectable when configuring a channel and are inversely proportional to the theoretical range of the devices:  
+### About
 
-|       Channel setting      |     Data-rate        |
-|----------------------------|----------------------|
-| Short range (but fast)     | 21.875 kbps          |
-| Medium range (but fast)    | 5.469 kbps           |
-| Long range (but slower)    | 0.275 kbps           |
-| Very long range (but slow) | 0.183 kbps (default) |
+Various data-rates are selectable when configuring a channel and are inversely proportional to the theoretical range of the devices.
+
+Considerations:
+
+* Spreading Factor - How much we "spread" our data over time.
+* * Each step up in Spreading Factor dobules the airtime to transmit.
+* * Each step up in Spreading Factor adds about 2.5db extra link budget.
+* Bandwidth - How big of a slice of the spectrum we use.
+* * Each doubling of the bandwidth is almost 3db less link budget.
+* * Bandwidths less than 31 may be unstable unless you have a high quality Crystal Ossilator.
+* Coding Rate - How much redundency we encode to resist noise.
+* * Increasing coding rate increases reliability while decrasing data-rate.
+* * 4/5 - 1.25x overhead
+* * 4/6 - 1.5x overhead
+* * 4/7 - 1.75x overhead
+* * 4/8 - 2x overhead
+
+
+### Pre-Defined
+
+We have four predefined channels. These are the most common settings and have been proven to work well:
+
+| Channel setting            | Alt Channel Name | Data-rate            | SF / Symbols | Coding Rate | Bandwidth | Link Budget |
+|:---------------------------|:-----------------|:---------------------|:-------------|:------------|:----------|:------------|
+| Short range (but fast)     | Short Fast       | 21.875 kbps          | 7 / 128      | 4/5         | 125       | 134dB       |
+| Medium range (but fast)    | Medium           | 5.469 kbps           | 7 / 128      | 4/5         | 500       | 140dB       |
+| Long range (but slower)    | Long Alt         | 0.275 kbps           | 9 / 512      | 4/8         | 31        | 153dB       |
+| Very long range (but slow) | Long Slow        | 0.183 kbps (default) | 12 / 4096    | 4/8         | 125       | 154dB       |
+
+The link budget used by these calculations assumes a transmit power of 17dBm and an antenna with 0dB gain. Adjust your link budget assumptions based on your actual devices.
+
+### Custom Settings
+
+You may want to select other channels for your usage. The other settings can be set by using the Python API.
+
+> meshtastic --setchan spread_factor 10 --setchan coding_rate 8 --setchan bandwidth 125
+
+After applying the settings, you will need to restart the device. After your device is restarted, it will generate a new crypto key and you will need to share the newly generated QR Code or URL to all your other devices.
+
+Some example settings:
+
+| Data-rate            | SF / Symbols | Coding Rate | Bandwidth | Link Budget | Note |
+|:---------------------|:-------------|:------------|:----------|:------------|:-----|
+| 37.50 kbps           | 6 / 64       | 4/5         | 500       | 129dB       | Fastest possible speed |
+| 3.125 kbps           | 8 / 256      | 4/5         | 125       | 143dB       | |
+| 1.953 kbps           | 8 / 256      | 4/8         | 125       | 143dB       | |
+| 1.343 kbps           | 11 / 2048    | 4/8         | 500       | 145dB       | | 
+| 1.099 kbps           | 9 / 512      | 4/8         | 125       | 146dB       | |
+| 0.814 kbps           | 10 / 1024    | 4/6         | 125       | 149dB       | |
+| 0.610 kbps           | 10 / 1024    | 4/8         | 125       | 149dB       | |
+| 0.488 kbps           | 11 / 2048    | 4/6         | 125       | 152dB       | |
+| 0.336 kbps           | 11 / 2048    | 4/8         | 125       | 152dB       | |
+| 0.073 kbps           | 12 / 4096    | 4/5         | 31        | 160dB       | Twice the range and/or coverage of "Long Slow", low resliance to noise |
+| 0.046 kbps           | 12 / 4096    | 4/8         | 31        | 160dB       | Twice the range and/or coverage of "Long Slow", high resliance to noise |
+
+The link budget used by these calculations assumes a transmit power of 17dBm and an antenna with 0dB gain. Adjust your link budget assumptions based on your actual devices.
+
+These channel settings may have not been tested. Use at your own discression. Share on https://meshtastic.discourse.group with your successes or failure.
+
+## Cryptography
+
+The preshared key used by the devices can be modified.
+
+* 0 = No crypto
+* 1 = Default channel key
+* 2 - 10 = The default channel key, except with 1 through 9 added to the last byte
+
+Use of cryptography can also be modified. To disable cryptography (maybe useful if you have HAM radio license):
+
+> meshtastic --setchan psk 0

docs/software/plugins/RangeTestPlugin.md

@@ -0,0 +1,93 @@
+# About
+
+The RangeTest Plugin will help you perform range and coverage tests.
+
+# Configuration
+
+These are the settings that can be configured.
+
+    range_test_plugin_enabled
+        Is the plugin enabled?
+        
+        0 = Disabled (Default)
+        1 = Enabled
+
+    range_test_plugin_save
+        If enabled, we will save a log of all received messages to /static/rangetest.csv which you can access from the webserver. We will abort
+        writing if there is less than 50k of space on the filesystem to prevent filling up the storage.
+
+        0 = Disabled (Default)
+        1 = Enabled
+
+    range_test_plugin_sender
+        Number of seconds to wait between sending packets. Using the long_slow channel configuration, it's best not to go more frequent than once every 60 seconds. You can be more agressive with faster settings. 0 is default which disables sending messages.
+
+# Usage Notes
+
+For basic usage, you will need two devices both with a GPS. A device with a paired phone with GPS may work, I have not tried it. 
+
+The first thing to do is to turn on the plugin. With the plugin turned on, the other settings will be available:
+
+	range_test_plugin_enabled = 1
+
+If you want to send a message every 60 seconds:
+    
+	range_test_plugin_sender = 60
+
+To save a log of the messages:
+
+    range_test_plugin_save = 1
+
+Recommended settings for a sender at different radio settings:
+
+    Long Slow  ... range_test_plugin_sender = 60
+    Long Alt   ... range_test_plugin_sender = 30
+    Medium     ... range_test_plugin_sender = 15
+    Short Fast ... range_test_plugin_sender = 15
+
+## Other things to keep in mind
+
+Be sure to turn off either the plugin configured as a sender or the device where the plugin setup as sender when not in use. This will use a lot of time on air and will spam your channel.
+
+Also be mindful of your space usage on the file system. It has protections from filling up the space but it's best to delete old range test results.
+
+
+# Known Problems
+
+* If turned on, using mesh network will become unwieldly because messages are sent over the same channel as the other messages. See TODO below.
+
+# TODO
+
+* Right now range test messages go over the TEXT_MESSAGE_APP port. We need a toggle to switch to optionally send over RANGE_TEST_APP.
+
+# FAQ
+
+Q: Where is rangetest.csv saved?
+A: Turn on the WiFi on your device as either a WiFi client or a WiFi AP. Once you can connect to your device, go to /static and you will see rangetest.csv.
+
+Q: Do I need to have WiFi turned on for the file to be saved?
+A: Nope, it'll just work.
+
+Q: Do I need a phone for this plugin?
+A: There's no need for a phone.
+
+Q: Can I use this as a message logger?
+A: While it's not the intended purpose, sure, why not. Do it!
+
+Q: What will happen if I run out of space on my device?
+A: We have a protection in place to keep you from completly filling up your device. This will make sure that other device critical functions will continue to work. We will reserve at least 50k of free space.
+
+Q: What do I do with the rangetest.csv file when I'm done?
+A: Go to /static and delete the file.
+
+Q: Can I use this as a sender while on battery power?
+A: Yes, but your battery will run down quicker than normal. While sending, we tell the device not to go into low-power mode since it needs to keep to a fairly strict timer.
+
+Q: Why is this operating on incoming messages instead of the existing location discovery protocol?
+A: This plugin is still young and currently supports monitoring just one port at a time. I decided to use the existing message port because that is easy to test with. A future version will listen to multiple ports to be more promiscuous. 
+
+# Need more help?
+
+Go to the Meshtastic Discourse Group if you have any questions or to share how you have used this.
+
+https://meshtastic.discourse.group

docs/software/plugins/StoreForwardPlugin.md

@@ -0,0 +1,105 @@
+# About
+
+This is a work in progress and is not yet available.
+
+The Store Forward Plugin is an implementation of a Store and Forward system to enable resilient messaging in the event that a client device is disconnected from the main network.
+
+Because of the increased network traffic for this overhead, it's not adviced to use this if you are duty cycle limited for your airtime usage nor is it adviced to use this for SF12 (Long range but Slow).
+
+# Requirements
+
+Initial Requirements:
+
+* Must be installed on a router node.
+* * This is an artificial limitation, but is in place to enforce best practices.
+* * Router nodes are intended to be always online. If this plugin misses any messages, the reliability of the stored messages will be reduced
+* Esp32 Processor based device with external PSRAM. (tbeam v1.0 and tbeamv1.1, maybe others)
+
+# Implementation timeline
+
+Not necessarily in this order:
+
+UC 1) MVP - automagically forward packets to a client that may have missed packets.
+
+UC 2) Client Interface (Web, Android, Python or iOS when that happens) to optionally request packets be resent. This is to support the case where Router has not detected that the client was away. This is because the router will only know you're away if you've been gone for a period of time but will have no way of knowing if you were offline for a short number of minutes. This will cover the case where you have ducked into a cave or you're swapping out your battery.
+
+UC 3) router sends a periodic “heartbeat” to let the clients know they’re part of the main mesh
+
+UC 4) support for a mesh to have multiple routers that have the store & forward functionality (for redundancy)
+
+UC 5) Support for "long term" delayed messages and "short term" delayed messages. Handle the cases slightly different to improve user expierence. A short term delayed message would be a message that was resent becaue a node was not heard from for <5 minutes. A long term delayed message is a message that has not been delivered in >5 minutes.
+
+UC 6) Eventually we could add a "want_store_and_forward" bit to MeshPacket and that could be nicer than whitelists in this plugin. Initially we'd only set that bit in text messages (and any other plugin messages that can cope with this). This change would be backward wire compatible so can add easily later.
+
+UC 7) Currently the way we allocate messages in the device code is super inefficient. It always allocates the worst case message size. Really we should dynamically allocate just the # of bytes we need. This would allow many more MeshPackets to be kept in RAM.
+
+UC 8) We'll want a "delayed" bit in MeshPacket. This will indicate that the message was not received in real time.
+
+# Things to consider
+
+Not all these cases will be initially implemented. It's just a running stream of thoughts to be considered.
+
+## Main Mesh Network with Router
+
+The store and forward plugin is intended to be enabled on a router that designates your "main" mesh network.
+
+## Store and Forward on Multiple Routers
+
+If multiple routers with the plugin are enabled, they should be able to share their stored database amongst each other. This enable resilliancy from one router going offline.
+
+## Fragmented networks - No router
+
+In this case, the mesh network has been fragmented by two client devices leaving the main network.
+
+If two Meshtastic devices walk away from the main mesh, they will be able to message each other but not message the main network. When they return to the main network, they will receive the messages they have missed from the main mesh network.
+
+## Fragmented network - With routers
+
+In this case, we have two routers separate by a great distance, each serving multiple devices. One of the routers have gone offline. This has now created two physically seaprated mesh networks using the same channel configuration.
+
+Q: How do we rejoin both fragmented networks? Do we care about messages that were unrouted between fagments?
+
+## Identifing Delayed Messages
+
+When a message is replayed for a node, identify the packet as "Delayed". This will indicate that the message was not received in real time.
+
+# Router Data Structures
+
+Structure of received messages:
+
+    receivedMessages
+      Port_No
+      packetID
+      to
+      from
+      rxTimeMsec
+      data
+
+Structure of nodes and last time we heard from them. This is a record of any packet type.
+
+    receivedRecord
+      From
+      rxTimeMillis
+
+# General Operation for UC1 - automagically forward packets to a client that may have missed packets
+
+On every handled packet
+* Record the sender from and the time we heard from that sender into senderRecord.
+
+On every handled packet
+
+* If the packet is a message, save the messsage into receivedMessages
+
+On every handled packet, if we have not heard from that sender in a period of time greater than timeAway, let's assume that they have been away from the network.
+
+* In this case, we will resend them all the messages they have missed since they were gone
+
+## Expected problems this implementation
+
+* If the client has been away for less than 5 minutes and has received the previously sent message, the client will gracefully ignore it. This is thanks to PacketHistory::wasSeenRecently in PacketHistory.cpp.
+* * If the client has been away for more than 5 minutes and we resend packets that they have already received, it's possible they will see duplicate messages. This should be unlikely but is still possible. 
+
+
+# Designed limitations
+
+The Store and Forward plugin will subscribe to specific packet types and channels and only save those. This will both reduce the amount of data we will need to store and reduce the overhead on the network. Eg: There's no need to replay ACK packets nor is there's no need to replay old location packets.

docs/software/plugins/StoreRequestPlugin.md

@@ -1,6 +0,0 @@
-# About
-
-
-
-# Running notes
-

platformio.ini

@@ -65,7 +65,7 @@ debug_tool = jlink
 ;  monitor adapter_khz 10000
 
 lib_deps =
-  https://github.com/meshtastic/esp8266-oled-ssd1306.git ; ESP8266_SSD1306 
+  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#2f106146071fc7bc620e1e8d4b88dc4e0266ce39
@@ -75,7 +75,7 @@ lib_deps =
   https://github.com/meshtastic/AXP202X_Library.git#8404abb6d4b486748636bc6ad72d2a47baaf5460
   Wire ; explicitly needed here because the AXP202 library forgets to add it
   SPI
-  https://github.com/geeksville/ArduinoThread.git#333ffd09b596977c217ba25da4258f588b462ac6
+  https://github.com/geeksville/ArduinoThread.git#72921ac222eed6f526ba1682023cee290d9aa1b3
   
 ; Common settings for conventional (non Portduino) Ardino targets
 [arduino_base]
@@ -104,6 +104,8 @@ build_flags =
 lib_deps =
   ${arduino_base.lib_deps}
   https://github.com/meshtastic/esp32_https_server.git
+  adafruit/DHT sensor library@^1.4.1
+  adafruit/Adafruit Unified Sensor@^1.1.4
 # Hmm - this doesn't work yet
 # board_build.ldscript = linker/esp32.extram.bss.ld
 lib_ignore = segger_rtt
@@ -188,7 +190,7 @@ build_flags =
   -Isdk-nrfxlib/crypto/nrf_oberon/include -Lsdk-nrfxlib/crypto/nrf_oberon/lib/cortex-m4/hard-float/ -lliboberon_3.0.7 
 ;-DCFG_DEBUG=3
 src_filter = 
-  ${arduino_base.src_filter} -<esp32/> -<nimble/> -<mesh/wifi/> -<mesh/http/>
+  ${arduino_base.src_filter} -<esp32/> -<nimble/> -<mesh/wifi/> -<mesh/http/> -<plugins/esp32>
 lib_ignore =
   BluetoothOTA
 monitor_port = /dev/ttyACM1
@@ -329,7 +331,7 @@ lib_deps =
 ; The Portduino based sim environment on top of linux
 [env:linux]
 platform = https://github.com/geeksville/platform-portduino.git
-src_filter = ${env.src_filter} -<esp32/> -<nimble/> -<nrf52/> -<mesh/http/>
+src_filter = ${env.src_filter} -<esp32/> -<nimble/> -<nrf52/> -<mesh/http/> -<plugins/esp32>
 build_flags = ${arduino_base.build_flags} -O0
 framework = arduino
 board = linux_x86_64
@@ -342,4 +344,4 @@ lib_deps =
 extends = esp32_base
 board = genieblocks_lora
 build_flags = 
-  ${esp32_base.build_flags} -D GENIEBLOCKS
+  ${esp32_base.build_flags} -D GENIEBLOCKS

src/RedirectablePrint.cpp

@@ -78,9 +78,9 @@ size_t RedirectablePrint::logDebug(const char *format, ...)
             int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
             int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
 
-            r += printf("%02d:%02d:%02d ", hour, min, sec);
+            r += printf("%02d:%02d:%02d %u ", hour, min, sec, millis() / 1000);
         } else
-            r += printf("??:??:?? ");
+            r += printf("??:??:?? %u ", millis() / 1000);
 
         auto thread = concurrency::OSThread::currentThread;
         if(thread) {

src/commands.h

@@ -9,6 +9,7 @@ enum class Cmd {
         SET_OFF,
         ON_PRESS,
         START_BLUETOOTH_PIN_SCREEN,
+        START_FIRMWARE_UPDATE_SCREEN,
         STOP_BLUETOOTH_PIN_SCREEN,
         STOP_BOOT_SCREEN,
         PRINT,

src/concurrency/OSThread.cpp

@@ -32,8 +32,10 @@ OSThread::OSThread(const char *_name, uint32_t period, ThreadController *_contro
 
     ThreadName = _name;
 
-    if (controller)
-        controller->add(this);
+    if (controller) {
+        bool added = controller->add(this);
+        assert(added);
+    }
 }
 
 OSThread::~OSThread()

src/configuration.h

@@ -309,6 +309,33 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define LORA_DIO1 35 // Not really used
 #define LORA_DIO2 34 // Not really used
 
+#elif defined(TLORA_V1_3)
+// This string must exactly match the case used in release file names or the android updater won't work
+#define HW_VENDOR "tlora-v1-3"
+
+#undef GPS_RX_PIN
+#undef GPS_TX_PIN
+#define GPS_RX_PIN 36
+#define GPS_TX_PIN 13 // per @eugene
+
+#define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
+
+#define I2C_SDA 4 // I2C pins for this board
+#define I2C_SCL 15
+
+#define RESET_OLED 16 // If defined, this pin will be used to reset the display controller
+
+#define VEXT_ENABLE 21 // active low, powers the oled display and the lora antenna boost
+#define LED_PIN 25     // If defined we will blink this LED
+#define BUTTON_PIN 36
+#define BUTTON_NEED_PULLUP
+
+#define USE_RF95
+#define LORA_DIO0 26 // a No connect on the SX1262 module
+#define LORA_RESET 14
+#define LORA_DIO1 35 // Not really used
+#define LORA_DIO2 34 // Not really used
+
 #elif defined(TLORA_V2_1_16)
 // This string must exactly match the case used in release file names or the android updater won't work
 #define HW_VENDOR "tlora-v2-1-1.6"
@@ -316,7 +343,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #undef GPS_RX_PIN
 #undef GPS_TX_PIN
 #define GPS_RX_PIN 36
-#define GPS_TX_PIN 39
+#define GPS_TX_PIN 13
 
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 
@@ -327,9 +354,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #define VEXT_ENABLE 21 // active low, powers the oled display and the lora antenna boost
 #define LED_PIN 25     // If defined we will blink this LED
-#define BUTTON_PIN                                                                                                               \
-    12 // If defined, this will be used for user button presses, if your board doesn't have a physical switch, you can wire one
-       // between this pin and ground
+#define BUTTON_PIN 12  // If defined, this will be used for user button presses,
+
 #define BUTTON_NEED_PULLUP
 
 #define USE_RF95
@@ -348,15 +374,16 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define GPS_RESET_N 10
 #define GPS_EXTINT 23 // On MAX-M8 module pin name is EXTINT. On L70 module pin name is STANDBY.
 
-#define BATTERY_PIN 39 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
+#define BATTERY_PIN 39    // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 #define BATTERY_EN_PIN 14 // Voltage voltage divider enable pin connected to mosfet
 
 #define I2C_SDA 4 // I2C pins for this board
 #define I2C_SCL 2
 
-#define LED_PIN 12     // If defined we will blink this LED
-//#define BUTTON_PIN 36  // If defined, this will be used for user button presses (ToDo problem on that line on debug screen -->   Long press start!)
-//#define BUTTON_NEED_PULLUP //GPIOs 34 to 39 are GPIs – input only pins. These pins don’t have internal pull-ups or pull-down resistors. 
+#define LED_PIN 12 // If defined we will blink this LED
+//#define BUTTON_PIN 36  // If defined, this will be used for user button presses (ToDo problem on that line on debug screen -->
+//Long press start!) #define BUTTON_NEED_PULLUP //GPIOs 34 to 39 are GPIs – input only pins. These pins don’t have internal
+//pull-ups or pull-down resistors.
 
 #define USE_RF95
 #define LORA_DIO0 38 // a No connect on the SX1262 module

src/esp32/BluetoothSoftwareUpdate.cpp

@@ -7,6 +7,8 @@
 #include "configuration.h"
 #include "nimble/BluetoothUtil.h"
 #include "NodeDB.h"
+#include "../graphics/Screen.h"
+#include "../main.h"
 
 #include <CRC32.h>
 #include <Update.h>
@@ -47,8 +49,9 @@ int update_size_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_
             // void stopMeshBluetoothService();
             // stopMeshBluetoothService();
 
+            screen->startFirmwareUpdateScreen();
             if (RadioLibInterface::instance)
-                RadioLibInterface::instance->sleep(); // FIXME, nasty hack - the RF95 ISR/SPI code on ESP32 can fail while we are
+                RadioLibInterface::instance->disable(); // FIXME, nasty hack - the RF95 ISR/SPI code on ESP32 can fail while we are
                                                       // writing flash - shut the radio off during updates
         }
     }

src/graphics/Screen.cpp

@@ -64,6 +64,10 @@ uint8_t imgBattery[16] = {0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
 // Threshold values for the GPS lock accuracy bar display
 uint32_t dopThresholds[5] = {2000, 1000, 500, 200, 100};
 
+// At some point, we're going to ask all of the plugins if they would like to display a screen frame
+// we'll need to hold onto pointers for the plugins that can draw a frame.
+std::vector<MeshPlugin *> pluginFrames;
+
 // Stores the last 4 of our hardware ID, to make finding the device for pairing easier
 static char ourId[5];
 
@@ -144,6 +148,30 @@ static void drawSleepScreen(OLEDDisplay *display, OLEDDisplayUiState *state, int
     drawIconScreen("Sleeping...", display, state, x, y);
 }
 
+static void drawPluginFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    uint8_t plugin_frame;
+    // there's a little but in the UI transition code
+    // where it invokes the function at the correct offset 
+    // in the array of "drawScreen" functions; however,
+    // the passed-state doesn't quite reflect the "current" 
+    // screen, so we have to detect it.
+    if (state->frameState == IN_TRANSITION && state->transitionFrameRelationship == INCOMING) {
+        // if we're transitioning from the end of the frame list back around to the first 
+        // frame, then we want this to be `0`
+        plugin_frame = state->transitionFrameTarget;
+    }
+    else {
+        // otherwise, just display the plugin frame that's aligned with the current frame
+        plugin_frame = state->currentFrame;
+        //DEBUG_MSG("Screen is not in transition.  Frame: %d\n\n", plugin_frame);
+    }
+    //DEBUG_MSG("Drawing Plugin Frame %d\n\n", plugin_frame);
+    MeshPlugin &pi = *pluginFrames.at(plugin_frame);
+    pi.drawFrame(display,state,x,y);
+    
+}
+
 static void drawFrameBluetooth(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
     display->setTextAlignment(TEXT_ALIGN_CENTER);
@@ -164,6 +192,20 @@ static void drawFrameBluetooth(OLEDDisplay *display, OLEDDisplayUiState *state,
     display->drawString(64 + x, 48 + y, buf);
 }
 
+static void drawFrameFirmware(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    display->setTextAlignment(TEXT_ALIGN_CENTER);
+    display->setFont(FONT_MEDIUM);
+    display->drawString(64 + x, y, "Updating");
+
+    display->setFont(FONT_SMALL);
+    display->drawString(64 + x, FONT_HEIGHT_SMALL + y + 2, "Please wait...");
+
+    //display->setFont(FONT_LARGE);
+    //display->drawString(64 + x, 26 + y, btPIN);
+}
+
+
 /// Draw the last text message we received
 static void drawCriticalFaultFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
 {
@@ -798,6 +840,9 @@ int32_t Screen::runOnce()
         case Cmd::START_BLUETOOTH_PIN_SCREEN:
             handleStartBluetoothPinScreen(cmd.bluetooth_pin);
             break;
+        case Cmd::START_FIRMWARE_UPDATE_SCREEN:
+            handleStartFirmwareUpdateScreen();
+            break;            
         case Cmd::STOP_BLUETOOTH_PIN_SCREEN:
         case Cmd::STOP_BOOT_SCREEN:
             setFrames();
@@ -870,6 +915,11 @@ void Screen::setFrames()
     DEBUG_MSG("showing standard frames\n");
     showingNormalScreen = true;
 
+    pluginFrames = MeshPlugin::GetMeshPluginsWithUIFrames();
+    DEBUG_MSG("Showing %d plugin frames\n", pluginFrames.size());
+    int totalFrameCount = MAX_NUM_NODES + NUM_EXTRA_FRAMES + pluginFrames.size();
+    DEBUG_MSG("Total frame count: %d\n", totalFrameCount);
+
     // We don't show the node info our our node (if we have it yet - we should)
     size_t numnodes = nodeStatus->getNumTotal();
     if (numnodes > 0)
@@ -877,6 +927,18 @@ void Screen::setFrames()
 
     size_t numframes = 0;
 
+    // put all of the plugin frames first.
+    // this is a little bit of a dirty hack; since we're going to call
+    // the same drawPluginFrame handler here for all of these plugin frames
+    // and then we'll just assume that the state->currentFrame value
+    // is the same offset into the pluginFrames vector
+    // so that we can invoke the plugin's callback
+    for (auto i = pluginFrames.begin(); i != pluginFrames.end(); ++i) {
+        normalFrames[numframes++] = drawPluginFrame;
+    }
+    
+    DEBUG_MSG("Added plugins.  numframes: %d\n", numframes);
+
     // If we have a critical fault, show it first
     if (myNodeInfo.error_code)
         normalFrames[numframes++] = drawCriticalFaultFrame;
@@ -905,6 +967,8 @@ void Screen::setFrames()
     }
 #endif
 
+    DEBUG_MSG("Finished building frames. numframes: %d\n", numframes);
+
     ui.setFrames(normalFrames, numframes);
     ui.enableAllIndicators();
 
@@ -928,6 +992,18 @@ void Screen::handleStartBluetoothPinScreen(uint32_t pin)
     setFastFramerate();
 }
 
+void Screen::handleStartFirmwareUpdateScreen()
+{
+    DEBUG_MSG("showing firmware screen\n");
+    showingNormalScreen = false;
+
+    static FrameCallback btFrames[] = {drawFrameFirmware};
+
+    ui.disableAllIndicators();
+    ui.setFrames(btFrames, 1);
+    setFastFramerate();
+}
+
 void Screen::blink()
 {
     setFastFramerate();

src/graphics/Screen.h

@@ -128,6 +128,14 @@ class Screen : public concurrency::OSThread
         enqueueCmd(cmd);
     }
 
+    void startFirmwareUpdateScreen()
+    {
+        ScreenCmd cmd;
+        cmd.cmd = Cmd::START_FIRMWARE_UPDATE_SCREEN;
+        enqueueCmd(cmd);
+    }
+
+
     /// Stops showing the bluetooth PIN screen.
     void stopBluetoothPinScreen() { enqueueCmd(ScreenCmd{.cmd = Cmd::STOP_BLUETOOTH_PIN_SCREEN}); }
 
@@ -233,6 +241,7 @@ class Screen : public concurrency::OSThread
     void handleOnPress();
     void handleStartBluetoothPinScreen(uint32_t pin);
     void handlePrint(const char *text);
+    void handleStartFirmwareUpdateScreen();
 
     /// Rebuilds our list of frames (screens) to default ones.
     void setFrames();

src/main.cpp

@@ -305,12 +305,15 @@ void setup()
 
 #ifdef BUTTON_PIN
 #ifndef NO_ESP32
-    // If BUTTON_PIN is held down during the startup process,
-    //   force the device to go into a SoftAP mode.
     bool forceSoftAP = 0;
+
+    // If the button is connected to GPIO 12, don't enable the ability to use
+    // meshtasticAdmin on the device.
     pinMode(BUTTON_PIN, INPUT);
+
 #ifdef BUTTON_NEED_PULLUP
     gpio_pullup_en((gpio_num_t)BUTTON_PIN);
+    delay(10);
 #endif
 
     // BUTTON_PIN is pulled high by a 12k resistor.

src/mesh/MeshPlugin.cpp

@@ -75,4 +75,18 @@ void MeshPlugin::sendResponse(const MeshPacket &req) {
 void setReplyTo(MeshPacket *p, const MeshPacket &to) {
     p->to = to.from;
     p->want_ack = to.want_ack;
-}
+}
+
+std::vector<MeshPlugin *> MeshPlugin::GetMeshPluginsWithUIFrames() {
+
+    std::vector<MeshPlugin *> pluginsWithUIFrames;    
+    for (auto i = plugins->begin(); i != plugins->end(); ++i) {
+        auto &pi = **i;
+        if ( pi.wantUIFrame()) {
+            DEBUG_MSG("Plugin wants a UI Frame\n");
+            pluginsWithUIFrames.push_back(&pi);
+        }
+    }
+    return pluginsWithUIFrames;
+    
+}

src/mesh/MeshPlugin.h

@@ -2,6 +2,8 @@
 
 #include "mesh/MeshTypes.h"
 #include <vector>
+#include <OLEDDisplay.h>
+#include <OLEDDisplayUi.h>
 /** A baseclass for any mesh "plugin".
  *
  * A plugin allows you to add new features to meshtastic device code, without needing to know messaging details.
@@ -14,7 +16,7 @@
  */
 class MeshPlugin
 {
-    static std::vector<MeshPlugin *> *plugins;
+  static std::vector<MeshPlugin *> *plugins;
 
   public:
     /** Constructor
@@ -28,6 +30,10 @@ class MeshPlugin
      */
     static void callPlugins(const MeshPacket &mp);
 
+    static std::vector<MeshPlugin *> GetMeshPluginsWithUIFrames();
+
+    virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) { return; }
+
   protected:
     const char *name;
 
@@ -61,6 +67,13 @@ class MeshPlugin
      * so that subclasses can (optionally) send a response back to the original sender.  */
     virtual MeshPacket *allocReply() { return NULL; }
 
+    /***
+     * @return true if you want to be alloced a UI screen frame
+     */
+    virtual bool wantUIFrame() { return false; }
+
+
+
   private:
 
     /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked

src/mesh/MeshService.cpp

@@ -51,22 +51,7 @@ MeshService service;
 
 #include "Router.h"
 
-static int32_t sendOwnerCb()
-{
-    static uint32_t currentGeneration;
 
-    // If we changed channels, ask everyone else for their latest info
-    bool requestReplies = currentGeneration != radioGeneration;
-    currentGeneration = radioGeneration;
-
-    DEBUG_MSG("Sending our nodeinfo to mesh (wantReplies=%d)\n", requestReplies);
-    assert(nodeInfoPlugin);
-    nodeInfoPlugin->sendOurNodeInfo(NODENUM_BROADCAST, requestReplies); // Send our info (don't request replies)
-
-    return getPref_send_owner_interval() * getPref_position_broadcast_secs() * 1000;
-}
-
-static concurrency::Periodic *sendOwnerPeriod;
 
 MeshService::MeshService() : toPhoneQueue(MAX_RX_TOPHONE)
 {
@@ -75,9 +60,6 @@ MeshService::MeshService() : toPhoneQueue(MAX_RX_TOPHONE)
 
 void MeshService::init()
 {
-    sendOwnerPeriod = new concurrency::Periodic("SendOwner", sendOwnerCb);
-    sendOwnerPeriod->setIntervalFromNow(30 * 1000); // Send our initial owner announcement 30 seconds after we start (to give network time to setup)
-
     // moved much earlier in boot (called from setup())
     // nodeDB.init();
 
@@ -178,18 +160,6 @@ void MeshService::sendToMesh(MeshPacket *p)
 {
     nodeDB.updateFrom(*p); // update our local DB for this packet (because phone might have sent position packets etc...)
 
-    // Strip out any time information before sending packets to other  nodes - to keep the wire size small (and because other
-    // nodes shouldn't trust it anyways) Note: we allow a device with a local GPS to include the time, so that gpsless
-    // devices can get time.
-    if (p->which_payloadVariant == MeshPacket_decoded_tag && p->decoded.which_payloadVariant == SubPacket_position_tag &&
-        p->decoded.position.time) {
-        if (getRTCQuality() < RTCQualityGPS) {
-            DEBUG_MSG("Stripping time %u from position send\n", p->decoded.position.time);
-            p->decoded.position.time = 0;
-        } else
-            DEBUG_MSG("Providing time to mesh %u\n", p->decoded.position.time);
-    }
-
     // Note: We might return !OK if our fifo was full, at that point the only option we have is to drop it
     router->sendLocal(p);
 }
@@ -221,7 +191,7 @@ NodeInfo *MeshService::refreshMyNodeInfo() {
     Position &position = node->position;
 
     // Update our local node info with our position (even if we don't decide to update anyone else)
-    position.time = getValidTime(RTCQualityGPS); // This nodedb timestamp might be stale, so update it if our clock is valid.
+    position.time = getValidTime(RTCQualityFromNet); // This nodedb timestamp might be stale, so update it if our clock is kinda valid
 
     position.battery_level = powerStatus->getBatteryChargePercent();
     updateBatteryLevel(position.battery_level);
@@ -244,7 +214,7 @@ int MeshService::onGPSChanged(const meshtastic::GPSStatus *unused)
     else {
         // The GPS has lost lock, if we are fixed position we should just keep using
         // the old position
-        if(!radioConfig.preferences.fixed_position) {
+        if(radioConfig.preferences.fixed_position) {
             DEBUG_MSG("WARNING: Using fixed position\n");
         } else {
             // throw away old position
@@ -254,27 +224,10 @@ int MeshService::onGPSChanged(const meshtastic::GPSStatus *unused)
         }
     }
 
-    DEBUG_MSG("got gps notify time=%u, lat=%d, bat=%d\n", pos.latitude_i, pos.time, pos.battery_level);
+    DEBUG_MSG("got gps notify time=%u, lat=%d, bat=%d\n", pos.time, pos.latitude_i, pos.battery_level);
 
     // Update our current position in the local DB
     nodeDB.updatePosition(nodeDB.getNodeNum(), pos);
 
-    // We limit our GPS broadcasts to a max rate
-    static uint32_t lastGpsSend;
-    uint32_t now = millis();
-    if (lastGpsSend == 0 || now - lastGpsSend > getPref_position_broadcast_secs() * 1000) {
-        lastGpsSend = now;
-
-        static uint32_t currentGeneration;
-
-        // If we changed channels, ask everyone else for their latest info
-        bool requestReplies = currentGeneration != radioGeneration;
-        currentGeneration = radioGeneration;
-
-        DEBUG_MSG("Sending position to mesh (wantReplies=%d)\n", requestReplies);
-        assert(positionPlugin);
-        positionPlugin->sendOurPosition(NODENUM_BROADCAST, requestReplies);
-    }
-
     return 0;
 }

src/mesh/MeshTypes.h

@@ -13,6 +13,7 @@ typedef uint32_t PacketId; // A packet sequence number
 #define ERRNO_OK 0
 #define ERRNO_NO_INTERFACES 33
 #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
 
 /**
  * the max number of hops a message can pass through, used as the default max for hop_limit in MeshPacket.

src/mesh/NodeDB.cpp

@@ -7,7 +7,6 @@
 #include "CryptoEngine.h"
 #include "FSCommon.h"
 #include "GPS.h"
-#include "main.h"
 #include "MeshRadio.h"
 #include "NodeDB.h"
 #include "PacketHistory.h"
@@ -16,6 +15,7 @@
 #include "Router.h"
 #include "configuration.h"
 #include "error.h"
+#include "main.h"
 #include "mesh-pb-constants.h"
 #include <pb_decode.h>
 #include <pb_encode.h>
@@ -183,7 +183,7 @@ bool NodeDB::resetRadioConfig()
     memset(activePSK, 0, sizeof(activePSK)); // In case the user provided a short key, we want to pad the rest with zeros
     memcpy(activePSK, channelSettings.psk.bytes, channelSettings.psk.size);
     activePSKSize = channelSettings.psk.size;
-    if(activePSKSize == 0)
+    if (activePSKSize == 0)
         DEBUG_MSG("Warning: User disabled encryption\n");
     else if (activePSKSize == 1) {
         // Convert the short single byte variants of psk into variant that can be used more generally
@@ -199,12 +199,12 @@ bool NodeDB::resetRadioConfig()
             uint8_t *last = activePSK + sizeof(defaultpsk) - 1;
             *last = *last + pskIndex - 1; // index of 1 means no change vs defaultPSK
         }
-    } else if(activePSKSize < 16) {
+    } else if (activePSKSize < 16) {
         // Error! The user specified only the first few bits of an AES128 key.  So by convention we just pad the rest of the key
         // with zeros
         DEBUG_MSG("Warning: User provided a too short AES128 key - padding\n");
         activePSKSize = 16;
-    } else if(activePSKSize < 32 && activePSKSize != 16) {
+    } else if (activePSKSize < 32 && activePSKSize != 16) {
         // Error! The user specified only the first few bits of an AES256 key.  So by convention we just pad the rest of the key
         // with zeros
         DEBUG_MSG("Warning: User provided a too short AES256 key - padding\n");
@@ -489,7 +489,15 @@ void NodeDB::updatePosition(uint32_t nodeId, const Position &p)
 
     DEBUG_MSG("DB update position node=0x%x time=%u, latI=%d, lonI=%d\n", nodeId, p.time, p.latitude_i, p.longitude_i);
 
-    info->position = p;
+    // Be careful to only update fields that have been set by the sender
+    if (p.time)
+        info->position.time = p.time;
+    if(p.battery_level)
+        info->position.battery_level = p.battery_level;
+    if (p.latitude_i || p.longitude_i) {
+        info->position.latitude_i = p.latitude_i;
+        info->position.longitude_i = p.longitude_i;
+    }
     info->has_position = true;
     updateGUIforNode = info;
     notifyObservers(true); // Force an update whether or not our node counts have changed
@@ -601,10 +609,9 @@ void recordCriticalError(CriticalErrorCode code, uint32_t address)
     String lcd = String("Critical error ") + code + "!\n";
     screen->print(lcd.c_str());
     DEBUG_MSG("NOTE! Recording critical error %d, address=%lx\n", code, address);
-    
+
     // Record error to DB
     myNodeInfo.error_code = code;
     myNodeInfo.error_address = address;
     myNodeInfo.error_count++;
-
 }

src/mesh/PhoneAPI.cpp

@@ -87,6 +87,10 @@ void PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
             handleSetRadio(toRadioScratch.set_radio);
             break;
 
+        case ToRadio_set_channel_tag:
+            DEBUG_MSG("Client is setting channel\n");
+            handleSetChannel(toRadioScratch.set_channel);
+            break;
         default:
             DEBUG_MSG("Error: unexpected ToRadio variant\n");
             break;
@@ -275,6 +279,17 @@ void PhoneAPI::handleSetOwner(const User &o)
         service.reloadOwner();
 }
 
+void PhoneAPI::handleSetChannel(const ChannelSettings &cc)
+{
+    radioConfig.channel_settings = cc;
+
+    bool didReset = service.reloadConfig();
+    if (didReset) {
+        state = STATE_SEND_MY_INFO; // Squirt a completely new set of configs to the client
+    }
+
+}
+
 void PhoneAPI::handleSetRadio(const RadioConfig &r)
 {
     radioConfig = r;

src/mesh/PhoneAPI.h

@@ -88,6 +88,7 @@ class PhoneAPI
     //
 
     void handleSetOwner(const User &o);
+    void handleSetChannel(const ChannelSettings &cc);
     void handleSetRadio(const RadioConfig &r);
 
   protected:

src/mesh/RadioInterface.cpp

@@ -212,6 +212,38 @@ unsigned long hash(const char *str)
     return hash;
 }
 
+/**
+ * Save our frequency for later reuse.
+ */
+void RadioInterface::saveFreq(float freq)
+{
+    savedFreq = freq;
+}
+
+/**
+ * Save our channel for later reuse.
+ */
+void RadioInterface::saveChannelNum(uint32_t channel_num)
+{
+    savedChannelNum = channel_num;
+}
+
+/**
+ * Save our frequency for later reuse.
+ */
+float RadioInterface::getFreq()
+{
+    return savedFreq;
+}
+
+/**
+ * Save our channel for later reuse.
+ */
+uint32_t RadioInterface::getChannelNum()
+{
+    return savedChannelNum;
+}
+
 /**
  * Pull our channel settings etc... from protobufs to the dumb interface settings
  */
@@ -264,18 +296,19 @@ void RadioInterface::applyModemConfig()
     assert(myRegion); // Should have been found in init
 
     // If user has manually specified a channel num, then use that, otherwise generate one by hashing the name
-    int channel_num =
-        (channelSettings.channel_num ? channelSettings.channel_num - 1 : hash(channelName)) % myRegion->numChannels;
+    int channel_num = (channelSettings.channel_num ? channelSettings.channel_num - 1 : hash(channelName)) % myRegion->numChannels;
     freq = myRegion->freq + myRegion->spacing * channel_num;
 
-    DEBUG_MSG("Set radio: name=%s, config=%u, ch=%d, power=%d\n", channelName, channelSettings.modem_config, channel_num,
-              power);
+    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("Short packet time: %u msec\n", shortPacketMsec);
+
+    saveChannelNum(channel_num);
+    saveFreq(freq);
 }
 
 /**

src/mesh/RadioInterface.h

@@ -54,6 +54,8 @@ class RadioInterface
     uint32_t shortPacketMsec;
 
   protected:
+    bool disabled = false;
+
     float bw = 125;
     uint8_t sf = 9;
     uint8_t cr = 7;
@@ -98,6 +100,9 @@ class RadioInterface
     /// Prepare hardware for sleep.  Call this _only_ for deep sleep, not needed for light sleep.
     virtual bool sleep() { return true; }
 
+    /// Disable this interface (while disabled, no packets can be sent or received)
+    void disable() { disabled = true; sleep(); }
+
     /**
      * Send a packet (possibly by enquing in a private fifo).  This routine will
      * later free() the packet to pool.  This routine is not allowed to stall.
@@ -136,9 +141,22 @@ class RadioInterface
     uint32_t getPacketTime(MeshPacket *p);
     uint32_t getPacketTime(uint32_t totalPacketLen);
 
+    /**
+     * Get the channel we saved.
+     */
+    uint32_t getChannelNum();
+
+    /**
+     * Get the frequency we saved.
+     */
+    float getFreq();
+
   protected:
     int8_t power = 17; // Set by applyModemConfig()
 
+    float savedFreq;
+    uint32_t savedChannelNum;
+
     /***
      * given a packet set sendingPacket and decode the protobufs into radiobuf.  Returns # of bytes to send (including the
      * PacketHeader & payload).
@@ -160,6 +178,16 @@ class RadioInterface
      */
     virtual void applyModemConfig();
 
+    /**
+     * Save the frequency we selected for later reuse.
+     */
+    virtual void saveFreq(float savedFreq);
+
+    /**
+     * Save the chanel we selected for later reuse.
+     */
+    virtual void saveChannelNum(uint32_t savedChannelNum);
+
   private:
     /// Return 0 if sleep is okay
     int preflightSleepCb(void *unused = NULL) { return canSleep() ? 0 : 1; }

src/mesh/RadioLibInterface.cpp

@@ -2,8 +2,8 @@
 #include "MeshTypes.h"
 #include "NodeDB.h"
 #include "SPILock.h"
-#include "mesh-pb-constants.h"
 #include "error.h"
+#include "mesh-pb-constants.h"
 #include <configuration.h>
 #include <pb_decode.h>
 #include <pb_encode.h>
@@ -68,13 +68,12 @@ bool RadioLibInterface::canSendImmediately()
     bool busyTx = sendingPacket != NULL;
     bool busyRx = isReceiving && isActivelyReceiving();
 
-
     if (busyTx || busyRx) {
         if (busyTx)
             DEBUG_MSG("Can not send yet, busyTx\n");
         // If we've been trying to send the same packet more than one minute and we haven't gotten a
         // TX IRQ from the radio, the radio is probably broken.
-        if (busyTx && (millis() - lastTxStart > 60000)){
+        if (busyTx && (millis() - lastTxStart > 60000)) {
             DEBUG_MSG("Hardware Failure! busyTx for more than 60s\n");
             recordCriticalError(CriticalErrorCode_TransmitFailed);
 #ifndef NO_ESP32
@@ -94,6 +93,11 @@ bool RadioLibInterface::canSendImmediately()
 /// bluetooth comms code.  If the txmit queue is empty it might return an error
 ErrorCode RadioLibInterface::send(MeshPacket *p)
 {
+    if (disabled) {
+        packetPool.release(p);
+        return ERRNO_DISABLED;
+    }
+
     // Sometimes when testing it is useful to be able to never turn on the xmitter
 #ifndef LORA_DISABLE_SENDING
     printPacket("enqueuing for send", p);
@@ -110,7 +114,6 @@ ErrorCode RadioLibInterface::send(MeshPacket *p)
     // Count the packet toward our TX airtime utilization.
     //   We only count it if it can be added to the TX queue.
     airTime->logAirtime(TX_LOG, xmitMsec);
-    //airTime.logAirtime(TX_LOG, xmitMsec);
 
     // We want all sending/receiving to be done by our daemon thread, We use a delay here because this packet might have been sent
     // in response to a packet we just received.  So we want to make sure the other side has had a chance to reconfigure its radio
@@ -119,7 +122,7 @@ ErrorCode RadioLibInterface::send(MeshPacket *p)
     return res;
 #else
     packetPool.release(p);
-    return ERRNO_UNKNOWN;
+    return ERRNO_DISABLED;
 #endif
 }
 
@@ -133,17 +136,17 @@ bool RadioLibInterface::canSleep()
 }
 
 /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
-bool RadioLibInterface::cancelSending(NodeNum from, PacketId id) {
+bool RadioLibInterface::cancelSending(NodeNum from, PacketId id)
+{
     auto p = txQueue.remove(from, id);
-    if(p)
+    if (p)
         packetPool.release(p); // free the packet we just removed
 
     bool result = (p != NULL);
-    DEBUG_MSG("cancelSending id=0x%x, removed=%d", id, result);
+    DEBUG_MSG("cancelSending id=0x%x, removed=%d\n", id, result);
     return result;
 }
 
-
 /** radio helper thread callback.
 
 We never immediately transmit after any operation (either rx or tx).  Instead we should start receiving and
@@ -241,13 +244,14 @@ void RadioLibInterface::handleReceiveInterrupt()
     size_t length = iface->getPacketLength();
 
     xmitMsec = getPacketTime(length);
-    airTime->logAirtime(RX_ALL_LOG, xmitMsec);
-    //airTime.logAirtime(RX_ALL_LOG, xmitMsec);
 
     int state = iface->readData(radiobuf, length);
     if (state != ERR_NONE) {
         DEBUG_MSG("ignoring received packet due to error=%d\n", state);
         rxBad++;
+
+        airTime->logAirtime(RX_ALL_LOG, xmitMsec);
+
     } else {
         // Skip the 4 headers that are at the beginning of the rxBuf
         int32_t payloadLen = length - sizeof(PacketHeader);
@@ -257,6 +261,7 @@ void RadioLibInterface::handleReceiveInterrupt()
         if (payloadLen < 0) {
             DEBUG_MSG("ignoring received packet too short\n");
             rxBad++;
+            airTime->logAirtime(RX_ALL_LOG, xmitMsec);
         } else {
             const PacketHeader *h = (PacketHeader *)radiobuf;
 
@@ -277,15 +282,14 @@ void RadioLibInterface::handleReceiveInterrupt()
             addReceiveMetadata(mp);
 
             mp->which_payloadVariant = MeshPacket_encrypted_tag; // Mark that the payload is still encrypted at this point
-            assert(((uint32_t) payloadLen) <= sizeof(mp->encrypted.bytes));
+            assert(((uint32_t)payloadLen) <= sizeof(mp->encrypted.bytes));
             memcpy(mp->encrypted.bytes, payload, payloadLen);
             mp->encrypted.size = payloadLen;
 
             printPacket("Lora RX", mp);
 
-            xmitMsec = getPacketTime(mp);
+            //xmitMsec = getPacketTime(mp);
             airTime->logAirtime(RX_LOG, xmitMsec);
-            //airTime.logAirtime(RX_LOG, xmitMsec);
 
             deliverToReceiver(mp);
         }
@@ -296,15 +300,20 @@ void RadioLibInterface::handleReceiveInterrupt()
 void RadioLibInterface::startSend(MeshPacket *txp)
 {
     printPacket("Starting low level send", txp);
-    setStandby(); // Cancel any already in process receives
+    if (disabled) {
+        DEBUG_MSG("startSend is dropping tx packet because we are disabled\n");
+        packetPool.release(txp);
+    } else {
+        setStandby(); // Cancel any already in process receives
 
-    configHardwareForSend(); // must be after setStandby
+        configHardwareForSend(); // must be after setStandby
 
-    size_t numbytes = beginSending(txp);
+        size_t numbytes = beginSending(txp);
 
-    int res = iface->startTransmit(radiobuf, numbytes);
-    assert(res == ERR_NONE);
+        int res = iface->startTransmit(radiobuf, numbytes);
+        assert(res == ERR_NONE);
 
-    // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register bits
-    enableInterrupt(isrTxLevel0);
+        // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register bits
+        enableInterrupt(isrTxLevel0);
+    }
 }

src/mesh/generated/deviceonly.pb.h

@@ -80,7 +80,7 @@ extern const pb_msgdesc_t DeviceState_msg;
 #define DeviceState_fields &DeviceState_msg
 
 /* Maximum encoded size of messages (where known) */
-#define DeviceState_size                         6266
+#define DeviceState_size                         6293
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/environmental_measurement.pb.c

@@ -0,0 +1,12 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.4 */
+
+#include "environmental_measurement.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(EnvironmentalMeasurement, EnvironmentalMeasurement, AUTO)
+
+
+

src/mesh/generated/environmental_measurement.pb.h

@@ -0,0 +1,53 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.4 */
+
+#ifndef PB_ENVIRONMENTAL_MEASUREMENT_PB_H_INCLUDED
+#define PB_ENVIRONMENTAL_MEASUREMENT_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _EnvironmentalMeasurement {
+    float temperature;
+    float relative_humidity;
+    float barometric_pressure;
+} EnvironmentalMeasurement;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define EnvironmentalMeasurement_init_default    {0, 0, 0}
+#define EnvironmentalMeasurement_init_zero       {0, 0, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define EnvironmentalMeasurement_temperature_tag 1
+#define EnvironmentalMeasurement_relative_humidity_tag 2
+#define EnvironmentalMeasurement_barometric_pressure_tag 3
+
+/* Struct field encoding specification for nanopb */
+#define EnvironmentalMeasurement_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, FLOAT,    temperature,       1) \
+X(a, STATIC,   SINGULAR, FLOAT,    relative_humidity,   2) \
+X(a, STATIC,   SINGULAR, FLOAT,    barometric_pressure,   3)
+#define EnvironmentalMeasurement_CALLBACK NULL
+#define EnvironmentalMeasurement_DEFAULT NULL
+
+extern const pb_msgdesc_t EnvironmentalMeasurement_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define EnvironmentalMeasurement_fields &EnvironmentalMeasurement_msg
+
+/* Maximum encoded size of messages (where known) */
+#define EnvironmentalMeasurement_size            15
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/mesh.pb.h

@@ -208,6 +208,11 @@ typedef struct _RadioConfig_UserPreferences {
     bool range_test_plugin_save;
     bool store_forward_plugin_enabled;
     uint32_t store_forward_plugin_records;
+    bool environmental_measurement_plugin_measurement_enabled;
+    bool environmental_measurement_plugin_screen_enabled;
+    uint32_t environmental_measurement_plugin_read_error_count_threshold;
+    uint32_t environmental_measurement_plugin_update_interval;
+    uint32_t environmental_measurement_plugin_recovery_interval;
 } RadioConfig_UserPreferences;
 
 typedef struct _RouteDiscovery {
@@ -360,7 +365,7 @@ extern "C" {
 #define MeshPacket_init_default                  {0, 0, 0, {SubPacket_init_default}, 0, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN}
 #define ChannelSettings_init_default             {0, _ChannelSettings_ModemConfig_MIN, {0, {0}}, "", 0, 0, 0, 0, 0, 0, 0}
 #define RadioConfig_init_default                 {false, RadioConfig_UserPreferences_init_default, false, ChannelSettings_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}
+#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}
 #define NodeInfo_init_default                    {0, false, User_init_default, false, Position_init_default, 0, 0}
 #define MyNodeInfo_init_default                  {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0, 0, 0}
 #define LogRecord_init_default                   {"", 0, "", _LogRecord_Level_MIN}
@@ -374,7 +379,7 @@ extern "C" {
 #define MeshPacket_init_zero                     {0, 0, 0, {SubPacket_init_zero}, 0, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN}
 #define ChannelSettings_init_zero                {0, _ChannelSettings_ModemConfig_MIN, {0, {0}}, "", 0, 0, 0, 0, 0, 0, 0}
 #define RadioConfig_init_zero                    {false, RadioConfig_UserPreferences_init_zero, false, ChannelSettings_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}
+#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}
 #define NodeInfo_init_zero                       {0, false, User_init_zero, false, Position_init_zero, 0, 0}
 #define MyNodeInfo_init_zero                     {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0, 0, 0}
 #define LogRecord_init_zero                      {"", 0, "", _LogRecord_Level_MIN}
@@ -460,6 +465,11 @@ extern "C" {
 #define RadioConfig_UserPreferences_range_test_plugin_save_tag 134
 #define RadioConfig_UserPreferences_store_forward_plugin_enabled_tag 136
 #define RadioConfig_UserPreferences_store_forward_plugin_records_tag 137
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_measurement_enabled_tag 140
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_screen_enabled_tag 141
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_read_error_count_threshold_tag 142
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_update_interval_tag 143
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_recovery_interval_tag 144
 #define RouteDiscovery_route_tag                 2
 #define User_id_tag                              1
 #define User_long_name_tag                       2
@@ -641,7 +651,12 @@ X(a, STATIC,   SINGULAR, BOOL,     range_test_plugin_enabled, 132) \
 X(a, STATIC,   SINGULAR, UINT32,   range_test_plugin_sender, 133) \
 X(a, STATIC,   SINGULAR, BOOL,     range_test_plugin_save, 134) \
 X(a, STATIC,   SINGULAR, BOOL,     store_forward_plugin_enabled, 136) \
-X(a, STATIC,   SINGULAR, UINT32,   store_forward_plugin_records, 137)
+X(a, STATIC,   SINGULAR, UINT32,   store_forward_plugin_records, 137) \
+X(a, STATIC,   SINGULAR, BOOL,     environmental_measurement_plugin_measurement_enabled, 140) \
+X(a, STATIC,   SINGULAR, BOOL,     environmental_measurement_plugin_screen_enabled, 141) \
+X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_read_error_count_threshold, 142) \
+X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_update_interval, 143) \
+X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_recovery_interval, 144)
 #define RadioConfig_UserPreferences_CALLBACK NULL
 #define RadioConfig_UserPreferences_DEFAULT NULL
 
@@ -753,13 +768,13 @@ extern const pb_msgdesc_t ToRadio_msg;
 #define SubPacket_size                           275
 #define MeshPacket_size                          322
 #define ChannelSettings_size                     95
-#define RadioConfig_size                         405
-#define RadioConfig_UserPreferences_size         305
+#define RadioConfig_size                         432
+#define RadioConfig_UserPreferences_size         332
 #define NodeInfo_size                            132
 #define MyNodeInfo_size                          106
 #define LogRecord_size                           81
-#define FromRadio_size                           414
-#define ToRadio_size                             409
+#define FromRadio_size                           441
+#define ToRadio_size                             436
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/portnums.pb.h

@@ -21,6 +21,7 @@ typedef enum _PortNum {
     PortNum_SERIAL_APP = 64,
     PortNum_STORE_FORWARD_APP = 65,
     PortNum_RANGE_TEST_APP = 66,
+    PortNum_ENVIRONMENTAL_MEASUREMENT_APP = 67,
     PortNum_PRIVATE_APP = 256,
     PortNum_ATAK_FORWARDER = 257
 } PortNum;

src/mesh/http/ContentHandler.cpp

@@ -11,6 +11,7 @@
 #include <HTTPMultipartBodyParser.hpp>
 #include <HTTPURLEncodedBodyParser.hpp>
 #include <SPIFFS.h>
+#include "RadioLibInterface.h"
 
 #ifndef NO_ESP32
 #include "esp_task_wdt.h"
@@ -928,10 +929,17 @@ void handleReport(HTTPRequest *req, HTTPResponse *res)
     res->printf("\"has_battery\": %s,\n", BoolToString(powerStatus->getHasBattery()));
     res->printf("\"has_usb\": %s,\n", BoolToString(powerStatus->getHasUSB()));
     res->printf("\"is_charging\": %s\n", BoolToString(powerStatus->getIsCharging()));
+    res->println("},");
+
+    res->println("\"radio\": {");
+    res->printf("\"frequecy\": %f,\n", RadioLibInterface::instance->getFreq());
+    res->printf("\"lora_channel\": %d\n", RadioLibInterface::instance->getChannelNum());
     res->println("}");
 
     res->println("},");
 
+
+
     res->println("\"status\": \"ok\"");
     res->println("}");
 }

src/plugins/ExternalNotificationPlugin.cpp

@@ -6,12 +6,12 @@
 #include "configuration.h"
 #include <Arduino.h>
 
-#include <assert.h>
+//#include <assert.h>
 
 /*
 
     Documentation:
-        https://github.com/mc-hamster/Meshtastic-device/blob/master/docs/software/plugins/ExternalNotificationPlugin.md
+        https://github.com/meshtastic/Meshtastic-device/blob/master/docs/software/plugins/ExternalNotificationPlugin.md
 
     This plugin supports:
         https://github.com/meshtastic/Meshtastic-device/issues/654

src/plugins/NodeInfoPlugin.cpp

@@ -29,7 +29,7 @@ bool NodeInfoPlugin::handleReceivedProtobuf(const MeshPacket &mp, const User &p)
 void NodeInfoPlugin::sendOurNodeInfo(NodeNum dest, bool wantReplies)
 {
     // cancel any not yet sent (now stale) position packets
-    if(prevPacketId) // if we wrap around to zero, we'll simply fail to cancel in that rare case (no big deal)
+    if (prevPacketId) // if we wrap around to zero, we'll simply fail to cancel in that rare case (no big deal)
         service.cancelSending(prevPacketId);
 
     MeshPacket *p = allocReply();
@@ -48,3 +48,26 @@ MeshPacket *NodeInfoPlugin::allocReply()
     DEBUG_MSG("sending owner %s/%s/%s\n", u.id, u.long_name, u.short_name);
     return allocDataProtobuf(u);
 }
+
+NodeInfoPlugin::NodeInfoPlugin()
+    : ProtobufPlugin("nodeinfo", PortNum_NODEINFO_APP, User_fields), concurrency::OSThread("NodeInfoPlugin")
+{
+    setIntervalFromNow(30 *
+                       1000); // Send our initial owner announcement 30 seconds after we start (to give network time to setup)
+}
+
+int32_t NodeInfoPlugin::runOnce()
+{
+    static uint32_t currentGeneration;
+
+    // If we changed channels, ask everyone else for their latest info
+    bool requestReplies = currentGeneration != radioGeneration;
+    currentGeneration = radioGeneration;
+
+    DEBUG_MSG("Sending our nodeinfo to mesh (wantReplies=%d)\n", requestReplies);
+    assert(nodeInfoPlugin);
+    nodeInfoPlugin->sendOurNodeInfo(NODENUM_BROADCAST, requestReplies); // Send our info (don't request replies)
+
+    return getPref_position_broadcast_secs() * 1000;
+}
+

src/plugins/NodeInfoPlugin.h

@@ -4,17 +4,18 @@
 /**
  * NodeInfo plugin for sending/receiving NodeInfos into the mesh
  */
-class NodeInfoPlugin : public ProtobufPlugin<User>
+class NodeInfoPlugin : public ProtobufPlugin<User>, private concurrency::OSThread
 {
     /// The id of the last packet we sent, to allow us to cancel it if we make something fresher
     PacketId prevPacketId = 0;
-      
+    
+    uint32_t currentGeneration = 0;
   public:
     /** Constructor
      * name is for debugging output
      */
-    NodeInfoPlugin() : ProtobufPlugin("nodeinfo", PortNum_NODEINFO_APP, User_fields) {}
-
+    NodeInfoPlugin();
+    
     /**
      * Send our NodeInfo into the mesh
      */
@@ -30,6 +31,9 @@ class NodeInfoPlugin : public ProtobufPlugin<User>
     /** 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.  */
     virtual MeshPacket *allocReply();
+
+    /** Does our periodic broadcast */
+    virtual int32_t runOnce();      
 };
 
 extern NodeInfoPlugin *nodeInfoPlugin;

src/plugins/Plugins.cpp

@@ -3,9 +3,15 @@
 #include "plugins/PositionPlugin.h"
 #include "plugins/RemoteHardwarePlugin.h"
 #include "plugins/ReplyPlugin.h"
-#include "plugins/SerialPlugin.h"
 #include "plugins/TextMessagePlugin.h"
 
+#ifndef NO_ESP32
+#include "plugins/SerialPlugin.h"
+#include "plugins/esp32/EnvironmentalMeasurementPlugin.h"
+#include "plugins/esp32/RangeTestPlugin.h"
+#include "plugins/esp32/StoreForwardPlugin.h"
+#endif
+
 /**
  * Create plugin instances here.  If you are adding a new plugin, you must 'new' it here (or somewhere else)
  */
@@ -24,7 +30,17 @@ void setupPlugins()
 #ifndef NO_ESP32
     // Only run on an esp32 based device.
 
-    new SerialPlugin();               // Maintained by MC Hamster (Jm Casler) jm@casler.org
-    new ExternalNotificationPlugin(); // Maintained by MC Hamster (Jm Casler) jm@casler.org
+    /*
+        Maintained by MC Hamster (Jm Casler) jm@casler.org
+    */
+    new SerialPlugin();
+    new ExternalNotificationPlugin();
+
+    // rangeTestPlugin = new RangeTestPlugin();
+    storeForwardPlugin = new StoreForwardPlugin();
+
+    new RangeTestPlugin();
+    // new StoreForwardPlugin();
+    new EnvironmentalMeasurementPlugin();
 #endif
 }

src/plugins/PositionPlugin.cpp

@@ -7,6 +7,14 @@
 
 PositionPlugin *positionPlugin;
 
+PositionPlugin::PositionPlugin()
+    : ProtobufPlugin("position", PortNum_POSITION_APP, Position_fields), concurrency::OSThread("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 &p)
 {
     // FIXME - we currently update position data in the DB only if the message was a broadcast or destined to us
@@ -31,14 +39,25 @@ MeshPacket *PositionPlugin::allocReply()
 {
     NodeInfo *node = service.refreshMyNodeInfo(); // should guarantee there is now a position
     assert(node->has_position);
-    
-    return allocDataProtobuf(node->position);
+
+    Position p = node->position;
+
+    // Strip out any time information before sending packets to other nodes - to keep the wire size small (and because other
+    // nodes shouldn't trust it anyways) Note: we allow a device with a local GPS to include the time, so that gpsless
+    // devices can get time.
+    if (getRTCQuality() < RTCQualityGPS) {
+        DEBUG_MSG("Stripping time %u from position send\n", p.time);
+        p.time = 0;
+    } else
+        DEBUG_MSG("Providing time to mesh %u\n", p.time);
+
+    return allocDataProtobuf(p);
 }
 
 void PositionPlugin::sendOurPosition(NodeNum dest, bool wantReplies)
 {
     // cancel any not yet sent (now stale) position packets
-    if(prevPacketId) // if we wrap around to zero, we'll simply fail to cancel in that rare case (no big deal)
+    if (prevPacketId) // if we wrap around to zero, we'll simply fail to cancel in that rare case (no big deal)
         service.cancelSending(prevPacketId);
 
     MeshPacket *p = allocReply();
@@ -50,3 +69,21 @@ void PositionPlugin::sendOurPosition(NodeNum dest, bool wantReplies)
     service.sendToMesh(p);
 }
 
+int32_t PositionPlugin::runOnce()
+{
+
+    // We limit our GPS broadcasts to a max rate
+    uint32_t now = millis();
+    if (lastGpsSend == 0 || now - lastGpsSend >= getPref_position_broadcast_secs() * 1000) {
+        lastGpsSend = now;
+
+        // If we changed channels, ask everyone else for their latest info
+        bool requestReplies = currentGeneration != radioGeneration;
+        currentGeneration = radioGeneration;
+
+        DEBUG_MSG("Sending position to mesh (wantReplies=%d)\n", requestReplies);
+        sendOurPosition(NODENUM_BROADCAST, requestReplies);
+    }
+
+    return 5000; // to save power only wake for our callback occasionally
+}

src/plugins/PositionPlugin.h

@@ -1,20 +1,27 @@
 #pragma once
 #include "ProtobufPlugin.h"
+#include "concurrency/OSThread.h"
 
 /**
  * Position plugin for sending/receiving positions into the mesh
  */
-class PositionPlugin : public ProtobufPlugin<Position>
+class PositionPlugin : public ProtobufPlugin<Position>, private concurrency::OSThread
 {
     /// The id of the last packet we sent, to allow us to cancel it if we make something fresher
     PacketId prevPacketId = 0;
 
+    /// We limit our GPS broadcasts to a max rate
+    uint32_t lastGpsSend = 0;
+
+    /// We force a rebroadcast if the radio settings change
+    uint32_t currentGeneration = 0;
+
   public:
     /** Constructor
      * name is for debugging output
      */
-    PositionPlugin() : ProtobufPlugin("position", PortNum_POSITION_APP, Position_fields) {}
-
+    PositionPlugin();
+    
     /**
      * Send our position into the mesh
      */
@@ -31,6 +38,9 @@ class PositionPlugin : public ProtobufPlugin<Position>
     /** 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.  */
     virtual MeshPacket *allocReply();
+
+    /** Does our periodic broadcast */
+    virtual int32_t runOnce();  
 };
 
 extern PositionPlugin *positionPlugin;

src/plugins/esp32/EnvironmentalMeasurementPlugin.cpp

@@ -0,0 +1,209 @@
+#include "EnvironmentalMeasurementPlugin.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "RTC.h"
+#include "Router.h"
+#include "configuration.h"
+#include "main.h"
+#include "../mesh/generated/environmental_measurement.pb.h"
+#include <DHT.h>
+#include <OLEDDisplay.h>
+#include <OLEDDisplayUi.h>
+
+EnvironmentalMeasurementPlugin *environmentalMeasurementPlugin;
+EnvironmentalMeasurementPluginRadio *environmentalMeasurementPluginRadio;
+
+EnvironmentalMeasurementPlugin::EnvironmentalMeasurementPlugin() : concurrency::OSThread("EnvironmentalMeasurementPlugin") {}
+
+uint32_t sensor_read_error_count = 0;
+
+#define DHT_11_GPIO_PIN 13
+#define DHT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS 1000 // Some sensors (the DHT11) have a minimum required duration between read attempts
+#define FAILED_STATE_SENSOR_READ_MULTIPLIER 10
+#define DISPLAY_RECEIVEID_MEASUREMENTS_ON_SCREEN true
+
+DHT dht(DHT_11_GPIO_PIN,DHT11);
+
+
+#ifdef HAS_EINK
+// The screen is bigger so use bigger fonts
+#define FONT_SMALL ArialMT_Plain_16
+#define FONT_MEDIUM ArialMT_Plain_24
+#define FONT_LARGE ArialMT_Plain_24
+#else
+#define FONT_SMALL ArialMT_Plain_10
+#define FONT_MEDIUM ArialMT_Plain_16
+#define FONT_LARGE ArialMT_Plain_24
+#endif
+
+#define fontHeight(font) ((font)[1] + 1) // height is position 1
+
+#define FONT_HEIGHT_SMALL fontHeight(FONT_SMALL)
+#define FONT_HEIGHT_MEDIUM fontHeight(FONT_MEDIUM)
+
+
+int32_t EnvironmentalMeasurementPlugin::runOnce() {
+#ifndef NO_ESP32 // this only works on ESP32 devices
+
+    /*
+        Uncomment the preferences below if you want to use the plugin
+        without having to configure it from the PythonAPI or WebUI.
+    */
+    /*radioConfig.preferences.environmental_measurement_plugin_measurement_enabled = 1;
+    radioConfig.preferences.environmental_measurement_plugin_screen_enabled = 1;
+    radioConfig.preferences.environmental_measurement_plugin_read_error_count_threshold = 5;
+    radioConfig.preferences.environmental_measurement_plugin_update_interval = 30;
+    radioConfig.preferences.environmental_measurement_plugin_recovery_interval = 600;*/
+
+    if (! (radioConfig.preferences.environmental_measurement_plugin_measurement_enabled || radioConfig.preferences.environmental_measurement_plugin_screen_enabled)){
+        // If this plugin is not enabled, and the user doesn't want the display screen don't waste any OSThread time on it
+        return (INT32_MAX);
+    }
+
+    if (firstTime) {
+        // This is the first time the OSThread library has called this function, so do some setup
+        DEBUG_MSG("EnvironmentalMeasurement: Initializing\n");
+        environmentalMeasurementPluginRadio = new EnvironmentalMeasurementPluginRadio();
+        firstTime = 0;
+        // begin reading measurements from the sensor
+        // DHT have a max read-rate of 1HZ, so we should wait at least 1 second
+        // after initializing the sensor before we try to read from it.
+        // returning the interval here means that the next time OSThread
+        // calls our plugin, we'll run the other branch of this if statement
+        // and actually do a "sendOurEnvironmentalMeasurement()"
+        if (radioConfig.preferences.environmental_measurement_plugin_measurement_enabled)
+        {
+            // it's possible to have this plugin enabled, only for displaying values on the screen.
+            // therefore, we should only enable the sensor loop if measurement is also enabled
+            dht.begin();
+            return(DHT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);   
+        }
+        return (INT32_MAX);
+    }
+    else {
+        if (!radioConfig.preferences.environmental_measurement_plugin_measurement_enabled)
+        {
+            // if we somehow got to a second run of this plugin with measurement disabled, then just wait forever
+            // I can't imagine we'd ever get here though.
+            return (INT32_MAX);
+        }
+        // this is not the first time OSThread library has called this function
+        // so just do what we intend to do on the interval
+        if(sensor_read_error_count > radioConfig.preferences.environmental_measurement_plugin_read_error_count_threshold)
+        {
+            if (radioConfig.preferences.environmental_measurement_plugin_recovery_interval > 0 ) {
+                DEBUG_MSG(
+                    "EnvironmentalMeasurement: TEMPORARILY DISABLED; The environmental_measurement_plugin_read_error_count_threshold has been exceed: %d. Will retry reads in %d seconds\n",
+                    radioConfig.preferences.environmental_measurement_plugin_read_error_count_threshold,
+                    radioConfig.preferences.environmental_measurement_plugin_recovery_interval);
+                return(radioConfig.preferences.environmental_measurement_plugin_recovery_interval*1000);  
+            }
+             DEBUG_MSG(
+                    "EnvironmentalMeasurement: DISABLED; The environmental_measurement_plugin_read_error_count_threshold has been exceed: %d. Reads will not be retried until after device reset\n",
+                    radioConfig.preferences.environmental_measurement_plugin_read_error_count_threshold);
+                return(INT32_MAX);
+
+            
+        }
+        else if (sensor_read_error_count > 0){
+            DEBUG_MSG("EnvironmentalMeasurement: There have been %d sensor read failures. Will retry %d more times\n", 
+                sensor_read_error_count, 
+                radioConfig.preferences.environmental_measurement_plugin_read_error_count_threshold-sensor_read_error_count);
+        }
+        if (! environmentalMeasurementPluginRadio->sendOurEnvironmentalMeasurement() ){
+            // if we failed to read the sensor, then try again 
+            // as soon as we can according to the maximum polling frequency
+            return(DHT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS);
+        }
+    }
+    // The return of runOnce is an int32 representing the desired number of 
+    // miliseconds until the function should be called again by the 
+    // OSThread library.  Multiply the preference value by 1000 to convert seconds to miliseconds
+    return(radioConfig.preferences.environmental_measurement_plugin_update_interval * 1000);   
+#endif
+}
+
+bool EnvironmentalMeasurementPluginRadio::wantUIFrame() {
+    return radioConfig.preferences.environmental_measurement_plugin_screen_enabled;
+}
+
+void EnvironmentalMeasurementPluginRadio::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
+{
+    display->setTextAlignment(TEXT_ALIGN_LEFT);
+    display->setFont(FONT_MEDIUM);
+    display->drawString(x, y, "Environment");
+    display->setFont(FONT_SMALL);
+    display->drawString(x, y += fontHeight(FONT_MEDIUM), lastSender+": T:"+ String(lastMeasurement.temperature,2) + " H:" + String(lastMeasurement.relative_humidity,2));
+
+}
+
+String GetSenderName(const MeshPacket &mp) {
+    String sender;
+
+    if (nodeDB.getNode(mp.from)){
+        sender = nodeDB.getNode(mp.from)->user.short_name;
+    }
+    else {
+        sender = "UNK";
+    }
+    return sender;
+}
+
+bool EnvironmentalMeasurementPluginRadio::handleReceivedProtobuf(const MeshPacket &mp, const 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 
+         return false;
+    }
+    bool wasBroadcast = mp.to == NODENUM_BROADCAST;
+
+    String sender = GetSenderName(mp);
+    
+    // Show new nodes on LCD screen
+    if (DISPLAY_RECEIVEID_MEASUREMENTS_ON_SCREEN && wasBroadcast) {
+        String lcd = String("Env Measured: ") +sender + "\n" +
+            "T: " + p.temperature + "\n" +
+            "H: " + p.relative_humidity + "\n";
+        screen->print(lcd.c_str());
+    }
+    DEBUG_MSG("-----------------------------------------\n");
+
+    DEBUG_MSG("EnvironmentalMeasurement: Received data from %s\n", sender);
+    DEBUG_MSG("EnvironmentalMeasurement->relative_humidity: %f\n", p.relative_humidity);
+    DEBUG_MSG("EnvironmentalMeasurement->temperature: %f\n", p.temperature);
+
+    lastMeasurement = p;
+    lastSender = sender;
+    return false; // Let others look at this message also if they want
+}
+
+bool EnvironmentalMeasurementPluginRadio::sendOurEnvironmentalMeasurement(NodeNum dest, bool wantReplies)
+{
+    EnvironmentalMeasurement m;
+
+    m.barometric_pressure = 0; // TODO: Add support for barometric sensors
+    m.relative_humidity = dht.readHumidity();
+    m.temperature = dht.readTemperature();;
+
+    DEBUG_MSG("-----------------------------------------\n");
+
+    DEBUG_MSG("EnvironmentalMeasurement: Read data\n");
+    DEBUG_MSG("EnvironmentalMeasurement->relative_humidity: %f\n", m.relative_humidity);
+    DEBUG_MSG("EnvironmentalMeasurement->temperature: %f\n", m.temperature);
+
+    if (isnan(m.relative_humidity) || isnan(m.temperature) ){
+        sensor_read_error_count++;
+        DEBUG_MSG("EnvironmentalMeasurement: FAILED TO READ DATA\n");
+        return false;
+    }
+
+    sensor_read_error_count = 0;
+
+    MeshPacket *p = allocDataProtobuf(m);
+    p->to = dest;
+    p->decoded.want_response = wantReplies;
+
+    service.sendToMesh(p);
+    return true;
+}
+

src/plugins/esp32/EnvironmentalMeasurementPlugin.h

@@ -0,0 +1,63 @@
+#pragma once
+#include "ProtobufPlugin.h"
+#include "../mesh/generated/environmental_measurement.pb.h"
+#include <OLEDDisplay.h>
+#include <OLEDDisplayUi.h>
+
+
+class EnvironmentalMeasurementPlugin : private concurrency::OSThread
+{
+    bool firstTime = 1;
+
+  public:
+    EnvironmentalMeasurementPlugin();
+
+  protected:
+    virtual int32_t runOnce();
+};
+
+extern EnvironmentalMeasurementPlugin *environmentalMeasurementPlugin;
+
+/**
+ * EnvironmentalMeasurementPluginRadio plugin for sending/receiving environmental measurements to/from the mesh
+ */
+class EnvironmentalMeasurementPluginRadio : public ProtobufPlugin<EnvironmentalMeasurement>
+{
+  public:
+    /** Constructor
+     * name is for debugging output
+     */
+    EnvironmentalMeasurementPluginRadio() : ProtobufPlugin("EnvironmentalMeasurement", PortNum_ENVIRONMENTAL_MEASUREMENT_APP, &EnvironmentalMeasurement_msg) {
+      lastMeasurement.barometric_pressure = nanf("");
+      lastMeasurement.relative_humidity =  nanf("");
+      lastMeasurement.temperature =  nanf("");
+      lastSender = "N/A";
+    }
+
+    /**
+     * Send our EnvironmentalMeasurement into the mesh
+     */
+    bool sendOurEnvironmentalMeasurement(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
+    
+    virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
+
+  protected:
+    
+    /** 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 wantUIFrame();
+
+
+  private:
+  
+    EnvironmentalMeasurement lastMeasurement;
+
+    String lastSender;
+
+};
+
+extern EnvironmentalMeasurementPluginRadio *environmentalMeasurementPluginRadio;

src/plugins/esp32/RangeTestPlugin.cpp

@@ -0,0 +1,315 @@
+#include "RangeTestPlugin.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "PowerFSM.h"
+#include "RTC.h"
+#include "Router.h"
+#include "configuration.h"
+#include <Arduino.h>
+#include <SPIFFS.h>
+//#include <assert.h>
+
+/*
+    As a sender, I can send packets every n-seonds. These packets include an incramented PacketID.
+
+    As a receiver, I can receive packets from multiple senders. These packets can be saved to the spiffs.
+*/
+
+RangeTestPlugin *rangeTestPlugin;
+RangeTestPluginRadio *rangeTestPluginRadio;
+
+RangeTestPlugin::RangeTestPlugin() : concurrency::OSThread("RangeTestPlugin") {}
+
+uint32_t packetSequence = 0;
+
+#define SEC_PER_DAY 86400
+#define SEC_PER_HOUR 3600
+#define SEC_PER_MIN 60
+
+int32_t RangeTestPlugin::runOnce()
+{
+#ifndef NO_ESP32
+
+    /*
+        Uncomment the preferences below if you want to use the plugin
+        without having to configure it from the PythonAPI or WebUI.
+    */
+
+    //radioConfig.preferences.range_test_plugin_enabled = 1;
+    //radioConfig.preferences.range_test_plugin_sender = 45;
+    //radioConfig.preferences.range_test_plugin_save = 1;
+
+    // Fixed position is useful when testing indoors.
+    // radioConfig.preferences.fixed_position = 1;
+
+    uint32_t senderHeartbeat = radioConfig.preferences.range_test_plugin_sender * 1000;
+
+    if (radioConfig.preferences.range_test_plugin_enabled) {
+
+        if (firstTime) {
+
+            // Interface with the serial peripheral from in here.
+
+            rangeTestPluginRadio = new RangeTestPluginRadio();
+
+            firstTime = 0;
+
+            if (radioConfig.preferences.range_test_plugin_sender) {
+                DEBUG_MSG("Initializing Range Test Plugin -- Sender\n");
+                return (5000); // Sending first message 5 seconds after initilization.
+            } else {
+                DEBUG_MSG("Initializing Range Test Plugin -- Receiver\n");
+                return (500);
+            }
+
+        } else {
+
+            if (radioConfig.preferences.range_test_plugin_sender) {
+                // If sender
+                DEBUG_MSG("Range Test Plugin - Sending heartbeat every %d ms\n", (senderHeartbeat));
+
+                DEBUG_MSG("gpsStatus->getLatitude()     %d\n", gpsStatus->getLatitude());
+                DEBUG_MSG("gpsStatus->getLongitude()    %d\n", gpsStatus->getLongitude());
+                DEBUG_MSG("gpsStatus->getHasLock()      %d\n", gpsStatus->getHasLock());
+                DEBUG_MSG("gpsStatus->getDOP()          %d\n", gpsStatus->getDOP());
+                DEBUG_MSG("gpsStatus->getHasLock()      %d\n", gpsStatus->getHasLock());
+                DEBUG_MSG("pref.fixed_position()        %d\n", radioConfig.preferences.fixed_position);
+
+                rangeTestPluginRadio->sendPayload();
+                return (senderHeartbeat);
+            } else {
+                // Otherwise, we're a receiver.
+
+                return (500);
+            }
+            // TBD
+        }
+
+    } else {
+        DEBUG_MSG("Range Test Plugin - Disabled\n");
+    }
+
+    return (INT32_MAX);
+#endif
+}
+
+MeshPacket *RangeTestPluginRadio::allocReply()
+{
+
+    auto reply = allocDataPacket(); // Allocate a packet for sending
+
+    return reply;
+}
+
+void RangeTestPluginRadio::sendPayload(NodeNum dest, bool wantReplies)
+{
+    MeshPacket *p = allocReply();
+    p->to = dest;
+    p->decoded.want_response = wantReplies;
+
+    p->want_ack = true;
+
+    packetSequence++;
+
+    static char heartbeatString[20];
+    snprintf(heartbeatString, sizeof(heartbeatString), "seq %d", packetSequence);
+
+    p->decoded.data.payload.size = strlen(heartbeatString); // You must specify how many bytes are in the reply
+    memcpy(p->decoded.data.payload.bytes, heartbeatString, p->decoded.data.payload.size);
+
+    service.sendToMesh(p);
+
+    // TODO: Handle this better. We want to keep the phone awake otherwise it stops sending.
+    powerFSM.trigger(EVENT_CONTACT_FROM_PHONE);
+}
+
+bool RangeTestPluginRadio::handleReceived(const MeshPacket &mp)
+{
+#ifndef NO_ESP32
+
+    if (radioConfig.preferences.range_test_plugin_enabled) {
+
+        auto &p = mp.decoded.data;
+        // DEBUG_MSG("Received text msg self=0x%0x, from=0x%0x, to=0x%0x, id=%d, msg=%.*s\n",
+        //          nodeDB.getNodeNum(), mp.from, mp.to, mp.id, p.payload.size, p.payload.bytes);
+
+        if (mp.from != nodeDB.getNodeNum()) {
+
+            // DEBUG_MSG("* * Message came from the mesh\n");
+            // Serial2.println("* * Message came from the mesh");
+            // Serial2.printf("%s", p.payload.bytes);
+            /*
+
+
+
+            */
+
+            NodeInfo *n = nodeDB.getNode(mp.from);
+
+            if (radioConfig.preferences.range_test_plugin_save) {
+                appendFile(mp);
+            }
+
+            DEBUG_MSG("-----------------------------------------\n");
+            DEBUG_MSG("p.payload.bytes  \"%s\"\n", p.payload.bytes);
+            DEBUG_MSG("p.payload.size   %d\n", p.payload.size);
+            DEBUG_MSG("---- Received Packet:\n");
+            DEBUG_MSG("mp.from          %d\n", mp.from);
+            DEBUG_MSG("mp.rx_snr        %f\n", mp.rx_snr);
+            DEBUG_MSG("mp.hop_limit     %d\n", mp.hop_limit);
+            // DEBUG_MSG("mp.decoded.position.latitude_i     %d\n", mp.decoded.position.latitude_i); // Depricated
+            // DEBUG_MSG("mp.decoded.position.longitude_i    %d\n", mp.decoded.position.longitude_i); // Depricated
+            DEBUG_MSG("---- Node Information of Received Packet (mp.from):\n");
+            DEBUG_MSG("n->user.long_name         %s\n", n->user.long_name);
+            DEBUG_MSG("n->user.short_name        %s\n", n->user.short_name);
+            // DEBUG_MSG("n->user.macaddr           %X\n", n->user.macaddr);
+            DEBUG_MSG("n->has_position           %d\n", n->has_position);
+            DEBUG_MSG("n->position.latitude_i    %d\n", n->position.latitude_i);
+            DEBUG_MSG("n->position.longitude_i   %d\n", n->position.longitude_i);
+            DEBUG_MSG("n->position.battery_level %d\n", n->position.battery_level);
+            DEBUG_MSG("---- Current device location information:\n");
+            DEBUG_MSG("gpsStatus->getLatitude()     %d\n", gpsStatus->getLatitude());
+            DEBUG_MSG("gpsStatus->getLongitude()    %d\n", gpsStatus->getLongitude());
+            DEBUG_MSG("gpsStatus->getHasLock()      %d\n", gpsStatus->getHasLock());
+            DEBUG_MSG("gpsStatus->getDOP()          %d\n", gpsStatus->getDOP());
+            DEBUG_MSG("-----------------------------------------\n");
+        }
+
+    } else {
+        DEBUG_MSG("Range Test Plugin Disabled\n");
+    }
+
+#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);
+}
+
+bool RangeTestPluginRadio::appendFile(const MeshPacket &mp)
+{
+    auto &p = mp.decoded.data;
+
+    NodeInfo *n = nodeDB.getNode(mp.from);
+    /*
+        DEBUG_MSG("-----------------------------------------\n");
+        DEBUG_MSG("p.payload.bytes  \"%s\"\n", p.payload.bytes);
+        DEBUG_MSG("p.payload.size   %d\n", p.payload.size);
+        DEBUG_MSG("---- Received Packet:\n");
+        DEBUG_MSG("mp.from          %d\n", mp.from);
+        DEBUG_MSG("mp.rx_snr        %f\n", mp.rx_snr);
+        DEBUG_MSG("mp.hop_limit     %d\n", mp.hop_limit);
+        // DEBUG_MSG("mp.decoded.position.latitude_i     %d\n", mp.decoded.position.latitude_i);  // Depricated
+        // DEBUG_MSG("mp.decoded.position.longitude_i    %d\n", mp.decoded.position.longitude_i); // Depricated
+        DEBUG_MSG("---- Node Information of Received Packet (mp.from):\n");
+        DEBUG_MSG("n->user.long_name         %s\n", n->user.long_name);
+        DEBUG_MSG("n->user.short_name        %s\n", n->user.short_name);
+        DEBUG_MSG("n->user.macaddr           %X\n", n->user.macaddr);
+        DEBUG_MSG("n->has_position           %d\n", n->has_position);
+        DEBUG_MSG("n->position.latitude_i    %d\n", n->position.latitude_i);
+        DEBUG_MSG("n->position.longitude_i   %d\n", n->position.longitude_i);
+        DEBUG_MSG("n->position.battery_level %d\n", n->position.battery_level);
+        DEBUG_MSG("---- Current device location information:\n");
+        DEBUG_MSG("gpsStatus->getLatitude()     %d\n", gpsStatus->getLatitude());
+        DEBUG_MSG("gpsStatus->getLongitude()    %d\n", gpsStatus->getLongitude());
+        DEBUG_MSG("gpsStatus->getHasLock()      %d\n", gpsStatus->getHasLock());
+        DEBUG_MSG("gpsStatus->getDOP()          %d\n", gpsStatus->getDOP());
+        DEBUG_MSG("-----------------------------------------\n");
+    */
+    if (!SPIFFS.begin(true)) {
+        DEBUG_MSG("An Error has occurred while mounting SPIFFS\n");
+        return 0;
+    }
+
+    if (SPIFFS.totalBytes() - SPIFFS.usedBytes() < 51200) {
+        DEBUG_MSG("SPIFFS doesn't have enough free space. Abourting write.\n");
+        return 0;
+    }
+
+    // If the file doesn't exist, write the header.
+    if (!SPIFFS.exists("/static/rangetest.csv")) {
+        //--------- Write to file
+        File fileToWrite = SPIFFS.open("/static/rangetest.csv", FILE_WRITE);
+
+        if (!fileToWrite) {
+            DEBUG_MSG("There was an error opening the file for writing\n");
+            return 0;
+        }
+
+        if (fileToWrite.println("time,from,sender name,sender lat,sender long,rx lat,rx long,rx snr,distance,payload")) {
+            DEBUG_MSG("File was written\n");
+        } else {
+            DEBUG_MSG("File write failed\n");
+        }
+
+        fileToWrite.close();
+    }
+
+    //--------- Apend content to file
+    File fileToAppend = SPIFFS.open("/static/rangetest.csv", FILE_APPEND);
+
+    if (!fileToAppend) {
+        DEBUG_MSG("There was an error opening the file for appending\n");
+        return 0;
+    }
+
+    struct timeval tv;
+    if (!gettimeofday(&tv, NULL)) {
+        long hms = tv.tv_sec % SEC_PER_DAY;
+        // hms += tz.tz_dsttime * SEC_PER_HOUR;
+        // hms -= tz.tz_minuteswest * SEC_PER_MIN;
+        // mod `hms` to ensure in positive range of [0...SEC_PER_DAY)
+        hms = (hms + SEC_PER_DAY) % SEC_PER_DAY;
+
+        // Tear apart hms into h:m:s
+        int hour = hms / SEC_PER_HOUR;
+        int min = (hms % SEC_PER_HOUR) / SEC_PER_MIN;
+        int sec = (hms % SEC_PER_HOUR) % SEC_PER_MIN; // or hms % SEC_PER_MIN
+
+        fileToAppend.printf("%02d:%02d:%02d,", hour, min, sec); // Time
+    } else {
+        fileToAppend.printf("??:??:??,"); // Time
+    }
+
+    fileToAppend.printf("%d,", mp.from);                          // From
+    fileToAppend.printf("%s,", n->user.long_name);                // Long Name
+    fileToAppend.printf("%f,", n->position.latitude_i * 1e-7);    // Sender Lat
+    fileToAppend.printf("%f,", n->position.longitude_i * 1e-7);   // Sender Long
+    fileToAppend.printf("%f,", gpsStatus->getLatitude() * 1e-7);  // RX Lat
+    fileToAppend.printf("%f,", gpsStatus->getLongitude() * 1e-7); // RX Long
+    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,
+                                        gpsStatus->getLatitude() * 1e-7, gpsStatus->getLongitude() * 1e-7);
+        fileToAppend.printf("%f,", distance); // Distance in meters
+    } else {
+        fileToAppend.printf("0,");
+    }
+
+    // TODO: If quotes are found in the payload, it has to be escaped.
+    fileToAppend.printf("\"%s\"\n", p.payload.bytes);
+
+    fileToAppend.close();
+
+    return 1;
+}

src/plugins/esp32/RangeTestPlugin.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "SinglePortPlugin.h"
+#include "concurrency/OSThread.h"
+#include "configuration.h"
+#include <Arduino.h>
+#include <functional>
+
+class RangeTestPlugin : private concurrency::OSThread
+{
+    bool firstTime = 1;
+
+  public:
+    RangeTestPlugin();
+
+  protected:
+    virtual int32_t runOnce();
+};
+
+extern RangeTestPlugin *rangeTestPlugin;
+
+/*
+ * Radio interface for RangeTestPlugin
+ *
+ */
+class RangeTestPluginRadio : public SinglePortPlugin
+{
+    uint32_t lastRxID;
+
+  public:
+    RangeTestPluginRadio() : SinglePortPlugin("RangeTestPluginRadio", PortNum_TEXT_MESSAGE_APP) {}
+
+    /**
+     * Send our payload into the mesh
+     */
+    void sendPayload(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
+
+    /**
+     * Append range test data to the file on the spiffs
+     */
+    bool appendFile(const MeshPacket &mp);
+
+    /**
+     * Kevin's magical calculation of two points to meters.
+     */
+    float latLongToMeter(double lat_a, double lng_a, double lat_b, double lng_b);
+
+  protected:
+    virtual MeshPacket *allocReply();
+
+    /** 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 handleReceived(const MeshPacket &mp);
+};
+
+extern RangeTestPluginRadio *rangeTestPluginRadio;

src/plugins/esp32/StoreForwardPlugin.cpp

@@ -0,0 +1,297 @@
+#include "StoreForwardPlugin.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "RTC.h"
+#include "Router.h"
+#include "configuration.h"
+#include "mesh-pb-constants.h"
+#include <Arduino.h>
+#include <map>
+
+#define STOREFORWARD_MAX_PACKETS 7500
+#define STOREFORWARD_SEND_HISTORY_SHORT 600
+
+StoreForwardPlugin *storeForwardPlugin;
+StoreForwardPluginRadio *storeForwardPluginRadio;
+
+StoreForwardPlugin::StoreForwardPlugin() : concurrency::OSThread("StoreForwardPlugin") {}
+
+int32_t StoreForwardPlugin::runOnce()
+{
+
+#ifndef NO_ESP32
+
+    /*
+        Uncomment the preferences below if you want to use the plugin
+        without having to configure it from the PythonAPI or WebUI.
+    */
+
+    // radioConfig.preferences.store_forward_plugin_enabled = 1;
+    // radioConfig.preferences.is_router = 1;
+
+    if (radioConfig.preferences.store_forward_plugin_enabled) {
+
+        if (firstTime) {
+
+            /*
+             */
+
+            if (radioConfig.preferences.is_router) {
+                DEBUG_MSG("Initializing Store & Forward Plugin - Enabled\n");
+                // Router
+                if (ESP.getPsramSize()) {
+                    if (ESP.getFreePsram() >= 2048 * 1024) {
+                        // Do the startup here
+                        storeForwardPluginRadio = new StoreForwardPluginRadio();
+
+                        firstTime = 0;
+
+                        this->populatePSRAM();
+
+                        // packetHistory[0].bytes;
+                        return (10 * 1000);
+
+                    } else {
+                        DEBUG_MSG("Device has less than 2M of PSRAM free. Aborting startup.\n");
+                        DEBUG_MSG("Store & Forward Plugin - Aborting Startup.\n");
+
+                        return (INT32_MAX);
+                    }
+
+                } else {
+                    DEBUG_MSG("Device doesn't have PSRAM.\n");
+                    DEBUG_MSG("Store & Forward Plugin - Aborting Startup.\n");
+
+                    return (INT32_MAX);
+                }
+
+            } else {
+                DEBUG_MSG("Initializing Store & Forward Plugin - Enabled but is_router is not turned on.\n");
+                DEBUG_MSG(
+                    "Initializing Store & Forward Plugin - If you want to use this plugin, you must also turn on is_router.\n");
+                // Non-Router
+
+                return (30 * 1000);
+            }
+
+        } else {
+            // What do we do if it's not our first time?
+
+            // Maybe some cleanup functions?
+            this->sawNodeReport();
+            this->historyReport();
+            return (10 * 1000);
+        }
+
+    } else {
+        DEBUG_MSG("Store & Forward Plugin - Disabled\n");
+
+        return (INT32_MAX);
+    }
+
+#endif
+    return (INT32_MAX);
+}
+
+void StoreForwardPlugin::populatePSRAM()
+{
+    /*
+    For PSRAM usage, see:
+        https://learn.upesy.com/en/programmation/psram.html#psram-tab
+    */
+
+    DEBUG_MSG("Before PSRAM initilization\n");
+
+    DEBUG_MSG("Total heap: %d\n", ESP.getHeapSize());
+    DEBUG_MSG("Free heap: %d\n", ESP.getFreeHeap());
+    DEBUG_MSG("Total PSRAM: %d\n", ESP.getPsramSize());
+    DEBUG_MSG("Free PSRAM: %d\n", ESP.getFreePsram());
+
+    // PacketHistoryStruct *packetHistory = (PacketHistoryStruct *)ps_calloc(STOREFORWARD_MAX_PACKETS,
+    // sizeof(PacketHistoryStruct));
+    this->packetHistory = (PacketHistoryStruct *)ps_calloc(STOREFORWARD_MAX_PACKETS, sizeof(PacketHistoryStruct));
+    DEBUG_MSG("After PSRAM initilization\n");
+
+    DEBUG_MSG("Total heap: %d\n", ESP.getHeapSize());
+    DEBUG_MSG("Free heap: %d\n", ESP.getFreeHeap());
+    DEBUG_MSG("Total PSRAM: %d\n", ESP.getPsramSize());
+    DEBUG_MSG("Free PSRAM: %d\n", ESP.getFreePsram());
+
+    DEBUG_MSG("packetHistory Size - %u", sizeof(packetHistory));
+}
+
+// We saw a node.
+uint32_t StoreForwardPlugin::sawNode(uint32_t node)
+{
+
+    /*
+    TODO: Move receivedRecord into the PSRAM
+
+    TODO: Gracefully handle the case where we run out of records.
+            Maybe replace the oldest record that hasn't been seen in a while and assume they won't be back.
+
+    TODO: Implment this as a std::map for quicker lookups (maybe it doesn't matter?).
+    */
+    // DEBUG_MSG("%s (id=0x%08x Fr0x%02x To0x%02x, WantAck%d, HopLim%d", prefix, p->id, p->from & 0xff, p->to & 0xff,
+    // p->want_ack, p->hop_limit);
+    DEBUG_MSG("looking for node - from-0x%08x\n", node);
+    for (int i = 0; i < 50; i++) {
+        // DEBUG_MSG("Iterating through the seen nodes - %u %u %u\n", i, receivedRecord[i][0], receivedRecord[i][1]);
+        // First time seeing that node.
+        if (receivedRecord[i][0] == 0) {
+            // DEBUG_MSG("New node! Woohoo! Win!\n");
+            receivedRecord[i][0] = node;
+            receivedRecord[i][1] = millis();
+
+            return receivedRecord[i][1];
+        }
+
+        // We've seen this node before.
+        if (receivedRecord[i][0] == node) {
+            // DEBUG_MSG("We've seen this node before\n");
+            uint32_t lastSaw = receivedRecord[i][1];
+            receivedRecord[i][1] = millis();
+            return lastSaw;
+        }
+    }
+
+    return 0;
+}
+
+void StoreForwardPlugin::historyReport()
+{
+    DEBUG_MSG("Iterating through the message history...\n");
+    DEBUG_MSG("Message history contains %u records\n", this->packetHistoryCurrent);
+    uint32_t startTimer = millis();
+    for (int i = 0; i < this->packetHistoryCurrent; i++) {
+        if (this->packetHistory[i].time) {
+            // DEBUG_MSG("... time-%u to-0x%08x\n", this->packetHistory[i].time, this->packetHistory[i].to & 0xffffffff);
+        }
+    }
+    DEBUG_MSG("StoreForwardPlugin::historyReport runtime - %u ms\n", millis() - startTimer);
+}
+void StoreForwardPlugin::historySend(uint32_t msAgo, uint32_t to)
+{
+    for (int i = 0; i < this->packetHistoryCurrent; i++) {
+        if (this->packetHistory[i].time) {
+            // DEBUG_MSG("... time-%u to-0x%08x\n", this->packetHistory[i].time, this->packetHistory[i].to & 0xffffffff);
+        }
+    }
+}
+
+void StoreForwardPlugin::historyAdd(const MeshPacket *mp)
+{
+    auto &p = mp;
+
+    static uint8_t bytes[MAX_RHPACKETLEN];
+    size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), SubPacket_fields, &p->decoded);
+    assert(numbytes <= MAX_RHPACKETLEN);
+
+    DEBUG_MSG("MP numbytes %u\n", numbytes);
+
+    // destination, source, bytes
+    // memcpy(p->encrypted.bytes, bytes, numbytes);
+    memcpy(this->packetHistory[this->packetHistoryCurrent].bytes, bytes, MAX_RHPACKETLEN);
+    this->packetHistory[this->packetHistoryCurrent].time = millis();
+    this->packetHistory[this->packetHistoryCurrent].to = mp->to;
+    this->packetHistoryCurrent++;
+}
+
+// We saw a node.
+void StoreForwardPlugin::sawNodeReport()
+{
+
+    /*
+    TODO: Move receivedRecord into the PSRAM
+
+    TODO: Gracefully handle the case where we run out of records.
+            Maybe replace the oldest record that hasn't been seen in a while and assume they won't be back.
+
+    TODO: Implment this as a std::map for quicker lookups (maybe it doesn't matter?).
+    */
+
+    DEBUG_MSG("Iterating through the seen nodes in receivedRecord...\n");
+    for (int i = 0; i < 50; i++) {
+        if (receivedRecord[i][1]) {
+            DEBUG_MSG("... record-%u from-0x%08x secAgo-%u\n", i, receivedRecord[i][0], (millis() - receivedRecord[i][1]) / 1000);
+        }
+    }
+}
+
+MeshPacket *StoreForwardPluginRadio::allocReply()
+{
+
+    auto reply = allocDataPacket(); // Allocate a packet for sending
+
+    return reply;
+}
+
+void StoreForwardPluginRadio::sendPayload(NodeNum dest, bool wantReplies)
+{
+    MeshPacket *p = allocReply();
+    p->to = dest;
+    p->decoded.want_response = wantReplies;
+
+    service.sendToMesh(p);
+}
+
+bool StoreForwardPluginRadio::handleReceived(const MeshPacket &mp)
+{
+#ifndef NO_ESP32
+    if (radioConfig.preferences.store_forward_plugin_enabled) {
+
+        if (mp.from != nodeDB.getNodeNum()) {
+            // DEBUG_MSG("Store & Forward Plugin -- Print Start ---------- ---------- ---------- ---------- ----------\n\n\n");
+            // DEBUG_MSG("%s (id=0x%08x Fr0x%02x To0x%02x, WantAck%d, HopLim%d", prefix, p->id, p->from & 0xff, p->to & 0xff,
+            // p->want_ack, p->hop_limit);
+            printPacket("----- PACKET FROM RADIO -----", &mp);
+            uint32_t sawTime = storeForwardPlugin->sawNode(mp.from & 0xffffffff);
+            DEBUG_MSG("We last saw this node (%u), %u sec ago\n", mp.from & 0xffffffff, (millis() - sawTime) / 1000);
+
+            if (mp.decoded.data.portnum == PortNum_UNKNOWN_APP) {
+                DEBUG_MSG("Packet came from - PortNum_UNKNOWN_APP\n");
+            } else if (mp.decoded.data.portnum == PortNum_TEXT_MESSAGE_APP) {
+                DEBUG_MSG("Packet came from - PortNum_TEXT_MESSAGE_APP\n");
+
+                storeForwardPlugin->historyAdd(&mp);
+
+            } else if (mp.decoded.data.portnum == PortNum_REMOTE_HARDWARE_APP) {
+                DEBUG_MSG("Packet came from - PortNum_REMOTE_HARDWARE_APP\n");
+            } else if (mp.decoded.data.portnum == PortNum_POSITION_APP) {
+                DEBUG_MSG("Packet came from - PortNum_POSITION_APP\n");
+            } else if (mp.decoded.data.portnum == PortNum_NODEINFO_APP) {
+                DEBUG_MSG("Packet came from - PortNum_NODEINFO_APP\n");
+            } else if (mp.decoded.data.portnum == PortNum_REPLY_APP) {
+                DEBUG_MSG("Packet came from - PortNum_REPLY_APP\n");
+            } else if (mp.decoded.data.portnum == PortNum_IP_TUNNEL_APP) {
+                DEBUG_MSG("Packet came from - PortNum_IP_TUNNEL_APP\n");
+            } else if (mp.decoded.data.portnum == PortNum_SERIAL_APP) {
+                DEBUG_MSG("Packet came from - PortNum_SERIAL_APP\n");
+            } else if (mp.decoded.data.portnum == PortNum_STORE_FORWARD_APP) {
+                DEBUG_MSG("Packet came from - PortNum_STORE_FORWARD_APP\n");
+            } else if (mp.decoded.data.portnum == PortNum_RANGE_TEST_APP) {
+                DEBUG_MSG("Packet came from - PortNum_RANGE_TEST_APP\n");
+            } else if (mp.decoded.data.portnum == PortNum_PRIVATE_APP) {
+                DEBUG_MSG("Packet came from - PortNum_PRIVATE_APP\n");
+            } else if (mp.decoded.data.portnum == PortNum_RANGE_TEST_APP) {
+                DEBUG_MSG("Packet came from - PortNum_RANGE_TEST_APP\n");
+            } else if (mp.decoded.data.portnum == PortNum_ATAK_FORWARDER) {
+                DEBUG_MSG("Packet came from - PortNum_ATAK_FORWARDER\n");
+            } else {
+                DEBUG_MSG("Packet came from an unknown port %u\n", mp.decoded.data.portnum);
+            }
+
+            if ((millis() - sawTime) > STOREFORWARD_SEND_HISTORY_SHORT) {
+                // Node has been away for a while. 
+                storeForwardPlugin->historySend(sawTime, mp.from);
+            }
+        }
+
+    } else {
+        DEBUG_MSG("Store & Forward Plugin - Disabled\n");
+    }
+
+#endif
+
+    return true; // Let others look at this message also if they want
+}

src/plugins/esp32/StoreForwardPlugin.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include "SinglePortPlugin.h"
+#include "concurrency/OSThread.h"
+#include "configuration.h"
+#include <Arduino.h>
+#include <functional>
+
+
+struct PacketHistoryStruct {
+    uint32_t time;
+    uint32_t to;
+    bool ack;
+    uint8_t bytes[MAX_RHPACKETLEN];
+};
+
+class StoreForwardPlugin : private concurrency::OSThread
+{
+    bool firstTime = 1;
+
+    uint32_t receivedRecord[50][2] = {{0}};
+
+    PacketHistoryStruct *packetHistory;
+    uint32_t packetHistoryCurrent = 0;
+
+  public:
+    StoreForwardPlugin();
+
+    /**
+     Update our local reference of when we last saw that node.
+     @return 0 if we have never seen that node before otherwise return the last time we saw the node.
+     */
+    uint32_t sawNode(uint32_t);
+    void sawNodeReport();
+    void historyAdd(const MeshPacket *mp);
+    void historyReport();
+    void historySend(uint32_t msAgo, uint32_t to);
+    void populatePSRAM();
+
+  private:
+    // Nothing here
+
+  protected:
+    virtual int32_t runOnce();
+};
+
+extern StoreForwardPlugin *storeForwardPlugin;
+
+/*
+ * Radio interface for StoreForwardPlugin
+ *
+ */
+class StoreForwardPluginRadio : public SinglePortPlugin
+{
+    // uint32_t lastRxID;
+
+  public:
+    StoreForwardPluginRadio() : SinglePortPlugin("StoreForwardPluginRadio", PortNum_STORE_FORWARD_APP) {}
+    // StoreForwardPluginRadio() : SinglePortPlugin("StoreForwardPluginRadio", PortNum_TEXT_MESSAGE_APP) {}
+
+    /**
+     * Send our payload into the mesh
+     */
+    void sendPayload(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
+
+  protected:
+    virtual MeshPacket *allocReply();
+
+    virtual bool wantPortnum(PortNum p) { return true; };
+
+    /** 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 handleReceived(const MeshPacket &mp);
+};
+
+extern StoreForwardPluginRadio *storeForwardPluginRadio;

version.properties

@@ -1,4 +1,4 @@
 [VERSION]  
 major = 1  
 minor = 1
-build = 46
+build = 50