Merge pull request #730 from geeksville/dev1.2

1.2.4

.github/workflows/main.yml

@@ -4,8 +4,7 @@ on:
   - pull_request
 
 jobs:
-  main:
-    name: Main
+  setup:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@master
@@ -32,5 +31,4 @@ jobs:
       - name: Build for lora-relay-v1
         run: platformio run -e lora-relay-v1 
       - name: Build for linux
-        run: platformio run -e linux
-        
+        run: platformio run -e linux

.vscode/settings.json

@@ -68,5 +68,13 @@
         "protobufs",
         "wifi"
     ],
-    "C_Cpp.dimInactiveRegions": true
+    "C_Cpp.dimInactiveRegions": true,
+    "protoc": {
+        "compile_on_save": false,
+        "compile_all_path": "/home/kevinh/development/meshtastic/meshtastic-esp32/proto",
+        "options": [
+            "--java_out=/tmp",
+            "-I=/home/kevinh/development/meshtastic/meshtastic-esp32/proto"
+        ]
+    }    
 }

bin/build-all.sh

@@ -4,7 +4,9 @@ set -e
 
 VERSION=`bin/buildinfo.py`
 
-COUNTRIES="US EU433 EU865 CN JP ANZ KR"
+# We now only do regionless builds
+COUNTRIES=""
+#COUNTRIES="US EU433 EU865 CN JP ANZ KR"
 #COUNTRIES=US
 #COUNTRIES=CN
 
@@ -21,7 +23,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
 
@@ -92,7 +94,7 @@ pio run --environment tbeam -t buildfs
 cp .pio/build/tbeam/spiffs.bin $OUTDIR/bins/universal/spiffs-$VERSION.bin
 
 # keep the bins in archive also
-cp $OUTDIR/bins/firmware* $OUTDIR/bins/universal/spiffs* $OUTDIR/elfs/firmware* $OUTDIR/bins/universal/firmware* $OUTDIR/elfs/universal/firmware* $ARCHIVEDIR
+cp $OUTDIR/bins/universal/spiffs* $OUTDIR/bins/universal/firmware* $OUTDIR/elfs/universal/firmware* $ARCHIVEDIR
 
 echo Updating android bins $OUTDIR/forandroid
 rm -rf $OUTDIR/forandroid
@@ -107,12 +109,12 @@ release.  It is used by the android app for forcing software updates.  Do not ed
 Generated by bin/buildall.sh -->
 
 <resources>
-    <string name="cur_firmware_version">$VERSION</string>
+    <string name="cur_firmware_version" translatable="false">$VERSION</string>
 </resources>
 XML
 
 echo Generating $ARCHIVEDIR/firmware-$VERSION.zip
 rm -f $ARCHIVEDIR/firmware-$VERSION.zip
-zip --junk-paths $ARCHIVEDIR/firmware-$VERSION.zip $ARCHIVEDIR/spiffs-$VERSION.bin $OUTDIR/bins/firmware-*-$VERSION.* images/system-info.bin bin/device-install.sh bin/device-update.sh
+zip --junk-paths $ARCHIVEDIR/firmware-$VERSION.zip $ARCHIVEDIR/spiffs-$VERSION.bin $OUTDIR/bins/universal/firmware-*-$VERSION.* images/system-info.bin bin/device-install.sh bin/device-update.sh
 
 echo BUILT ALL

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))
 

bin/program-release-tbeam.sh

@@ -2,5 +2,7 @@
 set -e
 
 VERSION=`bin/buildinfo.py`
+FILENAME=release/latest/bins/universal/firmware-tbeam-$VERSION.bin
 
-esptool.py --baud 921600 write_flash 0x10000 release/latest/bins/firmware-tbeam-US-$VERSION.bin
+echo Installing $FILENAME
+esptool.py --baud 921600 write_flash 0x10000 $FILENAME

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/TODO.md

@@ -2,6 +2,85 @@
 
 You probably don't care about this section - skip to the next one.
 
+## 1.2 cleanup & multichannel support:
+
+* DONE call RouterPlugin for *all* packets - not just Router packets
+* DONE generate channel hash from the name of the channel+the psk (not just one or the other)
+* DONE send a hint that can be used to select which channel to try and hash against with each message
+* DONE remove deprecated
+* DONE fix setchannel in phoneapi.cpp
+* DONE set mynodeinfo.max_channels
+* DONE set mynodeinfo.num_bands (formerly num_channels)
+* DONE fix sniffing of non Routing packets
+* DONE enable remote setttings access by moving settings operations into a regular plugin (move settings ops out of PhoneAPI)
+* DONE move portnum up?
+* DONE remove region specific builds from the firmware
+* DONE test single channel without python
+* DONE Use "default" for name if name is empty
+* DONE fix python data packet receiving (nothing showing in log?)
+* DONE implement 'get channels' Admin plugin operation
+* DONE use get-channels from python
+* DONE use get channels & get settings from android
+* DONE use set-channel from python
+* DONE make settings changes from python work
+* DONE pthon should stop fetching channels once we've reached our first empty channel definition (hasSettings == true)
+* DONE add check for old devices with new API library
+* DONE release python api
+* DONE release protobufs
+* DONE release to developers
+* DONE fix setch-fast in python tool
+* age out pendingrequests in the python API
+* DONE stress test channel download from python, sometimes it seems like we don't get all replies, bug was due to simultaneous android connection
+* DONE combine acks and responses in a single message if possible (do routing plugin LAST and drop ACK if someone else has already replied)
+* DONE don't send packets we received from the phone BACK TOWARDS THE PHONE (possibly use fromnode 0 for packets the phone sends?)
+* fix 1.1.50 android debug panel display
+* test android channel setting
+* release to users
+* DONE warn in android app about unset regions
+* DONE use set-channel from android
+* DONE add gui in android app for setting region
+* make python tests more exhaustive
+* pick default random admin key
+* exclude admin channels from URL?
+* make a way to share just secondary channels via URL
+* use single byte 'well known' channel names for the four default channel names (longslow etc), and for admin, gpio, etc...
+* use presence of gpio channel to enable gpio ops, same for serial etc...
+* restrict gpio & serial & settings operations to the admin channel (unless local to the current node)
+* add channel restrictions for plugins (and restrict routing plugin to the "control" channel)
+* stress test multi channel
+* investigate @mc-hamster report of heap corruption
+* DONE use set-user from android
+* use portuino TCP connection to debug with python API
+* document the relationship between want_response (indicating remote node received it) and want_ack (indicating that this message should be sent reliably - and also get acks from the first rx node and naks if it is never delivered)
+* DONE android should stop fetching channels once we've reached our first empty channel definition (hasSettings == true)
+* DONE warn in python api if we are too new to talk to the device code
+* DONE make a post warning about 1.2, telling how to stay on old android & python clients.  link to this from the android dialog message and python version warning.
+* DONE "FIXME - move the radioconfig/user/channel READ operations into SettingsMessage as well"
+* DONE scrub protobufs to make sure they are absoloute minimum wiresize (in particular Data, ChannelSets and positions)
+* DONE change syncword (now ox2b)
+* allow chaning packets in single transmission - to increase airtime efficiency and amortize packet overhead
+* DONE move most parts of meshpacket into the Data packet, so that we can chain multiple Data for sending when they all have a common destination and key.
+* when selecting a MeshPacket for transmit, scan the TX queue for any Data packets we can merge together as a WirePayload.  In the low level send/rx code expand that into multiple MeshPackets as needed (thus 'hiding' from MeshPacket that over the wire we send multiple datapackets
+* confirm we are still calling the plugins for messages inbound from the phone (or generated locally)
+* confirm we are still multi hop routing flood broadcasts
+* confirm we are still doing resends on unicast reliable packets
+* add history to routed packets: https://meshtastic.discourse.group/t/packet-source-tracking/2764/2
+* add support for full DSR unicast delivery
+* DONE move acks into routing
+* DONE make all subpackets different versions of data
+* DONE move routing control into a data packet
+* have phoneapi done via plugin (will allow multiple simultaneous API clients - stop disabling BLE while using phone API)
+* DONE figure out how to add micro_delta to position, make it so that phone apps don't need to understand it?
+* only send battery updates a max of once a minute
+* add python channel selection for sending
+* DONE record recevied channel in meshpacket
+* test remote settings operations (confirm it works 3 hops away)
+* DONE make a primaryChannel global and properly maintain it when the phone sends setChannel
+* DONE move setCrypto call into packet send and packet decode code
+* implement 'small location diffs' change
+* move battery level out of position? 
+* DOUBLE CHECK android app can still upgrade 1.1 and 1.0 loads
+ 
 eink:
 
 * new battery level sensing

docs/software/android-too-old.md

@@ -0,0 +1,13 @@
+# Your android application needs updating
+
+Hi.
+
+If you've landed here that means your android application is too old for the running device firmware.  Usually our updates are backwards compatible, but in this special circumstance it is not.  Sorry.
+
+Probably, what this means is that you installed the **alpha test** version of the firmware from github.  We really love people helping with development by running the alpha test binaries.  But if you aren't ready to sign up for that right now, please go back to [github](https://github.com/meshtastic/Meshtastic-device/releases) and install the latest **not alpha** 1.1.x firmware.
+
+If you **do** intend to run the alpha test please [opt-in](https://play.google.com/apps/testing/com.geeksville.mesh) to receive the alpha test version of the android application.
+
+If you are willing to be an alpha tester, please keep an eye on our forum where we post frequent release notes.  We also will actively help you with any bugs you might encounter (along our shared journey of new feature goodness).
+
+If you have problems/questions please post in our [forum](https://meshtastic.discourse.group) and some nice person will probably help.

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

@@ -15,6 +15,7 @@ default_envs = tbeam
 ;default_envs = tlora-v1
 ;default_envs = tlora-v2
 ;default_envs = lora-relay-v1 # nrf board
+;default_envs = eink
 ;default_envs = linux # lora-relay-v1 # nrf52840dk-geeksville # linux # or if you'd like to change the default to something like lora-relay-v1 put that here
 
 [common]
@@ -33,7 +34,9 @@ extra_scripts = bin/platformio-custom.py
 
 ; note: we add src to our include search path so that lmic_project_config can override
 ; FIXME: fix lib/BluetoothOTA dependency back on src/ so we can remove -Isrc
-build_flags = -Wno-missing-field-initializers -Isrc -Isrc/mesh -Isrc/gps -Ilib/nanopb/include -Wl,-Map,.pio/build/output.map 
+build_flags = -Wno-missing-field-initializers
+  -Wno-format 
+  -Isrc -Isrc/mesh -Isrc/gps -Ilib/nanopb/include -Wl,-Map,.pio/build/output.map 
   -DHW_VERSION_${sysenv.COUNTRY}
   -DHW_VERSION=${sysenv.HW_VERSION}
   -DUSE_THREAD_NAMES
@@ -65,7 +68,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 +78,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 +107,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 +193,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 +334,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 +347,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/esp32/ESP32CryptoEngine.cpp

@@ -18,9 +18,6 @@ class ESP32CryptoEngine : public CryptoEngine
 
     mbedtls_aes_context aes;
 
-    /// How many bytes in our key
-    uint8_t keySize = 0;
-
   public:
     ESP32CryptoEngine() { mbedtls_aes_init(&aes); }
 
@@ -35,12 +32,12 @@ class ESP32CryptoEngine : public CryptoEngine
      * @param bytes a _static_ buffer that will remain valid for the life of this crypto instance (i.e. this class will cache the
      * provided pointer)
      */
-    virtual void setKey(size_t numBytes, uint8_t *bytes)
+    virtual void setKey(const CryptoKey &k)
     {
-        keySize = numBytes;
-        DEBUG_MSG("Installing AES%d key!\n", numBytes * 8);
-        if (numBytes != 0) {
-            auto res = mbedtls_aes_setkey_enc(&aes, bytes, numBytes * 8);
+        CryptoEngine::setKey(k);
+
+        if (key.length != 0) {
+            auto res = mbedtls_aes_setkey_enc(&aes, key.bytes, key.length * 8);
             assert(!res);
         }
     }
@@ -52,7 +49,7 @@ class ESP32CryptoEngine : public CryptoEngine
      */
     virtual void encrypt(uint32_t fromNode, uint64_t packetNum, size_t numBytes, uint8_t *bytes)
     {
-        if (keySize != 0) {
+        if (key.length > 0) {
             uint8_t stream_block[16];
             static uint8_t scratch[MAX_BLOCKSIZE];
             size_t nc_off = 0;

src/graphics/Screen.cpp

@@ -32,6 +32,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "main.h"
 #include "mesh-pb-constants.h"
 #include "plugins/TextMessagePlugin.h"
+#include "mesh/Channels.h"
 #include "target_specific.h"
 #include "utils.h"
 
@@ -64,6 +65,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 +149,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 +193,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)
 {
@@ -186,7 +229,7 @@ static void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state
     displayedNodeNum = 0; // Not currently showing a node pane
 
     MeshPacket &mp = devicestate.rx_text_message;
-    NodeInfo *node = nodeDB.getNode(mp.from);
+    NodeInfo *node = nodeDB.getNode(getFrom(&mp));
     // DEBUG_MSG("drawing text message from 0x%x: %s\n", mp.from,
     // mp.decoded.variant.data.decoded.bytes);
 
@@ -201,8 +244,7 @@ static void drawTextMessageFrame(OLEDDisplay *display, OLEDDisplayUiState *state
 
     // the max length of this buffer is much longer than we can possibly print
     static char tempBuf[96];
-    assert(mp.decoded.which_payloadVariant == SubPacket_data_tag);
-    snprintf(tempBuf, sizeof(tempBuf), "         %s", mp.decoded.data.payload.bytes);
+    snprintf(tempBuf, sizeof(tempBuf), "         %s", mp.decoded.payload.bytes);
 
     display->drawStringMaxWidth(4 + x, 10 + y, SCREEN_WIDTH - (6 + x), tempBuf);
 }
@@ -776,9 +818,6 @@ int32_t Screen::runOnce()
         showingBootScreen = false;
     }
 
-    // Update the screen last, after we've figured out what to show.
-    debug_info()->setChannelNameStatus(getChannelName());
-
     // Process incoming commands.
     for (;;) {
         ScreenCmd cmd;
@@ -798,6 +837,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 +912,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 +924,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 +964,8 @@ void Screen::setFrames()
     }
 #endif
 
+    DEBUG_MSG("Finished building frames. numframes: %d\n", numframes);
+
     ui.setFrames(normalFrames, numframes);
     ui.enableAllIndicators();
 
@@ -928,6 +989,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();
@@ -993,7 +1066,8 @@ void DebugInfo::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16
     char channelStr[20];
     {
         concurrency::LockGuard guard(&lock);
-        snprintf(channelStr, sizeof(channelStr), "%s", channelName.c_str());
+        auto chName = channels.getPrimaryName();
+        snprintf(channelStr, sizeof(channelStr), "%s", chName);
     }
 
     // Display power status
@@ -1200,8 +1274,8 @@ void DebugInfo::drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *stat
         display->drawString(x, y, String("USB"));
     }
 
-    display->drawString(x + SCREEN_WIDTH - display->getStringWidth("Mode " + String(channelSettings.modem_config)), y,
-                        "Mode " + String(channelSettings.modem_config));
+    auto mode = "Mode " + String(channels.getPrimary().modem_config);
+    display->drawString(x + SCREEN_WIDTH - display->getStringWidth(mode), y, mode);
 
     // Line 2
     uint32_t currentMillis = millis();

src/graphics/Screen.h

@@ -39,13 +39,6 @@ class DebugInfo
     DebugInfo(const DebugInfo &) = delete;
     DebugInfo &operator=(const DebugInfo &) = delete;
 
-    /// Sets the name of the channel.
-    void setChannelNameStatus(const char *name)
-    {
-        concurrency::LockGuard guard(&lock);
-        channelName = name;
-    }
-
   private:
     friend Screen;
 
@@ -56,8 +49,6 @@ class DebugInfo
     void drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
     void drawFrameWiFi(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y);
 
-    std::string channelName;
-
     /// Protects all of internal state.
     concurrency::Lock lock;
 };
@@ -128,6 +119,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 +232,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.
@@ -356,7 +359,7 @@ void setup()
 #endif
 
     // Hello
-    DEBUG_MSG("Meshtastic swver=%s, hwver=%s\n", optstr(APP_VERSION), optstr(HW_VERSION));
+    DEBUG_MSG("Meshtastic hwvendor=%s, swver=%s, hwver=%s\n", HW_VENDOR, optstr(APP_VERSION), optstr(HW_VERSION));
 
 #ifndef NO_ESP32
     // Don't init display if we don't have one or we are waking headless due to a timer event

src/mesh/Channels.cpp

@@ -0,0 +1,296 @@
+#include "Channels.h"
+#include "CryptoEngine.h"
+#include "NodeDB.h"
+
+#include <assert.h>
+
+/// 16 bytes of random PSK for our _public_ default channel that all devices power up on (AES128)
+static const uint8_t defaultpsk[] = {0xd4, 0xf1, 0xbb, 0x3a, 0x20, 0x29, 0x07, 0x59,
+                                     0xf0, 0xbc, 0xff, 0xab, 0xcf, 0x4e, 0x69, 0xbf};
+
+Channels channels;
+
+uint8_t xorHash(const uint8_t *p, size_t len)
+{
+    uint8_t code = 0;
+    for (int i = 0; i < len; i++)
+        code ^= p[i];
+    return code;
+}
+
+/** Given a channel number, return the (0 to 255) hash for that channel.
+ * The hash is just an xor of the channel name followed by the channel PSK being used for encryption
+ * If no suitable channel could be found, return -1
+ */
+int16_t Channels::generateHash(ChannelIndex channelNum)
+{
+    auto k = getKey(channelNum);
+    if (k.length < 0)
+        return -1; // invalid
+    else {
+        const char *name = getName(channelNum);
+        uint8_t h = xorHash((const uint8_t *) name, strlen(name));
+
+        h ^= xorHash(k.bytes, k.length);
+
+        return h;
+    }
+}
+
+/**
+ * Validate a channel, fixing any errors as needed
+ */
+Channel &Channels::fixupChannel(ChannelIndex chIndex)
+{
+    Channel &ch = getByIndex(chIndex);
+
+    ch.index = chIndex; // Preinit the index so it be ready to share with the phone (we'll never change it later)
+
+    if (!ch.has_settings) {
+        // No settings! Must disable and skip
+        ch.role = Channel_Role_DISABLED;
+        memset(&ch.settings, 0, sizeof(ch.settings));
+        ch.has_settings = true;
+    } else {
+        ChannelSettings &channelSettings = ch.settings;
+
+        // Convert the old string "Default" to our new short representation
+        if (strcmp(channelSettings.name, "Default") == 0)
+            *channelSettings.name = '\0';
+
+        /* Convert any old usage of the defaultpsk into our new short representation.
+        if (channelSettings.psk.size == sizeof(defaultpsk) &&
+            memcmp(channelSettings.psk.bytes, defaultpsk, sizeof(defaultpsk)) == 0) {
+            *channelSettings.psk.bytes = 1;
+            channelSettings.psk.size = 1;
+        } */
+    }
+
+    hashes[chIndex] = generateHash(chIndex);
+
+    return ch;
+}
+
+/**
+ * Write a default channel to the specified channel index
+ */
+void Channels::initDefaultChannel(ChannelIndex chIndex)
+{
+    Channel &ch = getByIndex(chIndex);
+    ChannelSettings &channelSettings = ch.settings;
+
+    // radioConfig.modem_config = RadioConfig_ModemConfig_Bw125Cr45Sf128;  // medium range and fast
+    // channelSettings.modem_config = ChannelSettings_ModemConfig_Bw500Cr45Sf128;  // short range and fast, but wide
+    // bandwidth so incompatible radios can talk together
+    channelSettings.modem_config = ChannelSettings_ModemConfig_Bw125Cr48Sf4096; // slow and long range
+
+    channelSettings.tx_power = 0; // default
+    uint8_t defaultpskIndex = 1;
+    channelSettings.psk.bytes[0] = defaultpskIndex;
+    channelSettings.psk.size = 1;
+    strcpy(channelSettings.name, "");
+
+    ch.has_settings = true;
+    ch.role = Channel_Role_PRIMARY;
+}
+
+CryptoKey Channels::getKey(ChannelIndex chIndex)
+{
+    Channel &ch = getByIndex(chIndex);
+    ChannelSettings &channelSettings = ch.settings;
+    assert(ch.has_settings);
+
+    CryptoKey k;
+    memset(k.bytes, 0, sizeof(k.bytes)); // In case the user provided a short key, we want to pad the rest with zeros
+
+    if (ch.role == Channel_Role_DISABLED) {
+        k.length = -1; // invalid
+    } else {
+        memcpy(k.bytes, channelSettings.psk.bytes, channelSettings.psk.size);
+        k.length = channelSettings.psk.size;
+        if (k.length == 0) {
+            if (ch.role == Channel_Role_SECONDARY) {
+                DEBUG_MSG("Unset PSK for secondary channel %s. using primary key\n", ch.settings.name);
+                k = getKey(primaryIndex);
+            } else
+                DEBUG_MSG("Warning: User disabled encryption\n");
+        } else if (k.length == 1) {
+            // Convert the short single byte variants of psk into variant that can be used more generally
+
+            uint8_t pskIndex = k.bytes[0];
+            DEBUG_MSG("Expanding short PSK #%d\n", pskIndex);
+            if (pskIndex == 0)
+                k.length = 0; // Turn off encryption
+            else {
+                memcpy(k.bytes, defaultpsk, sizeof(defaultpsk));
+                k.length = sizeof(defaultpsk);
+                // Bump up the last byte of PSK as needed
+                uint8_t *last = k.bytes + sizeof(defaultpsk) - 1;
+                *last = *last + pskIndex - 1; // index of 1 means no change vs defaultPSK
+            }
+        } else if (k.length < 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");
+            k.length = 16;
+        } else if (k.length < 32 && k.length != 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");
+            k.length = 32;
+        }
+    }
+
+    return k;
+}
+
+/** Given a channel index, change to use the crypto key specified by that index
+ */
+int16_t Channels::setCrypto(ChannelIndex chIndex)
+{
+    CryptoKey k = getKey(chIndex);
+
+    if (k.length < 0)
+        return -1;
+    else {
+        // Tell our crypto engine about the psk
+        crypto->setKey(k);
+        return getHash(chIndex);
+    }
+}
+
+void Channels::initDefaults()
+{
+    devicestate.channels_count = MAX_NUM_CHANNELS;
+    for (int i = 0; i < devicestate.channels_count; i++)
+        fixupChannel(i);
+    initDefaultChannel(0);
+}
+
+void Channels::onConfigChanged()
+{
+    // Make sure the phone hasn't mucked anything up
+    for (int i = 0; i < devicestate.channels_count; i++) {
+        Channel &ch = fixupChannel(i);
+
+        if (ch.role == Channel_Role_PRIMARY)
+            primaryIndex = i;
+    }
+}
+
+Channel &Channels::getByIndex(ChannelIndex chIndex)
+{
+    assert(chIndex < devicestate.channels_count);
+    Channel *ch = devicestate.channels + chIndex;
+    return *ch;
+}
+
+void Channels::setChannel(const Channel &c)
+{
+    Channel &old = getByIndex(c.index);
+
+    // if this is the new primary, demote any existing roles
+    if (c.role == Channel_Role_PRIMARY)
+        for (int i = 0; i < getNumChannels(); i++)
+            if (devicestate.channels[i].role == Channel_Role_PRIMARY)
+                devicestate.channels[i].role = Channel_Role_SECONDARY;
+
+    old = c; // slam in the new settings/role
+}
+
+const char *Channels::getName(size_t chIndex)
+{
+    // Convert the short "" representation for Default into a usable string
+    ChannelSettings &channelSettings = getByIndex(chIndex).settings;
+    const char *channelName = channelSettings.name;
+    if (!*channelName) { // emptystring
+        // Per mesh.proto spec, if bandwidth is specified we must ignore modemConfig enum, we assume that in that case
+        // the app fucked up and forgot to set channelSettings.name
+
+        if (channelSettings.bandwidth != 0)
+            channelName = "Unset";
+        else
+            switch (channelSettings.modem_config) {
+            case ChannelSettings_ModemConfig_Bw125Cr45Sf128:
+                channelName = "Medium";
+                break;
+            case ChannelSettings_ModemConfig_Bw500Cr45Sf128:
+                channelName = "ShortFast";
+                break;
+            case ChannelSettings_ModemConfig_Bw31_25Cr48Sf512:
+                channelName = "LongAlt";
+                break;
+            case ChannelSettings_ModemConfig_Bw125Cr48Sf4096:
+                channelName = "LongSlow";
+                break;
+            default:
+                channelName = "Invalid";
+                break;
+            }
+    }
+
+    return channelName;
+}
+
+/**
+* Generate a short suffix used to disambiguate channels that might have the same "name" entered by the human but different PSKs.
+* The ideas is that the PSK changing should be visible to the user so that they see they probably messed up and that's why they
+their nodes
+* aren't talking to each other.
+*
+* This string is of the form "#name-X".
+*
+* Where X is either:
+* (for custom PSKS) a letter from A to Z (base26), and formed by xoring all the bytes of the PSK together,
+*
+* This function will also need to be implemented in GUI apps that talk to the radio.
+*
+* https://github.com/meshtastic/Meshtastic-device/issues/269
+*/
+const char *Channels::getPrimaryName()
+{
+    static char buf[32];
+
+    char suffix;
+    // auto channelSettings = getPrimary();
+    // if (channelSettings.psk.size != 1) {
+    // We have a standard PSK, so generate a letter based hash.
+    uint8_t code = getHash(primaryIndex);
+
+    suffix = 'A' + (code % 26);
+    /* } else {
+        suffix = '0' + channelSettings.psk.bytes[0];
+    } */
+
+    snprintf(buf, sizeof(buf), "#%s-%c", getName(primaryIndex), suffix);
+    return buf;
+}
+
+/** Given a channel hash setup crypto for decoding that channel (or the primary channel if that channel is unsecured)
+ *
+ * This method is called before decoding inbound packets
+ *
+ * @return false if the channel hash or channel is invalid
+ */
+bool Channels::decryptForHash(ChannelIndex chIndex, ChannelHash channelHash)
+{
+    if(chIndex > getNumChannels() || getHash(chIndex) != channelHash) {
+        DEBUG_MSG("Skipping channel %d due to invalid hash/index\n", chIndex);
+        return false;
+    }
+    else {
+        setCrypto(chIndex);
+        return true;
+    }
+}
+
+/** Given a channel index setup crypto for encoding that channel (or the primary channel if that channel is unsecured)
+ *
+ * This method is called before encoding outbound packets
+ *
+ * @eturn the (0 to 255) hash for that channel - if no suitable channel could be found, return -1
+ */
+int16_t Channels::setActiveByIndex(ChannelIndex channelIndex)
+{
+    return setCrypto(channelIndex);
+}

src/mesh/Channels.h

@@ -0,0 +1,127 @@
+#pragma once
+
+#include "CryptoEngine.h"
+#include "NodeDB.h"
+#include "mesh-pb-constants.h"
+#include <Arduino.h>
+
+/** A channel number (index into the channel table)
+ */
+typedef uint8_t ChannelIndex;
+
+/** A low quality hash of the channel PSK and the channel name.  created by generateHash(chIndex)
+ * Used as a hint to limit which PSKs are considered for packet decoding.
+ */
+typedef uint8_t ChannelHash;
+
+/** The container/on device API for working with channels */
+class Channels
+{
+    /// The index of the primary channel
+    ChannelIndex primaryIndex = 0;
+
+    /** The channel index that was requested for sending/receving.  Note: if this channel is a secondary
+    channel and does not have a PSK, we will use the PSK from the primary channel.  If this channel is disabled
+    no sending or receiving will be allowed */
+    ChannelIndex activeChannelIndex = 0;
+
+    /// the precomputed hashes for each of our channels, or -1 for invalid
+    int16_t hashes[MAX_NUM_CHANNELS];
+
+  public:
+    const ChannelSettings &getPrimary() { return getByIndex(getPrimaryIndex()).settings; }
+
+    /** Return the Channel for a specified index */
+    Channel &getByIndex(ChannelIndex chIndex);
+
+    /** Using the index inside the channel, update the specified channel's settings and role.  If this channel is being promoted
+     * to be primary, force all other channels to be secondary.
+     */
+    void setChannel(const Channel &c);
+
+    const char *getName(size_t chIndex);
+
+    /** The index of the primary channel */
+    ChannelIndex getPrimaryIndex() const { return primaryIndex; }
+
+    ChannelIndex getNumChannels() { return devicestate.channels_count; }
+
+    /**
+     * Generate a short suffix used to disambiguate channels that might have the same "name" entered by the human but different
+    PSKs.
+     * The ideas is that the PSK changing should be visible to the user so that they see they probably messed up and that's why
+    they their nodes
+     * aren't talking to each other.
+     *
+     * This string is of the form "#name-X".
+     *
+     * Where X is either:
+     * (for custom PSKS) a letter from A to Z (base26), and formed by xoring all the bytes of the PSK together,
+     * OR (for the standard minimially secure PSKs) a number from 0 to 9.
+     *
+     * This function will also need to be implemented in GUI apps that talk to the radio.
+     *
+     * https://github.com/meshtastic/Meshtastic-device/issues/269
+    */
+    const char *getPrimaryName();
+
+    /// Called by NodeDB on initial boot when the radio config settings are unset.  Set a default single channel config.
+    void initDefaults();
+
+    /// called when the user has just changed our radio config and we might need to change channel keys
+    void onConfigChanged();
+
+    /** Given a channel hash setup crypto for decoding that channel (or the primary channel if that channel is unsecured)
+     *
+     * This method is called before decoding inbound packets
+     *
+     * @return false if the channel hash or channel is invalid
+     */
+    bool decryptForHash(ChannelIndex chIndex, ChannelHash channelHash);
+
+    /** Given a channel index setup crypto for encoding that channel (or the primary channel if that channel is unsecured)
+     *
+     * This method is called before encoding outbound packets
+     *
+     * @eturn the (0 to 255) hash for that channel - if no suitable channel could be found, return -1
+     */
+    int16_t setActiveByIndex(ChannelIndex channelIndex);
+
+  private:
+    /** Given a channel index, change to use the crypto key specified by that index
+     *
+     * @eturn the (0 to 255) hash for that channel - if no suitable channel could be found, return -1
+     */
+    int16_t setCrypto(ChannelIndex chIndex);
+
+    /** Return the channel index for the specified channel hash, or -1 for not found */
+    int8_t getIndexByHash(ChannelHash channelHash);
+
+    /** Given a channel number, return the (0 to 255) hash for that channel
+     * If no suitable channel could be found, return -1
+     *
+     * called by fixupChannel when a new channel is set
+     */
+    int16_t generateHash(ChannelIndex channelNum);
+
+    int16_t getHash(ChannelIndex i) { return hashes[i]; }
+
+    /**
+     * Validate a channel, fixing any errors as needed
+     */
+    Channel &fixupChannel(ChannelIndex chIndex);
+
+    /**
+     * Write a default channel to the specified channel index
+     */
+    void initDefaultChannel(ChannelIndex chIndex);
+
+    /**
+     * Return the key used for encrypting this channel (if channel is secondary and no key provided, use the primary channel's
+     * PSK)
+     */
+    CryptoKey getKey(ChannelIndex chIndex);
+};
+
+/// Singleton channel table
+extern Channels channels;

src/mesh/CryptoEngine.cpp

@@ -1,9 +1,10 @@
 #include "CryptoEngine.h"
 #include "configuration.h"
 
-void CryptoEngine::setKey(size_t numBytes, uint8_t *bytes)
+void CryptoEngine::setKey(const CryptoKey &k)
 {
-    DEBUG_MSG("WARNING: Using stub crypto - all crypto is sent in plaintext!\n");
+    DEBUG_MSG("Installing AES%d key!\n", k.length * 8);
+    key = k;
 }
 
 /**

src/mesh/CryptoEngine.h

@@ -2,6 +2,13 @@
 
 #include <Arduino.h>
 
+struct CryptoKey {
+    uint8_t bytes[32];
+
+    /// # of bytes, or -1 to mean "invalid key - do not use"
+    int8_t length;
+};
+
 /**
  * see docs/software/crypto.md for details.
  *
@@ -15,6 +22,8 @@ class CryptoEngine
     /** Our per packet nonce */
     uint8_t nonce[16];
 
+    CryptoKey key;
+
   public:
     virtual ~CryptoEngine() {}
 
@@ -27,7 +36,7 @@ class CryptoEngine
      * @param bytes a _static_ buffer that will remain valid for the life of this crypto instance (i.e. this class will cache the
      * provided pointer)
      */
-    virtual void setKey(size_t numBytes, uint8_t *bytes);
+    virtual void setKey(const CryptoKey &k);
 
     /**
      * Encrypt a packet

src/mesh/DSRRouter.cpp

@@ -62,57 +62,59 @@ ErrorCode DSRRouter::send(MeshPacket *p)
         return ReliableRouter::send(p);
 }
 
-void DSRRouter::sniffReceived(const MeshPacket *p)
+void DSRRouter::sniffReceived(const MeshPacket *p, const Routing *c)
 {
     // Learn 0 hop routes by just hearing any adjacent nodes
     // But treat broadcasts carefully, because when flood broadcasts go out they keep the same original "from".  So we want to
     // ignore rebroadcasts.
     // this will also add records for any ACKs we receive for our messages
     if (p->to != NODENUM_BROADCAST || p->hop_limit != HOP_RELIABLE) {
-        addRoute(p->from, p->from, 0); // We are adjacent with zero hops
+        addRoute(getFrom(p), getFrom(p), 0); // We are adjacent with zero hops
     }
 
-    switch (p->decoded.which_payloadVariant) {
-    case SubPacket_route_request_tag:
-        // Handle route discovery packets (will be a broadcast message)
-        // FIXME - always start request with the senders nodenum
-        if (weAreInRoute(p->decoded.route_request)) {
-            DEBUG_MSG("Ignoring a route request that contains us\n");
-        } else {
-            updateRoutes(p->decoded.route_request,
-                         true); // Update our routing tables based on the route that came in so far on this request
-
-            if (p->decoded.dest == getNodeNum()) {
-                // They were looking for us, send back a route reply (the sender address will be first in the list)
-                sendRouteReply(p->decoded.route_request);
+    if (c)
+        switch (c->which_variant) {
+        case Routing_route_request_tag:
+            // Handle route discovery packets (will be a broadcast message)
+            // FIXME - always start request with the senders nodenum
+            if (weAreInRoute(c->route_request)) {
+                DEBUG_MSG("Ignoring a route request that contains us\n");
             } else {
-                // They were looking for someone else, forward it along (as a zero hop broadcast)
-                NodeNum nextHop = getNextHop(p->decoded.dest);
-                if (nextHop) {
-                    // in our route cache, reply to the requester (the sender address will be first in the list)
-                    sendRouteReply(p->decoded.route_request, nextHop);
+                updateRoutes(c->route_request,
+                             true); // Update our routing tables based on the route that came in so far on this request
+
+                if (p->decoded.dest == getNodeNum()) {
+                    // They were looking for us, send back a route reply (the sender address will be first in the list)
+                    sendRouteReply(c->route_request);
                 } else {
-                    // Not in our route cache, rebroadcast on their behalf (after adding ourselves to the request route)
-                    resendRouteRequest(p);
+                    // They were looking for someone else, forward it along (as a zero hop broadcast)
+                    NodeNum nextHop = getNextHop(p->decoded.dest);
+                    if (nextHop) {
+                        // in our route cache, reply to the requester (the sender address will be first in the list)
+                        sendRouteReply(c->route_request, nextHop);
+                    } else {
+                        // Not in our route cache, rebroadcast on their behalf (after adding ourselves to the request route)
+                        resendRouteRequest(p);
+                    }
                 }
             }
+            break;
+        case Routing_route_reply_tag:
+            updateRoutes(c->route_reply, false);
+
+            // FIXME, if any of our current pending packets were waiting for this route, send them (and leave them as regular
+            // pending packets until ack arrives)
+            // FIXME, if we don't get a route reply at all (or a route error), timeout and generate a routeerror TIMEOUT on our
+            // own...
+            break;
+        case Routing_error_reason_tag:
+            removeRoute(p->decoded.dest);
+
+            // FIXME: if any pending packets were waiting on this route, delete them
+            break;
+        default:
+            break;
         }
-        break;
-    case SubPacket_route_reply_tag:
-        updateRoutes(p->decoded.route_reply, false);
-
-        // FIXME, if any of our current pending packets were waiting for this route, send them (and leave them as regular pending
-        // packets until ack arrives)
-        // FIXME, if we don't get a route reply at all (or a route error), timeout and generate a routeerror TIMEOUT on our own...
-        break;
-    case SubPacket_error_reason_tag:
-        removeRoute(p->decoded.dest);
-
-        // FIXME: if any pending packets were waiting on this route, delete them
-        break;
-    default:
-        break;
-    }
 
     // We simply ignore ACKs - because ReliableRouter will delete the pending packet for us
 
@@ -131,26 +133,29 @@ void DSRRouter::sniffReceived(const MeshPacket *p)
                 assert(p->decoded.source); // I think this is guaranteed by now
 
                 // FIXME - what if the current packet _is_ a route error packet?
-                sendRouteError(p, ErrorReason_NO_ROUTE);
+                sendRouteError(p, Routing_Error_NO_ROUTE);
             }
 
             // FIXME, stop local processing of this packet
         }
 
-        // handle naks - convert them to route error packets
-        // All naks are generated locally, because we failed resending the packet too many times
-        PacketId nakId = p->decoded.which_ackVariant == SubPacket_fail_id_tag ? p->decoded.ackVariant.fail_id : 0;
-        if (nakId) {
-            auto pending = findPendingPacket(p->to, nakId);
-            if (pending && pending->packet->decoded.source) { // if source not set, this was not a multihop packet, just ignore
-                removeRoute(pending->packet->decoded.dest);   // We no longer have a route to the specified node
+        if (c) {
+            // handle naks - convert them to route error packets
+            // All naks are generated locally, because we failed resending the packet too many times
+            PacketId nakId = c->error_reason ? p->decoded.request_id : 0;
+            if (nakId) {
+                auto pending = findPendingPacket(p->to, nakId);
+                if (pending &&
+                    pending->packet->decoded.source) {          // if source not set, this was not a multihop packet, just ignore
+                    removeRoute(pending->packet->decoded.dest); // We no longer have a route to the specified node
 
-                sendRouteError(p, ErrorReason_GOT_NAK);
+                    sendRouteError(p, Routing_Error_GOT_NAK);
+                }
             }
         }
     }
 
-    return ReliableRouter::sniffReceived(p);
+    ReliableRouter::sniffReceived(p, c);
 }
 
 /**
@@ -230,7 +235,7 @@ void DSRRouter::sendNextHop(NodeNum n, const MeshPacket *p)
 /**
  * Send a route error packet towards whoever originally sent this message
  */
-void DSRRouter::sendRouteError(const MeshPacket *p, ErrorReason err)
+void DSRRouter::sendRouteError(const MeshPacket *p, Routing_Error err)
 {
     DEBUG_MSG("FIXME not implemented sendRouteError\n");
 }

src/mesh/DSRRouter.h

@@ -8,7 +8,7 @@ class DSRRouter : public ReliableRouter
      * Every (non duplicate) packet this node receives will be passed through this method.  This allows subclasses to
      * update routing tables etc... based on what we overhear (even for messages not destined to our node)
      */
-    virtual void sniffReceived(const MeshPacket *p);
+    virtual void sniffReceived(const MeshPacket *p, const Routing *c);
 
     /**
      * Send a packet on a suitable interface.  This routine will
@@ -70,7 +70,7 @@ class DSRRouter : public ReliableRouter
     /**
      * Send a route error packet towards whoever originally sent this message
      */
-    void sendRouteError(const MeshPacket *p, ErrorReason err);
+    void sendRouteError(const MeshPacket *p, Routing_Error err);
 
     /** make a copy of p, start discovery, but only if we don't
      *  already a discovery in progress for that node number.  Caller has already scheduled this message for retransmission

src/mesh/FloodingRouter.cpp

@@ -27,11 +27,11 @@ bool FloodingRouter::shouldFilterReceived(const MeshPacket *p)
     return Router::shouldFilterReceived(p);
 }
 
-void FloodingRouter::sniffReceived(const MeshPacket *p)
+void FloodingRouter::sniffReceived(const MeshPacket *p, const Routing *c)
 {
     // If a broadcast, possibly _also_ send copies out into the mesh.
     // (FIXME, do something smarter than naive flooding here)
-    if (p->to == NODENUM_BROADCAST && p->hop_limit > 0) {
+    if (p->to == NODENUM_BROADCAST && p->hop_limit > 0 && getFrom(p) != getNodeNum()) {
         if (p->id != 0) {
             MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
 
@@ -48,5 +48,5 @@ void FloodingRouter::sniffReceived(const MeshPacket *p)
     }
 
     // handle the packet as normal
-    Router::sniffReceived(p);
+    Router::sniffReceived(p, c);
 }

src/mesh/FloodingRouter.h

@@ -55,5 +55,5 @@ class FloodingRouter : public Router, protected PacketHistory
     /**
      * Look for broadcasts we need to rebroadcast
      */
-    virtual void sniffReceived(const MeshPacket *p);
+    virtual void sniffReceived(const MeshPacket *p, const Routing *c);
 };

src/mesh/MeshPacketQueue.cpp

@@ -33,7 +33,7 @@ void fixPriority(MeshPacket *p)
     if (p->priority == MeshPacket_Priority_UNSET) {
         // if acks give high priority
         // if a reliable message give a bit higher default priority
-        p->priority = p->decoded.which_ackVariant ? MeshPacket_Priority_ACK :                
+        p->priority = (p->decoded.portnum == PortNum_ROUTING_APP) ? MeshPacket_Priority_ACK :                
                           (p->want_ack ? MeshPacket_Priority_RELIABLE : MeshPacket_Priority_DEFAULT);
     }
 }
@@ -71,7 +71,7 @@ static PacketId findId;
 
 static bool isMyPacket(MeshPacket *p)
 {
-    return p->id == findId && p->from == findFrom;
+    return p->id == findId && getFrom(p) == findFrom;
 }
 
 /** Attempt to find and remove a packet from this queue.  Returns true the packet which was removed from the queue */

src/mesh/MeshPlugin.cpp

@@ -1,23 +1,28 @@
 #include "MeshPlugin.h"
-#include "NodeDB.h"
 #include "MeshService.h"
+#include "NodeDB.h"
 #include <assert.h>
 
 std::vector<MeshPlugin *> *MeshPlugin::plugins;
 
 const MeshPacket *MeshPlugin::currentRequest;
 
+/**
+ * If any of the current chain of plugins has already sent a reply, it will be here.  This is useful to allow
+ * the RoutingPlugin to avoid sending redundant acks
+ */
+ MeshPacket *MeshPlugin::currentReply;
+
 MeshPlugin::MeshPlugin(const char *_name) : name(_name)
 {
     // Can't trust static initalizer order, so we check each time
-    if(!plugins)
+    if (!plugins)
         plugins = new std::vector<MeshPlugin *>();
 
     plugins->push_back(this);
 }
 
-void MeshPlugin::setup() {
-}
+void MeshPlugin::setup() {}
 
 MeshPlugin::~MeshPlugin()
 {
@@ -28,51 +33,100 @@ void MeshPlugin::callPlugins(const MeshPacket &mp)
 {
     // DEBUG_MSG("In call plugins\n");
     bool pluginFound = false;
+
+    assert(mp.which_payloadVariant == MeshPacket_decoded_tag); // I think we are guarnteed the packet is decoded by this point?
+
+    currentReply = NULL; // No reply yet
+
+    // Was this message directed to us specifically?  Will be false if we are sniffing someone elses packets
+    auto ourNodeNum = nodeDB.getNodeNum();
+    bool toUs = mp.to == NODENUM_BROADCAST || mp.to == ourNodeNum;
     for (auto i = plugins->begin(); i != plugins->end(); ++i) {
         auto &pi = **i;
 
         pi.currentRequest = &mp;
-        if (pi.wantPortnum(mp.decoded.data.portnum)) {
+
+        // We only call plugins that are interested in the packet (and the message is destined to us or we are promiscious)
+        bool wantsPacket = (pi.isPromiscuous || toUs) && pi.wantPacket(&mp);
+        // DEBUG_MSG("Plugin %s wantsPacket=%d\n", pi.name, wantsPacket);
+        if (wantsPacket) {
             pluginFound = true;
 
             bool handled = pi.handleReceived(mp);
 
-            // Possibly send replies
-            if (mp.decoded.want_response)
-                pi.sendResponse(mp);
+            // Possibly send replies (but only if the message was directed to us specifically, i.e. not for promiscious sniffing)
+            // also: we only let the one plugin send a reply, once that happens, remaining plugins are not considered
 
-            DEBUG_MSG("Plugin %s handled=%d\n", pi.name, handled);
-            if (handled)
+            // NOTE: we send a reply *even if the (non broadcast) request was from us* which is unfortunate but necessary because
+            // currently when the phone sends things, it sends things using the local node ID as the from address.  A better
+            // solution (FIXME) would be to let phones have their own distinct addresses and we 'route' to them like any other
+            // node.
+            if (mp.decoded.want_response && toUs && (getFrom(&mp) != ourNodeNum || mp.to == ourNodeNum) && !currentReply) {
+                pi.sendResponse(mp);
+                DEBUG_MSG("Plugin %s sent a response\n", pi.name);
+            } else {
+                DEBUG_MSG("Plugin %s considered\n", pi.name);
+            }
+            if (handled) {
+                DEBUG_MSG("Plugin %s handled and skipped other processing\n", pi.name);
                 break;
+            }
         }
-       
+
         pi.currentRequest = NULL;
     }
 
-    if(!pluginFound)
-        DEBUG_MSG("No plugins interested in portnum=%d\n", mp.decoded.data.portnum);
+    if(currentReply) {
+        DEBUG_MSG("Sending response\n"); 
+        service.sendToMesh(currentReply);
+        currentReply = NULL;
+    }
+
+    if (!pluginFound)
+        DEBUG_MSG("No plugins interested in portnum=%d\n", mp.decoded.portnum);
 }
 
 /** 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.  Implementing this method
  * is optional
  */
-void MeshPlugin::sendResponse(const MeshPacket &req) {
+void MeshPlugin::sendResponse(const MeshPacket &req)
+{
     auto r = allocReply();
-    if(r) {
-        DEBUG_MSG("Sending response\n");
+    if (r) {
         setReplyTo(r, req);
-        service.sendToMesh(r);
-    }
-    else {
-        DEBUG_MSG("WARNING: Client requested response but this plugin did not provide\n");
+        currentReply = r;       
+    } else {
+        // Ignore - this is now expected behavior for routing plugin (because it ignores some replies)
+        // DEBUG_MSG("WARNING: Client requested response but this plugin did not provide\n");
     }
 }
 
-/** set the destination and packet parameters of packet p intended as a reply to a particular "to" packet 
+/** set the destination and packet parameters of packet p intended as a reply to a particular "to" packet
  * This ensures that if the request packet was sent reliably, the reply is sent that way as well.
-*/
-void setReplyTo(MeshPacket *p, const MeshPacket &to) {
-    p->to = to.from;
-    p->want_ack = to.want_ack;
-}
+ */
+void setReplyTo(MeshPacket *p, const MeshPacket &to)
+{
+    assert(p->which_payloadVariant == MeshPacket_decoded_tag); // Should already be set by now
+    p->to = getFrom(&to);
+
+    // No need for an ack if we are just delivering locally (it just generates an ignored ack)
+    p->want_ack = (to.from != 0) ? to.want_ack : false;
+    if(p->priority == MeshPacket_Priority_UNSET)
+        p->priority = MeshPacket_Priority_RELIABLE;
+    p->decoded.request_id = to.id;
+}
+
+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,9 +30,19 @@ 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;
 
+    /* Most plugins only care about packets that are destined for their node (i.e. broadcasts or has their node as the specific recipient)
+    But some plugs might want to 'sniff' packets that are merely being routed (passing through the current node).  Those plugins can set this to
+    true and their handleReceived() will be called for every packet.
+    */
+    bool isPromiscuous = false;
+
     /**
      * If this plugin is currently handling a request currentRequest will be preset
      * to the packet with the request.  This is mostly useful for reply handlers.
@@ -49,7 +61,7 @@ class MeshPlugin
     /**
      * @return true if you want to receive the specified portnum
      */
-    virtual bool wantPortnum(PortNum p) = 0;
+    virtual bool wantPacket(const MeshPacket *p) = 0;
 
     /** Called to handle a particular incoming message
 
@@ -61,8 +73,22 @@ 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:
 
+    /**
+     * If any of the current chain of plugins has already sent a reply, it will be here.  This is useful to allow 
+     * the RoutingPlugin to avoid sending redundant acks
+     */
+    static MeshPacket *currentReply;
+    friend class ReliableRouter;  
+
     /** 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.  This method calls allocReply()
      * to generate the reply message, and if !NULL that message will be delivered to whoever sent req

src/mesh/MeshService.cpp

@@ -13,8 +13,8 @@
 #include "RTC.h"
 #include "main.h"
 #include "mesh-pb-constants.h"
-#include "plugins/PositionPlugin.h"
 #include "plugins/NodeInfoPlugin.h"
+#include "plugins/PositionPlugin.h"
 #include "power.h"
 
 /*
@@ -51,23 +51,6 @@ 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)
 {
     // assert(MAX_RX_TOPHONE == 32); // FIXME, delete this, just checking my clever macro
@@ -75,18 +58,13 @@ 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();
 
     if (gps)
         gpsObserver.observe(&gps->newStatus);
-    packetReceivedObserver.observe(&router->notifyPacketReceived);
 }
 
-
 int MeshService::handleFromRadio(const MeshPacket *mp)
 {
     powerFSM.trigger(EVENT_RECEIVED_PACKET); // Possibly keep the node from sleeping
@@ -147,8 +125,12 @@ void MeshService::reloadOwner()
  */
 void MeshService::handleToRadio(MeshPacket &p)
 {
-    if (p.from == 0) // If the phone didn't set a sending node ID, use ours
-        p.from = nodeDB.getNodeNum();
+    if (p.from != 0) { // We don't let phones assign nodenums to their sent messages
+        DEBUG_MSG("Warning: phone tried to pick a nodenum, we don't allow that.\n");
+        p.from = 0;
+    } else {
+        // p.from = nodeDB.getNodeNum();
+    }
 
     if (p.id == 0)
         p.id = generatePacketId(); // If the phone didn't supply one, then pick one
@@ -170,7 +152,8 @@ void MeshService::handleToRadio(MeshPacket &p)
 }
 
 /** Attempt to cancel a previously sent packet from this _local_ node.  Returns true if a packet was found we could cancel */
-bool MeshService::cancelSending(PacketId id) {
+bool MeshService::cancelSending(PacketId id)
+{
     return router->cancelSending(nodeDB.getNodeNum(), id);
 }
 
@@ -178,18 +161,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);
 }
@@ -207,21 +178,22 @@ void MeshService::sendNetworkPing(NodeNum dest, bool wantReplies)
         nodeInfoPlugin->sendOurNodeInfo(dest, wantReplies);
 }
 
-
-NodeInfo *MeshService::refreshMyNodeInfo() {
+NodeInfo *MeshService::refreshMyNodeInfo()
+{
     NodeInfo *node = nodeDB.getNode(nodeDB.getNodeNum());
     assert(node);
 
     // We might not have a position yet for our local node, in that case, at least try to send the time
-    if(!node->has_position) {
+    if (!node->has_position) {
         memset(&node->position, 0, sizeof(node->position));
         node->has_position = true;
     }
-    
+
     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);
@@ -240,11 +212,10 @@ int MeshService::onGPSChanged(const meshtastic::GPSStatus *unused)
             pos.altitude = gps->altitude;
         pos.latitude_i = gps->latitude;
         pos.longitude_i = gps->longitude;
-    }
-    else {
+    } 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 +225,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/MeshService.h

@@ -19,8 +19,6 @@ class MeshService
 {
     CallbackObserver<MeshService, const meshtastic::GPSStatus *> gpsObserver =
         CallbackObserver<MeshService, const meshtastic::GPSStatus *>(this, &MeshService::onGPSChanged);
-    CallbackObserver<MeshService, const MeshPacket *> packetReceivedObserver =
-        CallbackObserver<MeshService, const MeshPacket *>(this, &MeshService::handleFromRadio);
 
     /// received packets waiting for the phone to process them
     /// FIXME, change to a DropOldestQueue and keep a count of the number of dropped packets to ensure
@@ -91,9 +89,10 @@ class MeshService
     /// returns 0 to allow futher processing
     int onGPSChanged(const meshtastic::GPSStatus *arg);
 
-    /// Handle a packet that just arrived from the radio.  This method does _not_ free the provided packet.  If it needs
+    /// Handle a packet that just arrived from the radio.  This method does _ReliableRouternot_ free the provided packet.  If it needs
     /// to keep the packet around it makes a copy
     int handleFromRadio(const MeshPacket *p);
+    friend class RoutingPlugin;
 };
 
 extern MeshService service;

src/mesh/MeshTypes.h

@@ -13,6 +13,9 @@ 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
+#define ERRNO_TOO_LARGE 35
+#define ERRNO_NO_CHANNEL 36
 
 /**
  * the max number of hops a message can pass through, used as the default max for hop_limit in MeshPacket.
@@ -29,4 +32,10 @@ typedef uint32_t PacketId; // A packet sequence number
 typedef int ErrorCode;
 
 /// Alloc and free packets to our global, ISR safe pool
-extern Allocator<MeshPacket> &packetPool;
+extern Allocator<MeshPacket> &packetPool;
+
+/**
+ * Most (but not always) of the time we want to treat packets 'from' the local phone (where from == 0), as if they originated on the local node.
+ * If from is zero this function returns our node number instead
+ */
+NodeNum getFrom(const MeshPacket *p);

src/mesh/NodeDB.cpp

@@ -4,10 +4,10 @@
 
 #include "FS.h"
 
+#include "Channels.h"
 #include "CryptoEngine.h"
 #include "FSCommon.h"
 #include "GPS.h"
-#include "main.h"
 #include "MeshRadio.h"
 #include "NodeDB.h"
 #include "PacketHistory.h"
@@ -16,6 +16,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>
@@ -30,7 +31,6 @@ NodeDB nodeDB;
 EXT_RAM_ATTR DeviceState devicestate;
 MyNodeInfo &myNodeInfo = devicestate.my_node;
 RadioConfig &radioConfig = devicestate.radio;
-ChannelSettings &channelSettings = radioConfig.channel_settings;
 
 /** The current change # for radio settings.  Starts at 0 on boot and any time the radio settings
  * might have changed is incremented.  Allows others to detect they might now be on a new channel.
@@ -64,155 +64,35 @@ static uint8_t ourMacAddr[6];
  */
 NodeNum displayedNodeNum;
 
-/// A usable (but bigger) version of the channel name in the channelSettings object
-const char *channelName;
-
-/// A usable psk - which has been constructed based on the (possibly short psk) in channelSettings
-static uint8_t activePSK[32];
-static uint8_t activePSKSize;
+NodeDB::NodeDB() : nodes(devicestate.node_db), numNodes(&devicestate.node_db_count) {}
 
 /**
- * Generate a short suffix used to disambiguate channels that might have the same "name" entered by the human but different PSKs.
- * The ideas is that the PSK changing should be visible to the user so that they see they probably messed up and that's why they
-their nodes
- * aren't talking to each other.
- *
- * This string is of the form "#name-X".
- *
- * Where X is either:
- * (for custom PSKS) a letter from A to Z (base26), and formed by xoring all the bytes of the PSK together,
- * OR (for the standard minimially secure PSKs) a number from 0 to 9.
- *
- * This function will also need to be implemented in GUI apps that talk to the radio.
- *
- * https://github.com/meshtastic/Meshtastic-device/issues/269
+ * Most (but not always) of the time we want to treat packets 'from' the local phone (where from == 0), as if they originated on the local node.
+ * If from is zero this function returns our node number instead
  */
-const char *getChannelName()
-{
-    static char buf[32];
-
-    char suffix;
-    if (channelSettings.psk.size != 1) {
-        // We have a standard PSK, so generate a letter based hash.
-        uint8_t code = 0;
-        for (int i = 0; i < activePSKSize; i++)
-            code ^= activePSK[i];
-
-        suffix = 'A' + (code % 26);
-    } else {
-        suffix = '0' + channelSettings.psk.bytes[0];
-    }
-
-    snprintf(buf, sizeof(buf), "#%s-%c", channelName, suffix);
-    return buf;
+NodeNum getFrom(const MeshPacket *p) {
+    return (p->from == 0) ? nodeDB.getNodeNum() : p->from;
 }
 
-NodeDB::NodeDB() : nodes(devicestate.node_db), numNodes(&devicestate.node_db_count) {}
-
 bool NodeDB::resetRadioConfig()
 {
     bool didFactoryReset = false;
 
     radioGeneration++;
 
-    /// 16 bytes of random PSK for our _public_ default channel that all devices power up on (AES128)
-    static const uint8_t defaultpsk[] = {0xd4, 0xf1, 0xbb, 0x3a, 0x20, 0x29, 0x07, 0x59,
-                                         0xf0, 0xbc, 0xff, 0xab, 0xcf, 0x4e, 0x69, 0xbf};
-
     if (radioConfig.preferences.factory_reset) {
         DEBUG_MSG("Performing factory reset!\n");
         installDefaultDeviceState();
         didFactoryReset = true;
-    } else if (!channelSettings.psk.size) {
-        DEBUG_MSG("Setting default preferences!\n");
+    } else if (devicestate.channels_count == 0) {
+        DEBUG_MSG("Setting default channel and radio preferences!\n");
+
+        channels.initDefaults();
 
-        radioConfig.has_channel_settings = true;
         radioConfig.has_preferences = true;
-
-        // radioConfig.modem_config = RadioConfig_ModemConfig_Bw125Cr45Sf128;  // medium range and fast
-        // channelSettings.modem_config = ChannelSettings_ModemConfig_Bw500Cr45Sf128;  // short range and fast, but wide
-        // bandwidth so incompatible radios can talk together
-        channelSettings.modem_config = ChannelSettings_ModemConfig_Bw125Cr48Sf4096; // slow and long range
-
-        channelSettings.tx_power = 0; // default
-        uint8_t defaultpskIndex = 1;
-        channelSettings.psk.bytes[0] = defaultpskIndex;
-        channelSettings.psk.size = 1;
-        strcpy(channelSettings.name, "");
     }
 
-    // Convert the old string "Default" to our new short representation
-    if (strcmp(channelSettings.name, "Default") == 0)
-        *channelSettings.name = '\0';
-
-    // Convert the short "" representation for Default into a usable string
-    channelName = channelSettings.name;
-    if (!*channelName) { // emptystring
-        // Per mesh.proto spec, if bandwidth is specified we must ignore modemConfig enum, we assume that in that case
-        // the app fucked up and forgot to set channelSettings.name
-
-        if (channelSettings.bandwidth != 0)
-            channelName = "Unset";
-        else
-            switch (channelSettings.modem_config) {
-            case ChannelSettings_ModemConfig_Bw125Cr45Sf128:
-                channelName = "Medium";
-                break;
-            case ChannelSettings_ModemConfig_Bw500Cr45Sf128:
-                channelName = "ShortFast";
-                break;
-            case ChannelSettings_ModemConfig_Bw31_25Cr48Sf512:
-                channelName = "LongAlt";
-                break;
-            case ChannelSettings_ModemConfig_Bw125Cr48Sf4096:
-                channelName = "LongSlow";
-                break;
-            default:
-                channelName = "Invalid";
-                break;
-            }
-    }
-
-    // Convert any old usage of the defaultpsk into our new short representation.
-    if (channelSettings.psk.size == sizeof(defaultpsk) &&
-        memcmp(channelSettings.psk.bytes, defaultpsk, sizeof(defaultpsk)) == 0) {
-        *channelSettings.psk.bytes = 1;
-        channelSettings.psk.size = 1;
-    }
-
-    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)
-        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
-
-        uint8_t pskIndex = activePSK[0];
-        DEBUG_MSG("Expanding short PSK #%d\n", pskIndex);
-        if (pskIndex == 0)
-            activePSKSize = 0; // Turn off encryption
-        else {
-            memcpy(activePSK, defaultpsk, sizeof(defaultpsk));
-            activePSKSize = sizeof(defaultpsk);
-            // Bump up the last byte of PSK as needed
-            uint8_t *last = activePSK + sizeof(defaultpsk) - 1;
-            *last = *last + pskIndex - 1; // index of 1 means no change vs defaultPSK
-        }
-    } 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) {
-        // 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");
-        activePSKSize = 32;
-    }
-
-    // Tell our crypto engine about the psk
-    crypto->setKey(activePSKSize, activePSK);
+    channels.onConfigChanged();
 
     // temp hack for quicker testing
     // devicestate.no_save = true;
@@ -251,7 +131,6 @@ void NodeDB::installDefaultDeviceState()
     devicestate.has_my_node = true;
     devicestate.has_radio = true;
     devicestate.has_owner = true;
-    devicestate.radio.has_channel_settings = true;
     devicestate.radio.has_preferences = true;
     devicestate.node_db_count = 0;
     devicestate.receive_queue_count = 0; // Not yet implemented FIXME
@@ -277,7 +156,7 @@ void NodeDB::installDefaultDeviceState()
     // Restore region if possible
     if (oldRegionCode != RegionCode_Unset)
         radioConfig.preferences.region = oldRegionCode;
-    if (oldRegion.length())
+    if (oldRegion.length()) // If the old style region was set, try to keep it up-to-date
         strcpy(myNodeInfo.region, oldRegion.c_str());
 }
 
@@ -289,17 +168,14 @@ void NodeDB::init()
     loadFromDisk();
     // saveToDisk();
 
-    // We set node_num and packet_id _after_ loading from disk, because we always want to use the values this
-    // rom was compiled for, not what happens to be in the save file.
-    myNodeInfo.node_num_bits = sizeof(NodeNum) * 8;
-    myNodeInfo.packet_id_bits = sizeof(PacketId) * 8;
+    myNodeInfo.max_channels = MAX_NUM_CHANNELS; // tell others the max # of channels we can understand
 
     myNodeInfo.error_code =
         CriticalErrorCode_None; // For the error code, only show values from this boot (discard value from flash)
     myNodeInfo.error_address = 0;
 
     // likewise - we always want the app requirements to come from the running appload
-    myNodeInfo.min_app_version = 20120; // format is Mmmss (where M is 1+the numeric major number. i.e. 20120 means 1.1.20
+    myNodeInfo.min_app_version = 20200; // format is Mmmss (where M is 1+the numeric major number. i.e. 20120 means 1.1.20
 
     // Note! We do this after loading saved settings, so that if somehow an invalid nodenum was stored in preferences we won't
     // keep using that nodenum forever. Crummy guess at our nodenum (but we will check against the nodedb to avoid conflicts)
@@ -489,7 +365,17 @@ 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
+    // A lot of position reports don't have time populated.  In that case, be careful to not blow away the time we
+    // recorded based on the packet rxTime
+    if (!info->position.time && 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
@@ -526,10 +412,9 @@ void NodeDB::updateUser(uint32_t nodeId, const User &p)
 void NodeDB::updateFrom(const MeshPacket &mp)
 {
     if (mp.which_payloadVariant == MeshPacket_decoded_tag) {
-        const SubPacket &p = mp.decoded;
         DEBUG_MSG("Update DB node 0x%x, rx_time=%u\n", mp.from, mp.rx_time);
 
-        NodeInfo *info = getOrCreateNode(mp.from);
+        NodeInfo *info = getOrCreateNode(getFrom(&mp));
 
         if (mp.rx_time) {              // if the packet has a valid timestamp use it to update our last_seen
             info->has_position = true; // at least the time is valid
@@ -537,31 +422,6 @@ void NodeDB::updateFrom(const MeshPacket &mp)
         }
 
         info->snr = mp.rx_snr; // keep the most recent SNR we received for this node.
-
-        switch (p.which_payloadVariant) {
-        case SubPacket_position_tag: {
-            // handle a legacy position packet
-            DEBUG_MSG("WARNING: Processing a (deprecated) position packet from %d\n", mp.from);
-            updatePosition(mp.from, p.position);
-            break;
-        }
-
-        case SubPacket_data_tag: {
-            if (mp.to == NODENUM_BROADCAST || mp.to == nodeDB.getNodeNum())
-                MeshPlugin::callPlugins(mp);
-            break;
-        }
-
-        case SubPacket_user_tag: {
-            DEBUG_MSG("WARNING: Processing a (deprecated) user packet from %d\n", mp.from);
-            updateUser(mp.from, p.user);
-            break;
-        }
-
-        default: {
-            notifyObservers(); // If the node counts have changed, notify observers
-        }
-        }
     }
 }
 
@@ -601,10 +461,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/NodeDB.h

@@ -11,9 +11,7 @@
 extern DeviceState devicestate;
 extern MyNodeInfo &myNodeInfo;
 extern RadioConfig &radioConfig;
-extern ChannelSettings &channelSettings;
 extern User &owner;
-extern const char *channelName;
 
 /// Given a node, return how many seconds in the past (vs now) that we last heard from it
 uint32_t sinceLastSeen(const NodeInfo *n);
@@ -130,23 +128,6 @@ extern NodeNum displayedNodeNum;
 
 extern NodeDB nodeDB;
 
-/**
- * Generate a short suffix used to disambiguate channels that might have the same "name" entered by the human but different PSKs.
- * The ideas is that the PSK changing should be visible to the user so that they see they probably messed up and that's why they
-their nodes
- * aren't talking to each other.
- *
- * This string is of the form "#name-XY".
- *
- * Where X is a letter from A to Z (base26), and formed by xoring all the bytes of the PSK together.
- * Y is not yet used but should eventually indicate 'speed/range' of the link
- *
- * This function will also need to be implemented in GUI apps that talk to the radio.
- *
- * https://github.com/meshtastic/Meshtastic-device/issues/269
- */
-const char *getChannelName();
-
 /*
   If is_router is set, we use a number of different default values
 
@@ -173,7 +154,7 @@ const char *getChannelName();
 */
 
 // Our delay functions check for this for times that should never expire
-#define DELAY_FOREVER 0xffffffff
+#define NODE_DELAY_FOREVER 0xffffffff
 
 #define IF_ROUTER(routerVal, normalVal) (radioConfig.preferences.is_router ? (routerVal) : (normalVal))
 
@@ -187,8 +168,8 @@ PREF_GET(position_broadcast_secs, IF_ROUTER(12 * 60 * 60, 15 * 60))
 PREF_GET(wait_bluetooth_secs, IF_ROUTER(1, 60))
 
 PREF_GET(screen_on_secs, 60)
-PREF_GET(mesh_sds_timeout_secs, IF_ROUTER(DELAY_FOREVER, 2 * 60 * 60))
-PREF_GET(phone_sds_timeout_sec, IF_ROUTER(DELAY_FOREVER, 2 * 60 * 60))
+PREF_GET(mesh_sds_timeout_secs, IF_ROUTER(NODE_DELAY_FOREVER, 2 * 60 * 60))
+PREF_GET(phone_sds_timeout_sec, IF_ROUTER(NODE_DELAY_FOREVER, 2 * 60 * 60))
 PREF_GET(sds_secs, 365 * 24 * 60 * 60)
 
 // We default to sleeping (with bluetooth off for 5 minutes at a time).  This seems to be a good tradeoff between
@@ -202,3 +183,4 @@ PREF_GET(min_wake_secs, 10)
  * might have changed is incremented.  Allows others to detect they might now be on a new channel.
  */
 extern uint32_t radioGeneration;
+

src/mesh/PacketHistory.cpp

@@ -26,7 +26,7 @@ bool PacketHistory::wasSeenRecently(const MeshPacket *p, bool withUpdate)
             // DEBUG_MSG("Deleting old broadcast record %d\n", i);
             recentPackets.erase(recentPackets.begin() + i); // delete old record
         } else {
-            if (r.id == p->id && r.sender == p->from) {
+            if (r.id == p->id && r.sender == getFrom(p)) {
                 DEBUG_MSG("Found existing packet record for fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
 
                 // Update the time on this record to now
@@ -43,7 +43,7 @@ bool PacketHistory::wasSeenRecently(const MeshPacket *p, bool withUpdate)
     if (withUpdate) {
         PacketRecord r;
         r.id = p->id;
-        r.sender = p->from;
+        r.sender = getFrom(p);
         r.rxTimeMsec = now;
         recentPackets.push_back(r);
         printPacket("Adding packet record", p);

src/mesh/PhoneAPI.cpp

@@ -4,6 +4,7 @@
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "RadioInterface.h"
+#include "Channels.h"
 #include <assert.h>
 
 #if FromRadio_size > MAX_TO_FROM_RADIO_SIZE
@@ -58,6 +59,7 @@ void PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
     }
     // return (lastContactMsec != 0) &&
 
+    memset(&toRadioScratch, 0, sizeof(toRadioScratch));
     if (pb_decode_from_bytes(buf, bufLength, ToRadio_fields, &toRadioScratch)) {
         switch (toRadioScratch.which_payloadVariant) {
         case ToRadio_packet_tag: {
@@ -77,16 +79,6 @@ void PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
                                        // this will break once we have multiple instances of PhoneAPI running independently
             break;
 
-        case ToRadio_set_owner_tag:
-            DEBUG_MSG("Client is setting owner\n");
-            handleSetOwner(toRadioScratch.set_owner);
-            break;
-
-        case ToRadio_set_radio_tag:
-            DEBUG_MSG("Client is setting radio\n");
-            handleSetRadio(toRadioScratch.set_radio);
-            break;
-
         default:
             DEBUG_MSG("Error: unexpected ToRadio variant\n");
             break;
@@ -133,24 +125,11 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
                                  : (gps && gps->isConnected()); // Update with latest GPS connect info
         fromRadioScratch.which_payloadVariant = FromRadio_my_info_tag;
         fromRadioScratch.my_info = myNodeInfo;
-        state = STATE_SEND_RADIO;
+        state = STATE_SEND_NODEINFO;
 
         service.refreshMyNodeInfo();  // Update my NodeInfo because the client will be asking for it soon.
         break;
 
-    case STATE_SEND_RADIO:
-        fromRadioScratch.which_payloadVariant = FromRadio_radio_tag;
-
-        fromRadioScratch.radio = radioConfig;
-
-        // NOTE: The phone app needs to know the ls_secs value so it can properly expect sleep behavior.
-        // So even if we internally use 0 to represent 'use default' we still need to send the value we are
-        // using to the app (so that even old phone apps work with new device loads).
-        fromRadioScratch.radio.preferences.ls_secs = getPref_ls_secs();
-
-        state = STATE_SEND_NODEINFO;
-        break;
-
     case STATE_SEND_NODEINFO: {
         const NodeInfo *info = nodeInfoForPhone;
         nodeInfoForPhone = NULL; // We just consumed a nodeinfo, will need a new one next time
@@ -227,9 +206,6 @@ bool PhoneAPI::available()
             nodeInfoForPhone = nodeDB.readNextInfo();
         return true; // Always say we have something, because we might need to advance our state machine
 
-    case STATE_SEND_RADIO:
-        return true;
-
     case STATE_SEND_COMPLETE_ID:
         return true;
 
@@ -250,41 +226,6 @@ bool PhoneAPI::available()
     return false;
 }
 
-//
-// The following routines are only public for now - until the rev1 bluetooth API is removed
-//
-
-void PhoneAPI::handleSetOwner(const User &o)
-{
-    int changed = 0;
-
-    if (*o.long_name) {
-        changed |= strcmp(owner.long_name, o.long_name);
-        strcpy(owner.long_name, o.long_name);
-    }
-    if (*o.short_name) {
-        changed |= strcmp(owner.short_name, o.short_name);
-        strcpy(owner.short_name, o.short_name);
-    }
-    if (*o.id) {
-        changed |= strcmp(owner.id, o.id);
-        strcpy(owner.id, o.id);
-    }
-
-    if (changed) // If nothing really changed, don't broadcast on the network or write to flash
-        service.reloadOwner();
-}
-
-void PhoneAPI::handleSetRadio(const RadioConfig &r)
-{
-    radioConfig = r;
-
-    bool didReset = service.reloadConfig();
-    if (didReset) {
-        state = STATE_SEND_MY_INFO; // Squirt a completely new set of configs to the client
-    }
-}
-
 /**
  * Handle a packet that the phone wants us to send.  It is our responsibility to free the packet to the pool
  */

src/mesh/PhoneAPI.h

@@ -23,7 +23,7 @@ class PhoneAPI
         STATE_LEGACY,       // (no longer used) old default state - until Android apps are all updated, uses the old BLE API
         STATE_SEND_NOTHING, // (Eventual) Initial state, don't send anything until the client starts asking for config
         STATE_SEND_MY_INFO, // send our my info record
-        STATE_SEND_RADIO,
+        // STATE_SEND_RADIO, // in 1.2 we now send this as a regular mesh packet
         // STATE_SEND_OWNER, no need to send Owner specially, it is just part of the nodedb
         STATE_SEND_NODEINFO, // states progress in this order as the device sends to to the client
         STATE_SEND_COMPLETE_ID,
@@ -83,13 +83,6 @@ class PhoneAPI
      */
     bool available();
 
-    //
-    // The following routines are only public for now - until the rev1 bluetooth API is removed
-    //
-
-    void handleSetOwner(const User &o);
-    void handleSetRadio(const RadioConfig &r);
-
   protected:
     /// Are we currently connected to a client?
     bool isConnected = false;

src/mesh/ProtobufPlugin.h

@@ -8,7 +8,7 @@
  * If you are using protobufs to encode your packets (recommended) you can use this as a baseclass for your plugin
  * and avoid a bunch of boilerplate code.
  */
-template <class T> class ProtobufPlugin : private SinglePortPlugin
+template <class T> class ProtobufPlugin : protected SinglePortPlugin
 {
     const pb_msgdesc_t *fields;
 
@@ -25,8 +25,11 @@ template <class T> class ProtobufPlugin : private SinglePortPlugin
 
     /**
      * Handle a received message, the data field in the message is already decoded and is provided
+     * 
+     * In general decoded will always be !NULL.  But in some special applications (where you have handling packets
+     * for multiple port numbers, decoding will ONLY be attempted for packets where the portnum matches our expected ourPortNum.
      */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const T &decoded) = 0;
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const T *decoded) = 0;
 
     /**
      * Return a mesh packet which has been preinited with a particular protobuf data payload and port number.
@@ -38,8 +41,8 @@ template <class T> class ProtobufPlugin : private SinglePortPlugin
         // Update our local node info with our position (even if we don't decide to update anyone else)
         MeshPacket *p = allocDataPacket();
 
-        p->decoded.data.payload.size =
-            pb_encode_to_bytes(p->decoded.data.payload.bytes, sizeof(p->decoded.data.payload.bytes), fields, &payload);
+        p->decoded.payload.size =
+            pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), fields, &payload);
         // DEBUG_MSG("did encode\n");
         return p;
     }
@@ -54,13 +57,19 @@ template <class T> class ProtobufPlugin : private SinglePortPlugin
         // FIXME - we currently update position data in the DB only if the message was a broadcast or destined to us
         // it would be better to update even if the message was destined to others.
 
-        auto &p = mp.decoded.data;
-        DEBUG_MSG("Received %s from=0x%0x, id=0x%x, payloadlen=%d\n", name, mp.from, mp.id, p.payload.size);
+        auto &p = mp.decoded;
+        DEBUG_MSG("Received %s from=0x%0x, id=0x%x, portnum=%d, payloadlen=%d\n", name, mp.from, mp.id, p.portnum, p.payload.size);
 
         T scratch;
-        if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, fields, &scratch))
-            return handleReceivedProtobuf(mp, scratch);
+        T *decoded = NULL; 
+        if(mp.decoded.portnum == ourPortNum) {
+            memset(&scratch, 0, sizeof(scratch));
+            if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, fields, &scratch))
+                decoded = &scratch;
+            else
+                DEBUG_MSG("Error decoding protobuf plugin!\n");
+        }
 
-        return false; // Let others look at this message also if they want
+        return handleReceivedProtobuf(mp, decoded);
     }
 };

src/mesh/RadioInterface.cpp

@@ -1,5 +1,6 @@
 
 #include "RadioInterface.h"
+#include "Channels.h"
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
@@ -9,6 +10,7 @@
 #include <assert.h>
 #include <pb_decode.h>
 #include <pb_encode.h>
+#include "Channels.h"
 
 #define RDEF(name, freq, spacing, num_ch, power_limit)                                                                           \
     {                                                                                                                            \
@@ -36,7 +38,7 @@ void initRegion()
     myRegion = r;
     DEBUG_MSG("Wanted region %d, using %s\n", radioConfig.preferences.region, r->name);
 
-    myNodeInfo.num_channels = myRegion->numChannels; // Tell our android app how many channels we have
+    myNodeInfo.num_bands = myRegion->numChannels; // Tell our android app how many channels we have
 }
 
 /**
@@ -117,27 +119,13 @@ uint32_t RadioInterface::getTxDelayMsec()
 
 void printPacket(const char *prefix, const MeshPacket *p)
 {
-    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("%s (id=0x%08x Fr0x%02x To0x%02x, WantAck%d, HopLim%d Ch0x%x", prefix, p->id, p->from & 0xff, p->to & 0xff, p->want_ack,
+              p->hop_limit, p->channel);
     if (p->which_payloadVariant == MeshPacket_decoded_tag) {
         auto &s = p->decoded;
-        switch (s.which_payloadVariant) {
-        case SubPacket_data_tag:
-            DEBUG_MSG(" Portnum=%d", s.data.portnum);
-            break;
-        case SubPacket_position_tag:
-            DEBUG_MSG(" Payload:Position");
-            break;
-        case SubPacket_user_tag:
-            DEBUG_MSG(" Payload:User");
-            break;
-        case 0:
-            DEBUG_MSG(" Payload:None");
-            break;
-        default:
-            DEBUG_MSG(" Payload:%d", s.which_payloadVariant);
-            break;
-        }
+        
+        DEBUG_MSG(" Portnum=%d", s.portnum);
+
         if (s.want_response)
             DEBUG_MSG(" WANTRESP");
 
@@ -147,10 +135,11 @@ void printPacket(const char *prefix, const MeshPacket *p)
         if (s.dest != 0)
             DEBUG_MSG(" dest=%08x", s.dest);
 
+        /* now inside Data and therefore kinda opaque
         if (s.which_ackVariant == SubPacket_success_id_tag)
             DEBUG_MSG(" successId=%08x", s.ackVariant.success_id);
         else if (s.which_ackVariant == SubPacket_fail_id_tag)
-            DEBUG_MSG(" failId=%08x", s.ackVariant.fail_id);
+            DEBUG_MSG(" failId=%08x", s.ackVariant.fail_id); */
     } else {
         DEBUG_MSG(" encrypted");
     }
@@ -161,15 +150,15 @@ void printPacket(const char *prefix, const MeshPacket *p)
     if (p->rx_snr != 0.0) {
         DEBUG_MSG(" rxSNR=%g", p->rx_snr);
     }
-    if(p->priority != 0)
+    if (p->priority != 0)
         DEBUG_MSG(" priority=%d", p->priority);
-        
+
     DEBUG_MSG(")\n");
 }
 
 RadioInterface::RadioInterface()
 {
-    assert(sizeof(PacketHeader) == 4 || sizeof(PacketHeader) == 16); // make sure the compiler did what we expected
+    assert(sizeof(PacketHeader) == 16); // make sure the compiler did what we expected
 
     // Can't print strings this early - serial not setup yet
     // DEBUG_MSG("Set meshradio defaults name=%s\n", channelSettings.name);
@@ -212,6 +201,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
  */
@@ -220,6 +241,7 @@ void RadioInterface::applyModemConfig()
     // Set up default configuration
     // No Sync Words in LORA mode
 
+    auto channelSettings = channels.getPrimary();
     if (channelSettings.spread_factor == 0) {
         switch (channelSettings.modem_config) {
         case ChannelSettings_ModemConfig_Bw125Cr45Sf128: ///< Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on. Default medium
@@ -264,18 +286,20 @@ 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;
+    const char *channelName = channels.getName(channels.getPrimaryIndex());
+    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);
 }
 
 /**
@@ -327,6 +351,7 @@ size_t RadioInterface::beginSending(MeshPacket *p)
     h->from = p->from;
     h->to = p->to;
     h->id = p->id;
+    h->channel = p->channel;
     assert(p->hop_limit <= HOP_MAX);
     h->flags = p->hop_limit | (p->want_ack ? PACKET_FLAGS_WANT_ACK_MASK : 0);
 

src/mesh/RadioInterface.h

@@ -29,6 +29,9 @@ typedef struct {
      * The bottom three bits of flags are use to store hop_limit when sent over the wire.
      **/
     uint8_t flags;
+
+    /** The channel hash - used as a hint for the decoder to limit which channels we consider */
+    uint8_t channel;
 } PacketHeader;
 
 /**
@@ -54,6 +57,8 @@ class RadioInterface
     uint32_t shortPacketMsec;
 
   protected:
+    bool disabled = false;
+
     float bw = 125;
     uint8_t sf = 9;
     uint8_t cr = 7;
@@ -98,6 +103,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 +144,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 +181,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;
 
@@ -270,6 +275,7 @@ void RadioLibInterface::handleReceiveInterrupt()
             mp->from = h->from;
             mp->to = h->to;
             mp->id = h->id;
+            mp->channel = h->channel;
             assert(HOP_MAX <= PACKET_FLAGS_HOP_MASK); // If hopmax changes, carefully check this code
             mp->hop_limit = h->flags & PACKET_FLAGS_HOP_MASK;
             mp->want_ack = !!(h->flags & PACKET_FLAGS_WANT_ACK_MASK);
@@ -277,15 +283,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 +301,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/RadioLibInterface.h

@@ -80,10 +80,13 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
   protected:
 
     /**
-     * FIXME, use a meshtastic sync word, but hashed with the Channel name.  Currently picking the same default
-     * the RF95 used (0x14). Note: do not use 0x34 - that is reserved for lorawan
+     * We use a meshtastic sync word, but hashed with the Channel name.  For releases before 1.2 we used 0x12 (or for very old loads 0x14)
+     * Note: do not use 0x34 - that is reserved for lorawan
+     * 
+     * We now use 0x2b (so that someday we can possibly use NOT 2b - because that would be funny pun).  We will be staying with this code
+     * for a long time.
      */
-    uint8_t syncWord = SX126X_SYNC_WORD_PRIVATE;
+    const uint8_t syncWord = 0x2b;
 
     float currentLimit = 100;     // FIXME
 

src/mesh/ReliableRouter.cpp

@@ -2,6 +2,7 @@
 #include "MeshTypes.h"
 #include "configuration.h"
 #include "mesh-pb-constants.h"
+#include "MeshPlugin.h"
 
 // ReliableRouter::ReliableRouter() {}
 
@@ -26,15 +27,17 @@ ErrorCode ReliableRouter::send(MeshPacket *p)
 
 bool ReliableRouter::shouldFilterReceived(const MeshPacket *p)
 {
+    // Note: do not use getFrom() here, because we want to ignore messages sent from phone
     if (p->to == NODENUM_BROADCAST && p->from == getNodeNum()) {
         printPacket("Rx someone rebroadcasting for us", p);
 
         // We are seeing someone rebroadcast one of our broadcast attempts.
         // If this is the first time we saw this, cancel any retransmissions we have queued up and generate an internal ack for
         // the original sending process.
-        if (stopRetransmission(p->from, p->id)) {
+        if (stopRetransmission(getFrom(p), p->id)) {
             DEBUG_MSG("Someone is retransmitting for us, generate implicit ack\n");
-            sendAckNak(ErrorReason_NONE, p->from, p->id);
+            if(p->want_ack)
+                sendAckNak(Routing_Error_NONE, getFrom(p), p->id);
         }
     }
 
@@ -53,35 +56,39 @@ bool ReliableRouter::shouldFilterReceived(const MeshPacket *p)
  *
  * Otherwise, let superclass handle it.
  */
-void ReliableRouter::sniffReceived(const MeshPacket *p)
+void ReliableRouter::sniffReceived(const MeshPacket *p, const Routing *c)
 {
     NodeNum ourNode = getNodeNum();
 
     if (p->to == ourNode) { // ignore ack/nak/want_ack packets that are not address to us (we only handle 0 hop reliability
                             // - not DSR routing)
         if (p->want_ack) {
-            sendAckNak(ErrorReason_NONE, p->from, p->id);
+            if(MeshPlugin::currentReply)
+                DEBUG_MSG("Someone else has replied to this message, no need for a 2nd ack");
+            else
+                sendAckNak(Routing_Error_NONE, getFrom(p), p->id);
         }
 
-        // If the payload is valid, look for ack/nak
+        // We consider an ack to be either a !routing packet with a request ID or a routing packet with !error
+        PacketId ackId = ((c && c->error_reason == Routing_Error_NONE) || !c) ? p->decoded.request_id : 0;
 
-        PacketId ackId = p->decoded.which_ackVariant == SubPacket_success_id_tag ? p->decoded.ackVariant.success_id : 0;
-        PacketId nakId = p->decoded.which_ackVariant == SubPacket_fail_id_tag ? p->decoded.ackVariant.fail_id : 0;
+        // A nak is a routing packt that has an  error code
+        PacketId nakId = (c && c->error_reason != Routing_Error_NONE) ? p->decoded.request_id : 0;
 
         // We intentionally don't check wasSeenRecently, because it is harmless to delete non existent retransmission records
         if (ackId || nakId) {
             if (ackId) {
-                DEBUG_MSG("Received a ack=%d, stopping retransmissions\n", ackId);
+                DEBUG_MSG("Received a ack for 0x%x, stopping retransmissions\n", ackId);
                 stopRetransmission(p->to, ackId);
             } else {
-                DEBUG_MSG("Received a nak=%d, stopping retransmissions\n", nakId);
+                DEBUG_MSG("Received a nak for 0x%x, stopping retransmissions\n", nakId);
                 stopRetransmission(p->to, nakId);
             }
         }
     }
 
     // handle the packet as normal
-    FloodingRouter::sniffReceived(p);
+    FloodingRouter::sniffReceived(p, c);
 }
 
 #define NUM_RETRANSMISSIONS 3
@@ -130,7 +137,7 @@ PendingPacket *ReliableRouter::startRetransmission(MeshPacket *p)
     auto rec = PendingPacket(p);
 
     setNextTx(&rec);
-    stopRetransmission(p->from, p->id);
+    stopRetransmission(getFrom(p), p->id);
     pending[id] = rec;
 
     return &pending[id];
@@ -155,7 +162,7 @@ int32_t ReliableRouter::doRetransmissions()
             if (p.numRetransmissions == 0) {
                 DEBUG_MSG("Reliable send failed, returning a nak fr=0x%x,to=0x%x,id=%d\n", p.packet->from, p.packet->to,
                           p.packet->id);
-                sendAckNak(ErrorReason_MAX_RETRANSMIT, p.packet->from, p.packet->id);
+                sendAckNak(Routing_Error_MAX_RETRANSMIT, p.packet->from, p.packet->id);
                 // Note: we don't stop retransmission here, instead the Nak packet gets processed in sniffReceived - which
                 // allows the DSR version to still be able to look at the PendingPacket
                 stopRetransmission(it->first);

src/mesh/ReliableRouter.h

@@ -15,7 +15,7 @@ struct GlobalPacketId {
 
     GlobalPacketId(const MeshPacket *p)
     {
-        node = p->from;
+        node = getFrom(p);
         id = p->id;
     }
 
@@ -90,7 +90,7 @@ class ReliableRouter : public FloodingRouter
     /**
      * Look for acks/naks or someone retransmitting us
      */
-    virtual void sniffReceived(const MeshPacket *p);
+    virtual void sniffReceived(const MeshPacket *p, const Routing *c);
 
     /**
      * Try to find the pending packet record for this ID (or NULL if not found)

src/mesh/Router.cpp

@@ -1,9 +1,11 @@
 #include "Router.h"
+#include "Channels.h"
 #include "CryptoEngine.h"
+#include "NodeDB.h"
 #include "RTC.h"
 #include "configuration.h"
 #include "mesh-pb-constants.h"
-#include <NodeDB.h>
+#include "plugins/RoutingPlugin.h"
 
 /**
  * Router todo
@@ -80,7 +82,6 @@ PacketId generatePacketId()
 
     i++;
     PacketId id = (i % numPacketId) + 1; // return number between 1 and numPacketId (ie - never zero)
-    myNodeInfo.current_packet_id = id;   // Kinda crufty - we keep updating this so the phone can see a current value
     return id;
 }
 
@@ -102,30 +103,17 @@ MeshPacket *Router::allocForSending()
 /**
  * Send an ack or a nak packet back towards whoever sent idFrom
  */
-void Router::sendAckNak(ErrorReason err, NodeNum to, PacketId idFrom)
+void Router::sendAckNak(Routing_Error err, NodeNum to, PacketId idFrom)
 {
-    auto p = allocForSending();
-    p->hop_limit = 0; // Assume just immediate neighbors for now
-    p->to = to;
-    DEBUG_MSG("Sending an err=%d,to=0x%x,idFrom=0x%x,id=0x%x\n", err, to, idFrom, p->id);
-
-    if (!err) {
-        p->decoded.ackVariant.success_id = idFrom;
-        p->decoded.which_ackVariant = SubPacket_success_id_tag;
-    } else {
-        p->decoded.ackVariant.fail_id = idFrom;
-        p->decoded.which_ackVariant = SubPacket_fail_id_tag;
-
-        // Also send back the error reason
-        p->decoded.which_payloadVariant = SubPacket_error_reason_tag;
-        p->decoded.error_reason = err;
-    }
-    p->priority = MeshPacket_Priority_ACK;
-
-    sendLocal(p); // we sometimes send directly to the local node
+    routingPlugin->sendAckNak(err, to, idFrom);
 }
 
-
+void Router::abortSendAndNak(Routing_Error err, MeshPacket *p)
+{
+    DEBUG_MSG("Error=%d, returning NAK and dropping packet.\n", err);
+    sendAckNak(Routing_Error_NO_INTERFACE, getFrom(p), p->id);
+    packetPool.release(p);
+}
 
 ErrorCode Router::sendLocal(MeshPacket *p)
 {
@@ -136,11 +124,7 @@ ErrorCode Router::sendLocal(MeshPacket *p)
         return ERRNO_OK;
     } else if (!iface) {
         // We must be sending to remote nodes also, fail if no interface found
-
-        // ERROR! no radio found, report failure back to the client and drop the packet
-        DEBUG_MSG("Error: No interface, returning NAK and dropping packet.\n");
-        sendAckNak(ErrorReason_NO_INTERFACE, p->from, p->id);
-        packetPool.release(p);
+        abortSendAndNak(Routing_Error_NO_INTERFACE, p);
 
         return ERRNO_NO_INTERFACES;
     } else {
@@ -163,14 +147,18 @@ ErrorCode Router::send(MeshPacket *p)
 {
     assert(p->to != nodeDB.getNodeNum()); // should have already been handled by sendLocal
 
-    PacketId nakId = p->decoded.which_ackVariant == SubPacket_fail_id_tag ? p->decoded.ackVariant.fail_id : 0;
-    assert(
-        !nakId); // I don't think we ever send 0hop naks over the wire (other than to the phone), test that assumption with assert
+    // PacketId nakId = p->decoded.which_ackVariant == SubPacket_fail_id_tag ? p->decoded.ackVariant.fail_id : 0;
+    // assert(!nakId); // I don't think we ever send 0hop naks over the wire (other than to the phone), test that assumption with
+    // assert
 
     // Never set the want_ack flag on broadcast packets sent over the air.
     if (p->to == NODENUM_BROADCAST)
         p->want_ack = false;
 
+    // Up until this point we might have been using 0 for the from address (if it started with the phone), but when we send over
+    // the lora we need to make sure we have replaced it with our local address
+    p->from = getFrom(p);
+
     // If the packet hasn't yet been encrypted, do so now (it might already be encrypted if we are just forwarding it)
 
     assert(p->which_payloadVariant == MeshPacket_encrypted_tag ||
@@ -180,9 +168,22 @@ ErrorCode Router::send(MeshPacket *p)
     if (p->which_payloadVariant == MeshPacket_decoded_tag) {
         static uint8_t bytes[MAX_RHPACKETLEN]; // we have to use a scratch buffer because a union
 
-        size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), SubPacket_fields, &p->decoded);
+        size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), Data_fields, &p->decoded);
 
-        assert(numbytes <= MAX_RHPACKETLEN);
+        if (numbytes > MAX_RHPACKETLEN) {
+            abortSendAndNak(Routing_Error_TOO_LARGE, p);
+            return ERRNO_TOO_LARGE;
+        }
+
+        auto hash = channels.setActiveByIndex(p->channel);
+        if (hash < 0) {
+            // No suitable channel could be found for sending
+            abortSendAndNak(Routing_Error_NO_CHANNEL, p);
+            return ERRNO_NO_CHANNEL;
+        }
+
+        // Now that we are encrypting the packet channel should be the hash (no longer the index)
+        p->channel = hash;
         crypto->encrypt(p->from, p->id, numbytes, bytes);
 
         // Copy back into the packet and set the variant type
@@ -192,28 +193,20 @@ ErrorCode Router::send(MeshPacket *p)
     }
 
     assert(iface); // This should have been detected already in sendLocal (or we just received a packet from outside)
-    // if (iface) {
-    // DEBUG_MSG("Sending packet via interface fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
     return iface->send(p);
-    /* } else {
-        DEBUG_MSG("Dropping packet - no interfaces - fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
-        packetPool.release(p);
-        return ERRNO_NO_INTERFACES;
-    } */
 }
 
 /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
-bool Router::cancelSending(NodeNum from, PacketId id) {
+bool Router::cancelSending(NodeNum from, PacketId id)
+{
     return iface ? iface->cancelSending(from, id) : false;
 }
 
-
-
 /**
  * Every (non duplicate) packet this node receives will be passed through this method.  This allows subclasses to
  * update routing tables etc... based on what we overhear (even for messages not destined to our node)
  */
-void Router::sniffReceived(const MeshPacket *p)
+void Router::sniffReceived(const MeshPacket *p, const Routing *c)
 {
     DEBUG_MSG("FIXME-update-db Sniffing packet\n");
     // FIXME, update nodedb here for any packet that passes through us
@@ -226,23 +219,33 @@ bool Router::perhapsDecode(MeshPacket *p)
 
     assert(p->which_payloadVariant == MeshPacket_encrypted_tag);
 
-    // FIXME - someday don't send routing packets encrypted.  That would allow us to route for other channels without
-    // being able to decrypt their data.
-    // Try to decrypt the packet if we can
-    static uint8_t bytes[MAX_RHPACKETLEN];
-    memcpy(bytes, p->encrypted.bytes,
-           p->encrypted.size); // we have to copy into a scratch buffer, because these bytes are a union with the decoded protobuf
-    crypto->decrypt(p->from, p->id, p->encrypted.size, bytes);
+    // Try to find a channel that works with this hash
+    for (ChannelIndex chIndex = 0; chIndex < channels.getNumChannels(); chIndex++) {
+        // Try to use this hash/channel pair
+        if (channels.decryptForHash(chIndex, p->channel)) {
+            // Try to decrypt the packet if we can
+            static uint8_t bytes[MAX_RHPACKETLEN];
+            memcpy(bytes, p->encrypted.bytes,
+                   p->encrypted
+                       .size); // we have to copy into a scratch buffer, because these bytes are a union with the decoded protobuf
+            crypto->decrypt(p->from, p->id, p->encrypted.size, bytes);
 
-    // Take those raw bytes and convert them back into a well structured protobuf we can understand
-    if (!pb_decode_from_bytes(bytes, p->encrypted.size, SubPacket_fields, &p->decoded)) {
-        DEBUG_MSG("Invalid protobufs in received mesh packet!\n");
-        return false;
-    } else {
-        // parsing was successful
-        p->which_payloadVariant = MeshPacket_decoded_tag;
-        return true;
+            // Take those raw bytes and convert them back into a well structured protobuf we can understand
+            memset(&p->decoded, 0, sizeof(p->decoded));
+            if (!pb_decode_from_bytes(bytes, p->encrypted.size, Data_fields, &p->decoded)) {
+                DEBUG_MSG("Invalid protobufs in received mesh packet (bad psk?!\n");
+            } else {
+                // parsing was successful
+                p->channel = chIndex; // change to store the index instead of the hash
+                // printPacket("decoded message", p);
+                p->which_payloadVariant = MeshPacket_decoded_tag;
+                return true;
+            }
+        }
     }
+
+    DEBUG_MSG("No suitable channel found for decoding, hash was 0x%x!\n", p->channel);
+    return false;
 }
 
 NodeNum Router::getNodeNum()
@@ -260,22 +263,22 @@ void Router::handleReceived(MeshPacket *p)
     p->rx_time = getValidTime(RTCQualityFromNet); // store the arrival timestamp for the phone
 
     // Take those raw bytes and convert them back into a well structured protobuf we can understand
-    if (perhapsDecode(p)) {
+    bool decoded = perhapsDecode(p);
+    printPacket("handleReceived", p);
+    DEBUG_MSG("decoded=%d\n", decoded);    
+    if (decoded) {
         // parsing was successful, queue for our recipient
 
-        sniffReceived(p);
-
-        if (p->to == NODENUM_BROADCAST || p->to == getNodeNum()) {
-            printPacket("Delivering rx packet", p);
-            notifyPacketReceived.notifyObservers(p);
-        }
+        // call any promiscious plugins here, make a (non promisiocous) plugin for forwarding messages to phone api
+        // sniffReceived(p);
+        MeshPlugin::callPlugins(*p);
     }
 }
 
 void Router::perhapsHandleReceived(MeshPacket *p)
 {
     assert(radioConfig.has_preferences);
-    bool ignore = is_in_repeated(radioConfig.preferences.ignore_incoming, p->from);
+    bool ignore = is_in_repeated(radioConfig.preferences.ignore_incoming, getFrom(p));
 
     if (ignore)
         DEBUG_MSG("Ignoring incoming message, 0x%x is in our ignore list\n", p->from);

src/mesh/Router.h

@@ -21,10 +21,6 @@ class Router : protected concurrency::OSThread
     RadioInterface *iface = NULL;
 
   public:
-    /// Local services that want to see _every_ packet this node receives can observe this.
-    /// Observers should always return 0 and _copy_ any packets they want to keep for use later (this packet will be getting
-    /// freed)
-    Observable<const MeshPacket *> notifyPacketReceived;
 
     /**
      * Constructor
@@ -68,6 +64,8 @@ class Router : protected concurrency::OSThread
     NodeNum getNodeNum();
 
   protected:
+    friend class RoutingPlugin;
+
     /**
      * Send a packet on a suitable interface.  This routine will
      * later free() the packet to pool.  This routine is not allowed to stall.
@@ -79,6 +77,8 @@ class Router : protected concurrency::OSThread
 
     /**
      * Should this incoming filter be dropped?
+     * 
+     * FIXME, move this into the new RoutingPlugin and do the filtering there using the regular plugin logic
      *
      * Called immedately on receiption, before any further processing.
      * @return true to abandon the packet
@@ -89,7 +89,7 @@ class Router : protected concurrency::OSThread
      * Every (non duplicate) packet this node receives will be passed through this method.  This allows subclasses to
      * update routing tables etc... based on what we overhear (even for messages not destined to our node)
      */
-    virtual void sniffReceived(const MeshPacket *p);
+    virtual void sniffReceived(const MeshPacket *p, const Routing *c);
 
     /**
      * Remove any encryption and decode the protobufs inside this packet (if necessary).
@@ -101,7 +101,7 @@ class Router : protected concurrency::OSThread
     /**
      * Send an ack or a nak packet back towards whoever sent idFrom
      */
-    void sendAckNak(ErrorReason err, NodeNum to, PacketId idFrom);
+    void sendAckNak(Routing_Error err, NodeNum to, PacketId idFrom);
     
   private:
     /**
@@ -123,6 +123,9 @@ class Router : protected concurrency::OSThread
      * Note: this method will free the provided packet.
      */
     void handleReceived(MeshPacket *p);
+
+    /** Frees the provided packet, and generates a NAK indicating the speicifed error while sending */
+    void abortSendAndNak(Routing_Error err, MeshPacket *p);
 };
 
 extern Router *router;

src/mesh/SinglePortPlugin.h

@@ -21,7 +21,7 @@ class SinglePortPlugin : public MeshPlugin
     /**
      * @return true if you want to receive the specified portnum
      */
-    virtual bool wantPortnum(PortNum p) { return p == ourPortNum; }
+    virtual bool wantPacket(const MeshPacket *p) { return p->decoded.portnum == ourPortNum; }
 
     /**
      * Return a mesh packet which has been preinited as a data packet with a particular port number.
@@ -32,8 +32,7 @@ class SinglePortPlugin : public MeshPlugin
     {
         // Update our local node info with our position (even if we don't decide to update anyone else)
         MeshPacket *p = router->allocForSending();
-        p->decoded.which_payloadVariant = SubPacket_data_tag;
-        p->decoded.data.portnum = ourPortNum;
+        p->decoded.portnum = ourPortNum;
 
         return p;
     }

src/mesh/generated/admin.pb.c

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

src/mesh/generated/admin.pb.h

@@ -0,0 +1,76 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.4 */
+
+#ifndef PB_ADMIN_PB_H_INCLUDED
+#define PB_ADMIN_PB_H_INCLUDED
+#include <pb.h>
+#include "mesh.pb.h"
+#include "radioconfig.pb.h"
+#include "channel.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _AdminMessage {
+    pb_size_t which_variant;
+    union {
+        RadioConfig set_radio;
+        User set_owner;
+        Channel set_channel;
+        bool get_radio_request;
+        RadioConfig get_radio_response;
+        uint32_t get_channel_request;
+        Channel get_channel_response;
+    };
+} AdminMessage;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define AdminMessage_init_default                {0, {RadioConfig_init_default}}
+#define AdminMessage_init_zero                   {0, {RadioConfig_init_zero}}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define AdminMessage_set_radio_tag               1
+#define AdminMessage_set_owner_tag               2
+#define AdminMessage_set_channel_tag             3
+#define AdminMessage_get_radio_request_tag       4
+#define AdminMessage_get_radio_response_tag      5
+#define AdminMessage_get_channel_request_tag     6
+#define AdminMessage_get_channel_response_tag    7
+
+/* Struct field encoding specification for nanopb */
+#define AdminMessage_FIELDLIST(X, a) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,set_radio,set_radio),   1) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,set_owner,set_owner),   2) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,set_channel,set_channel),   3) \
+X(a, STATIC,   ONEOF,    BOOL,     (variant,get_radio_request,get_radio_request),   4) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,get_radio_response,get_radio_response),   5) \
+X(a, STATIC,   ONEOF,    UINT32,   (variant,get_channel_request,get_channel_request),   6) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,get_channel_response,get_channel_response),   7)
+#define AdminMessage_CALLBACK NULL
+#define AdminMessage_DEFAULT NULL
+#define AdminMessage_variant_set_radio_MSGTYPE RadioConfig
+#define AdminMessage_variant_set_owner_MSGTYPE User
+#define AdminMessage_variant_set_channel_MSGTYPE Channel
+#define AdminMessage_variant_get_radio_response_MSGTYPE RadioConfig
+#define AdminMessage_variant_get_channel_response_MSGTYPE Channel
+
+extern const pb_msgdesc_t AdminMessage_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define AdminMessage_fields &AdminMessage_msg
+
+/* Maximum encoded size of messages (where known) */
+#define AdminMessage_size                        351
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/apponly.pb.c

@@ -9,4 +9,7 @@
 PB_BIND(ServiceEnvelope, ServiceEnvelope, 2)
 
 
+PB_BIND(ChannelSet, ChannelSet, AUTO)
+
+
 

src/mesh/generated/apponly.pb.h

@@ -5,12 +5,17 @@
 #define PB_APPONLY_PB_H_INCLUDED
 #include <pb.h>
 #include "mesh.pb.h"
+#include "channel.pb.h"
 
 #if PB_PROTO_HEADER_VERSION != 40
 #error Regenerate this file with the current version of nanopb generator.
 #endif
 
 /* Struct definitions */
+typedef struct _ChannelSet {
+    pb_callback_t settings;
+} ChannelSet;
+
 typedef struct _ServiceEnvelope {
     bool has_packet;
     MeshPacket packet;
@@ -25,9 +30,12 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define ServiceEnvelope_init_default             {false, MeshPacket_init_default, {{NULL}, NULL}, {{NULL}, NULL}}
+#define ChannelSet_init_default                  {{{NULL}, NULL}}
 #define ServiceEnvelope_init_zero                {false, MeshPacket_init_zero, {{NULL}, NULL}, {{NULL}, NULL}}
+#define ChannelSet_init_zero                     {{{NULL}, NULL}}
 
 /* Field tags (for use in manual encoding/decoding) */
+#define ChannelSet_settings_tag                  1
 #define ServiceEnvelope_packet_tag               1
 #define ServiceEnvelope_channel_id_tag           2
 #define ServiceEnvelope_gateway_id_tag           3
@@ -41,13 +49,22 @@ X(a, CALLBACK, SINGULAR, STRING,   gateway_id,        3)
 #define ServiceEnvelope_DEFAULT NULL
 #define ServiceEnvelope_packet_MSGTYPE MeshPacket
 
+#define ChannelSet_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  settings,          1)
+#define ChannelSet_CALLBACK pb_default_field_callback
+#define ChannelSet_DEFAULT NULL
+#define ChannelSet_settings_MSGTYPE ChannelSettings
+
 extern const pb_msgdesc_t ServiceEnvelope_msg;
+extern const pb_msgdesc_t ChannelSet_msg;
 
 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
 #define ServiceEnvelope_fields &ServiceEnvelope_msg
+#define ChannelSet_fields &ChannelSet_msg
 
 /* Maximum encoded size of messages (where known) */
 /* ServiceEnvelope_size depends on runtime parameters */
+/* ChannelSet_size depends on runtime parameters */
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/channel.pb.c

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

src/mesh/generated/channel.pb.h

@@ -0,0 +1,125 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.4 */
+
+#ifndef PB_CHANNEL_PB_H_INCLUDED
+#define PB_CHANNEL_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _ChannelSettings_ModemConfig {
+    ChannelSettings_ModemConfig_Bw125Cr45Sf128 = 0,
+    ChannelSettings_ModemConfig_Bw500Cr45Sf128 = 1,
+    ChannelSettings_ModemConfig_Bw31_25Cr48Sf512 = 2,
+    ChannelSettings_ModemConfig_Bw125Cr48Sf4096 = 3
+} ChannelSettings_ModemConfig;
+
+typedef enum _Channel_Role {
+    Channel_Role_DISABLED = 0,
+    Channel_Role_PRIMARY = 1,
+    Channel_Role_SECONDARY = 2
+} Channel_Role;
+
+/* Struct definitions */
+typedef PB_BYTES_ARRAY_T(32) ChannelSettings_psk_t;
+typedef struct _ChannelSettings {
+    int8_t tx_power;
+    ChannelSettings_ModemConfig modem_config;
+    ChannelSettings_psk_t psk;
+    char name[12];
+    uint16_t bandwidth;
+    uint32_t spread_factor;
+    uint8_t coding_rate;
+    uint8_t channel_num;
+    uint32_t id;
+    bool uplink_enabled;
+    bool downlink_enabled;
+} ChannelSettings;
+
+typedef struct _Channel {
+    uint8_t index;
+    bool has_settings;
+    ChannelSettings settings;
+    Channel_Role role;
+} Channel;
+
+
+/* Helper constants for enums */
+#define _ChannelSettings_ModemConfig_MIN ChannelSettings_ModemConfig_Bw125Cr45Sf128
+#define _ChannelSettings_ModemConfig_MAX ChannelSettings_ModemConfig_Bw125Cr48Sf4096
+#define _ChannelSettings_ModemConfig_ARRAYSIZE ((ChannelSettings_ModemConfig)(ChannelSettings_ModemConfig_Bw125Cr48Sf4096+1))
+
+#define _Channel_Role_MIN Channel_Role_DISABLED
+#define _Channel_Role_MAX Channel_Role_SECONDARY
+#define _Channel_Role_ARRAYSIZE ((Channel_Role)(Channel_Role_SECONDARY+1))
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define ChannelSettings_init_default             {0, _ChannelSettings_ModemConfig_MIN, {0, {0}}, "", 0, 0, 0, 0, 0, 0, 0}
+#define Channel_init_default                     {0, false, ChannelSettings_init_default, _Channel_Role_MIN}
+#define ChannelSettings_init_zero                {0, _ChannelSettings_ModemConfig_MIN, {0, {0}}, "", 0, 0, 0, 0, 0, 0, 0}
+#define Channel_init_zero                        {0, false, ChannelSettings_init_zero, _Channel_Role_MIN}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define ChannelSettings_tx_power_tag             1
+#define ChannelSettings_modem_config_tag         3
+#define ChannelSettings_psk_tag                  4
+#define ChannelSettings_name_tag                 5
+#define ChannelSettings_bandwidth_tag            6
+#define ChannelSettings_spread_factor_tag        7
+#define ChannelSettings_coding_rate_tag          8
+#define ChannelSettings_channel_num_tag          9
+#define ChannelSettings_id_tag                   10
+#define ChannelSettings_uplink_enabled_tag       16
+#define ChannelSettings_downlink_enabled_tag     17
+#define Channel_index_tag                        1
+#define Channel_settings_tag                     2
+#define Channel_role_tag                         3
+
+/* Struct field encoding specification for nanopb */
+#define ChannelSettings_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, INT32,    tx_power,          1) \
+X(a, STATIC,   SINGULAR, UENUM,    modem_config,      3) \
+X(a, STATIC,   SINGULAR, BYTES,    psk,               4) \
+X(a, STATIC,   SINGULAR, STRING,   name,              5) \
+X(a, STATIC,   SINGULAR, UINT32,   bandwidth,         6) \
+X(a, STATIC,   SINGULAR, UINT32,   spread_factor,     7) \
+X(a, STATIC,   SINGULAR, UINT32,   coding_rate,       8) \
+X(a, STATIC,   SINGULAR, UINT32,   channel_num,       9) \
+X(a, STATIC,   SINGULAR, FIXED32,  id,               10) \
+X(a, STATIC,   SINGULAR, BOOL,     uplink_enabled,   16) \
+X(a, STATIC,   SINGULAR, BOOL,     downlink_enabled,  17)
+#define ChannelSettings_CALLBACK NULL
+#define ChannelSettings_DEFAULT NULL
+
+#define Channel_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   index,             1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  settings,          2) \
+X(a, STATIC,   SINGULAR, UENUM,    role,              3)
+#define Channel_CALLBACK NULL
+#define Channel_DEFAULT NULL
+#define Channel_settings_MSGTYPE ChannelSettings
+
+extern const pb_msgdesc_t ChannelSettings_msg;
+extern const pb_msgdesc_t Channel_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define ChannelSettings_fields &ChannelSettings_msg
+#define Channel_fields &Channel_msg
+
+/* Maximum encoded size of messages (where known) */
+#define ChannelSettings_size                     87
+#define Channel_size                             94
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/deviceonly.pb.h

@@ -5,6 +5,8 @@
 #define PB_DEVICEONLY_PB_H_INCLUDED
 #include <pb.h>
 #include "mesh.pb.h"
+#include "radioconfig.pb.h"
+#include "channel.pb.h"
 
 #if PB_PROTO_HEADER_VERSION != 40
 #error Regenerate this file with the current version of nanopb generator.
@@ -27,8 +29,8 @@ typedef struct _DeviceState {
     uint32_t version;
     bool no_save;
     bool did_gps_reset;
-    pb_size_t secondary_channels_count;
-    ChannelSettings secondary_channels[7];
+    pb_size_t channels_count;
+    Channel channels[8];
 } DeviceState;
 
 
@@ -37,8 +39,8 @@ extern "C" {
 #endif
 
 /* Initializer values for message structs */
-#define DeviceState_init_default                 {false, RadioConfig_init_default, false, MyNodeInfo_init_default, false, User_init_default, 0, {NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default}, 0, {MeshPacket_init_default}, false, MeshPacket_init_default, 0, 0, 0, 0, {ChannelSettings_init_default, ChannelSettings_init_default, ChannelSettings_init_default, ChannelSettings_init_default, ChannelSettings_init_default, ChannelSettings_init_default, ChannelSettings_init_default}}
-#define DeviceState_init_zero                    {false, RadioConfig_init_zero, false, MyNodeInfo_init_zero, false, User_init_zero, 0, {NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero}, 0, {MeshPacket_init_zero}, false, MeshPacket_init_zero, 0, 0, 0, 0, {ChannelSettings_init_zero, ChannelSettings_init_zero, ChannelSettings_init_zero, ChannelSettings_init_zero, ChannelSettings_init_zero, ChannelSettings_init_zero, ChannelSettings_init_zero}}
+#define DeviceState_init_default                 {false, RadioConfig_init_default, false, MyNodeInfo_init_default, false, User_init_default, 0, {NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default}, 0, {MeshPacket_init_default}, false, MeshPacket_init_default, 0, 0, 0, 0, {Channel_init_default, Channel_init_default, Channel_init_default, Channel_init_default, Channel_init_default, Channel_init_default, Channel_init_default, Channel_init_default}}
+#define DeviceState_init_zero                    {false, RadioConfig_init_zero, false, MyNodeInfo_init_zero, false, User_init_zero, 0, {NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero}, 0, {MeshPacket_init_zero}, false, MeshPacket_init_zero, 0, 0, 0, 0, {Channel_init_zero, Channel_init_zero, Channel_init_zero, Channel_init_zero, Channel_init_zero, Channel_init_zero, Channel_init_zero, Channel_init_zero}}
 
 /* Field tags (for use in manual encoding/decoding) */
 #define DeviceState_radio_tag                    1
@@ -50,7 +52,7 @@ extern "C" {
 #define DeviceState_version_tag                  8
 #define DeviceState_no_save_tag                  9
 #define DeviceState_did_gps_reset_tag            11
-#define DeviceState_secondary_channels_tag       12
+#define DeviceState_channels_tag                 13
 
 /* Struct field encoding specification for nanopb */
 #define DeviceState_FIELDLIST(X, a) \
@@ -63,7 +65,7 @@ X(a, STATIC,   OPTIONAL, MESSAGE,  rx_text_message,   7) \
 X(a, STATIC,   SINGULAR, UINT32,   version,           8) \
 X(a, STATIC,   SINGULAR, BOOL,     no_save,           9) \
 X(a, STATIC,   SINGULAR, BOOL,     did_gps_reset,    11) \
-X(a, STATIC,   REPEATED, MESSAGE,  secondary_channels,  12)
+X(a, STATIC,   REPEATED, MESSAGE,  channels,         13)
 #define DeviceState_CALLBACK NULL
 #define DeviceState_DEFAULT NULL
 #define DeviceState_radio_MSGTYPE RadioConfig
@@ -72,7 +74,7 @@ X(a, STATIC,   REPEATED, MESSAGE,  secondary_channels,  12)
 #define DeviceState_node_db_MSGTYPE NodeInfo
 #define DeviceState_receive_queue_MSGTYPE MeshPacket
 #define DeviceState_rx_text_message_MSGTYPE MeshPacket
-#define DeviceState_secondary_channels_MSGTYPE ChannelSettings
+#define DeviceState_channels_MSGTYPE Channel
 
 extern const pb_msgdesc_t DeviceState_msg;
 
@@ -80,7 +82,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                         6169
 
 #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.c

@@ -9,30 +9,21 @@
 PB_BIND(Position, Position, AUTO)
 
 
-PB_BIND(Data, Data, AUTO)
-
-
 PB_BIND(User, User, AUTO)
 
 
 PB_BIND(RouteDiscovery, RouteDiscovery, AUTO)
 
 
-PB_BIND(SubPacket, SubPacket, 2)
+PB_BIND(Routing, Routing, AUTO)
+
+
+PB_BIND(Data, Data, 2)
 
 
 PB_BIND(MeshPacket, MeshPacket, 2)
 
 
-PB_BIND(ChannelSettings, ChannelSettings, AUTO)
-
-
-PB_BIND(RadioConfig, RadioConfig, 2)
-
-
-PB_BIND(RadioConfig_UserPreferences, RadioConfig_UserPreferences, 2)
-
-
 PB_BIND(NodeInfo, NodeInfo, AUTO)
 
 
@@ -54,8 +45,3 @@ PB_BIND(ToRadio, ToRadio, 2)
 
 
 
-
-
-
-
-

src/mesh/generated/mesh.pb.h

@@ -11,66 +11,11 @@
 #endif
 
 /* Enum definitions */
-typedef enum _ErrorReason {
-    ErrorReason_NONE = 0,
-    ErrorReason_NO_ROUTE = 1,
-    ErrorReason_GOT_NAK = 2,
-    ErrorReason_TIMEOUT = 3,
-    ErrorReason_NO_INTERFACE = 4,
-    ErrorReason_MAX_RETRANSMIT = 5
-} ErrorReason;
-
 typedef enum _Constants {
     Constants_Unused = 0,
     Constants_DATA_PAYLOAD_LEN = 240
 } Constants;
 
-typedef enum _RegionCode {
-    RegionCode_Unset = 0,
-    RegionCode_US = 1,
-    RegionCode_EU433 = 2,
-    RegionCode_EU865 = 3,
-    RegionCode_CN = 4,
-    RegionCode_JP = 5,
-    RegionCode_ANZ = 6,
-    RegionCode_KR = 7,
-    RegionCode_TW = 8
-} RegionCode;
-
-typedef enum _ChargeCurrent {
-    ChargeCurrent_MAUnset = 0,
-    ChargeCurrent_MA100 = 1,
-    ChargeCurrent_MA190 = 2,
-    ChargeCurrent_MA280 = 3,
-    ChargeCurrent_MA360 = 4,
-    ChargeCurrent_MA450 = 5,
-    ChargeCurrent_MA550 = 6,
-    ChargeCurrent_MA630 = 7,
-    ChargeCurrent_MA700 = 8,
-    ChargeCurrent_MA780 = 9,
-    ChargeCurrent_MA880 = 10,
-    ChargeCurrent_MA960 = 11,
-    ChargeCurrent_MA1000 = 12,
-    ChargeCurrent_MA1080 = 13,
-    ChargeCurrent_MA1160 = 14,
-    ChargeCurrent_MA1240 = 15,
-    ChargeCurrent_MA1320 = 16
-} ChargeCurrent;
-
-typedef enum _GpsOperation {
-    GpsOperation_GpsOpUnset = 0,
-    GpsOperation_GpsOpStationary = 1,
-    GpsOperation_GpsOpMobile = 2,
-    GpsOperation_GpsOpTimeOnly = 3,
-    GpsOperation_GpsOpDisabled = 4
-} GpsOperation;
-
-typedef enum _LocationSharing {
-    LocationSharing_LocUnset = 0,
-    LocationSharing_LocEnabled = 1,
-    LocationSharing_LocDisabled = 2
-} LocationSharing;
-
 typedef enum _CriticalErrorCode {
     CriticalErrorCode_None = 0,
     CriticalErrorCode_TxWatchdog = 1,
@@ -83,6 +28,17 @@ typedef enum _CriticalErrorCode {
     CriticalErrorCode_TransmitFailed = 8
 } CriticalErrorCode;
 
+typedef enum _Routing_Error {
+    Routing_Error_NONE = 0,
+    Routing_Error_NO_ROUTE = 1,
+    Routing_Error_GOT_NAK = 2,
+    Routing_Error_TIMEOUT = 3,
+    Routing_Error_NO_INTERFACE = 4,
+    Routing_Error_MAX_RETRANSMIT = 5,
+    Routing_Error_NO_CHANNEL = 6,
+    Routing_Error_TOO_LARGE = 7
+} Routing_Error;
+
 typedef enum _MeshPacket_Priority {
     MeshPacket_Priority_UNSET = 0,
     MeshPacket_Priority_MIN = 1,
@@ -93,13 +49,6 @@ typedef enum _MeshPacket_Priority {
     MeshPacket_Priority_MAX = 127
 } MeshPacket_Priority;
 
-typedef enum _ChannelSettings_ModemConfig {
-    ChannelSettings_ModemConfig_Bw125Cr45Sf128 = 0,
-    ChannelSettings_ModemConfig_Bw500Cr45Sf128 = 1,
-    ChannelSettings_ModemConfig_Bw31_25Cr48Sf512 = 2,
-    ChannelSettings_ModemConfig_Bw125Cr48Sf4096 = 3
-} ChannelSettings_ModemConfig;
-
 typedef enum _LogRecord_Level {
     LogRecord_Level_UNSET = 0,
     LogRecord_Level_CRITICAL = 50,
@@ -111,25 +60,14 @@ typedef enum _LogRecord_Level {
 } LogRecord_Level;
 
 /* Struct definitions */
-typedef PB_BYTES_ARRAY_T(32) ChannelSettings_psk_t;
-typedef struct _ChannelSettings {
-    int32_t tx_power;
-    ChannelSettings_ModemConfig modem_config;
-    ChannelSettings_psk_t psk;
-    char name[12];
-    uint32_t bandwidth;
-    uint32_t spread_factor;
-    uint32_t coding_rate;
-    uint32_t channel_num;
-    uint32_t id;
-    bool uplink_enabled;
-    bool downlink_enabled;
-} ChannelSettings;
-
-typedef PB_BYTES_ARRAY_T(240) Data_payload_t;
+typedef PB_BYTES_ARRAY_T(237) Data_payload_t;
 typedef struct _Data {
     PortNum portnum;
     Data_payload_t payload;
+    bool want_response;
+    uint32_t dest;
+    uint32_t source;
+    uint32_t request_id;
 } Data;
 
 typedef struct _LogRecord {
@@ -142,77 +80,29 @@ typedef struct _LogRecord {
 typedef struct _MyNodeInfo {
     uint32_t my_node_num;
     bool has_gps;
-    int32_t num_channels;
+    uint32_t num_bands;
     char region[12];
     char hw_model[16];
     char firmware_version[12];
     CriticalErrorCode error_code;
     uint32_t error_address;
     uint32_t error_count;
-    uint32_t packet_id_bits;
-    uint32_t current_packet_id;
-    uint32_t node_num_bits;
     uint32_t message_timeout_msec;
     uint32_t min_app_version;
+    uint32_t max_channels;
 } MyNodeInfo;
 
 typedef struct _Position {
-    int32_t altitude;
-    int32_t battery_level;
     int32_t latitude_i;
     int32_t longitude_i;
+    int32_t altitude;
+    int32_t battery_level;
     uint32_t time;
 } Position;
 
-typedef struct _RadioConfig_UserPreferences {
-    uint32_t position_broadcast_secs;
-    uint32_t send_owner_interval;
-    uint32_t wait_bluetooth_secs;
-    uint32_t screen_on_secs;
-    uint32_t phone_timeout_secs;
-    uint32_t phone_sds_timeout_sec;
-    uint32_t mesh_sds_timeout_secs;
-    uint32_t sds_secs;
-    uint32_t ls_secs;
-    uint32_t min_wake_secs;
-    char wifi_ssid[33];
-    char wifi_password[64];
-    bool wifi_ap_mode;
-    RegionCode region;
-    ChargeCurrent charge_current;
-    LocationSharing location_share;
-    GpsOperation gps_operation;
-    uint32_t gps_update_interval;
-    uint32_t gps_attempt_time;
-    bool is_router;
-    bool is_low_power;
-    bool fixed_position;
-    bool factory_reset;
-    bool debug_log_enabled;
-    pb_size_t ignore_incoming_count;
-    uint32_t ignore_incoming[3];
-    bool serialplugin_enabled;
-    bool serialplugin_echo;
-    uint32_t serialplugin_rxd;
-    uint32_t serialplugin_txd;
-    uint32_t serialplugin_timeout;
-    uint32_t serialplugin_mode;
-    bool ext_notification_plugin_enabled;
-    uint32_t ext_notification_plugin_output_ms;
-    uint32_t ext_notification_plugin_output;
-    bool ext_notification_plugin_active;
-    bool ext_notification_plugin_alert_message;
-    bool ext_notification_plugin_alert_bell;
-    bool range_test_plugin_enabled;
-    uint32_t range_test_plugin_sender;
-    bool range_test_plugin_save;
-    bool store_forward_plugin_enabled;
-    uint32_t store_forward_plugin_records;
-} RadioConfig_UserPreferences;
-
 typedef struct _RouteDiscovery {
     pb_size_t route_count;
-    int32_t route[8];
+    uint32_t route[8];
 } RouteDiscovery;
 
 typedef struct _User {
@@ -222,6 +112,24 @@ typedef struct _User {
     pb_byte_t macaddr[6];
 } User;
 
+typedef PB_BYTES_ARRAY_T(256) MeshPacket_encrypted_t;
+typedef struct _MeshPacket {
+    uint32_t from;
+    uint32_t to;
+    uint8_t channel;
+    pb_size_t which_payloadVariant;
+    union {
+        Data decoded;
+        MeshPacket_encrypted_t encrypted;
+    };
+    uint32_t id;
+    uint32_t rx_time;
+    float rx_snr;
+    uint8_t hop_limit;
+    bool want_ack;
+    MeshPacket_Priority priority;
+} MeshPacket;
+
 typedef struct _NodeInfo {
     uint32_t num;
     bool has_user;
@@ -232,64 +140,25 @@ typedef struct _NodeInfo {
     float snr;
 } NodeInfo;
 
-typedef struct _RadioConfig {
-    bool has_preferences;
-    RadioConfig_UserPreferences preferences;
-    bool has_channel_settings;
-    ChannelSettings channel_settings;
-} RadioConfig;
-
-typedef struct _SubPacket {
-    pb_size_t which_payloadVariant;
+typedef struct _Routing {
+    pb_size_t which_variant;
     union {
-        Position position;
-        Data data;
-        User user;
         RouteDiscovery route_request;
         RouteDiscovery route_reply;
-        ErrorReason error_reason;
+        Routing_Error error_reason;
     };
-    uint32_t original_id;
-    bool want_response;
-    uint32_t dest;
-    pb_size_t which_ackVariant;
-    union {
-        uint32_t success_id;
-        uint32_t fail_id;
-    } ackVariant;
-    uint32_t source;
-} SubPacket;
-
-typedef PB_BYTES_ARRAY_T(256) MeshPacket_encrypted_t;
-typedef struct _MeshPacket {
-    uint32_t from;
-    uint32_t to;
-    pb_size_t which_payloadVariant;
-    union {
-        SubPacket decoded;
-        MeshPacket_encrypted_t encrypted;
-    };
-    uint32_t channel_index;
-    uint32_t id;
-    float rx_snr;
-    uint32_t rx_time;
-    uint32_t hop_limit;
-    bool want_ack;
-    MeshPacket_Priority priority;
-} MeshPacket;
+} Routing;
 
 typedef struct _FromRadio {
     uint32_t num;
     pb_size_t which_payloadVariant;
     union {
-        MeshPacket packet;
         MyNodeInfo my_info;
         NodeInfo node_info;
-        RadioConfig radio;
         LogRecord log_record;
         uint32_t config_complete_id;
         bool rebooted;
-        ChannelSettings channel;
+        MeshPacket packet;
     };
 } FromRadio;
 
@@ -298,50 +167,27 @@ typedef struct _ToRadio {
     union {
         MeshPacket packet;
         uint32_t want_config_id;
-        RadioConfig set_radio;
-        User set_owner;
-        ChannelSettings set_channel;
     };
 } ToRadio;
 
 
 /* Helper constants for enums */
-#define _ErrorReason_MIN ErrorReason_NONE
-#define _ErrorReason_MAX ErrorReason_MAX_RETRANSMIT
-#define _ErrorReason_ARRAYSIZE ((ErrorReason)(ErrorReason_MAX_RETRANSMIT+1))
-
 #define _Constants_MIN Constants_Unused
 #define _Constants_MAX Constants_DATA_PAYLOAD_LEN
 #define _Constants_ARRAYSIZE ((Constants)(Constants_DATA_PAYLOAD_LEN+1))
 
-#define _RegionCode_MIN RegionCode_Unset
-#define _RegionCode_MAX RegionCode_TW
-#define _RegionCode_ARRAYSIZE ((RegionCode)(RegionCode_TW+1))
-
-#define _ChargeCurrent_MIN ChargeCurrent_MAUnset
-#define _ChargeCurrent_MAX ChargeCurrent_MA1320
-#define _ChargeCurrent_ARRAYSIZE ((ChargeCurrent)(ChargeCurrent_MA1320+1))
-
-#define _GpsOperation_MIN GpsOperation_GpsOpUnset
-#define _GpsOperation_MAX GpsOperation_GpsOpDisabled
-#define _GpsOperation_ARRAYSIZE ((GpsOperation)(GpsOperation_GpsOpDisabled+1))
-
-#define _LocationSharing_MIN LocationSharing_LocUnset
-#define _LocationSharing_MAX LocationSharing_LocDisabled
-#define _LocationSharing_ARRAYSIZE ((LocationSharing)(LocationSharing_LocDisabled+1))
-
 #define _CriticalErrorCode_MIN CriticalErrorCode_None
 #define _CriticalErrorCode_MAX CriticalErrorCode_TransmitFailed
 #define _CriticalErrorCode_ARRAYSIZE ((CriticalErrorCode)(CriticalErrorCode_TransmitFailed+1))
 
+#define _Routing_Error_MIN Routing_Error_NONE
+#define _Routing_Error_MAX Routing_Error_TOO_LARGE
+#define _Routing_Error_ARRAYSIZE ((Routing_Error)(Routing_Error_TOO_LARGE+1))
+
 #define _MeshPacket_Priority_MIN MeshPacket_Priority_UNSET
 #define _MeshPacket_Priority_MAX MeshPacket_Priority_MAX
 #define _MeshPacket_Priority_ARRAYSIZE ((MeshPacket_Priority)(MeshPacket_Priority_MAX+1))
 
-#define _ChannelSettings_ModemConfig_MIN ChannelSettings_ModemConfig_Bw125Cr45Sf128
-#define _ChannelSettings_ModemConfig_MAX ChannelSettings_ModemConfig_Bw125Cr48Sf4096
-#define _ChannelSettings_ModemConfig_ARRAYSIZE ((ChannelSettings_ModemConfig)(ChannelSettings_ModemConfig_Bw125Cr48Sf4096+1))
-
 #define _LogRecord_Level_MIN LogRecord_Level_UNSET
 #define _LogRecord_Level_MAX LogRecord_Level_CRITICAL
 #define _LogRecord_Level_ARRAYSIZE ((LogRecord_Level)(LogRecord_Level_CRITICAL+1))
@@ -353,179 +199,100 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define Position_init_default                    {0, 0, 0, 0, 0}
-#define Data_init_default                        {_PortNum_MIN, {0, {0}}}
 #define User_init_default                        {"", "", "", {0}}
 #define RouteDiscovery_init_default              {0, {0, 0, 0, 0, 0, 0, 0, 0}}
-#define SubPacket_init_default                   {0, {Position_init_default}, 0, 0, 0, 0, {0}, 0}
-#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 Routing_init_default                     {0, {RouteDiscovery_init_default}}
+#define Data_init_default                        {_PortNum_MIN, {0, {0}}, 0, 0, 0, 0}
+#define MeshPacket_init_default                  {0, 0, 0, 0, {Data_init_default}, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN}
 #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 MyNodeInfo_init_default                  {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0}
 #define LogRecord_init_default                   {"", 0, "", _LogRecord_Level_MIN}
-#define FromRadio_init_default                   {0, 0, {MeshPacket_init_default}}
+#define FromRadio_init_default                   {0, 0, {MyNodeInfo_init_default}}
 #define ToRadio_init_default                     {0, {MeshPacket_init_default}}
 #define Position_init_zero                       {0, 0, 0, 0, 0}
-#define Data_init_zero                           {_PortNum_MIN, {0, {0}}}
 #define User_init_zero                           {"", "", "", {0}}
 #define RouteDiscovery_init_zero                 {0, {0, 0, 0, 0, 0, 0, 0, 0}}
-#define SubPacket_init_zero                      {0, {Position_init_zero}, 0, 0, 0, 0, {0}, 0}
-#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 Routing_init_zero                        {0, {RouteDiscovery_init_zero}}
+#define Data_init_zero                           {_PortNum_MIN, {0, {0}}, 0, 0, 0, 0}
+#define MeshPacket_init_zero                     {0, 0, 0, 0, {Data_init_zero}, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN}
 #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 MyNodeInfo_init_zero                     {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0}
 #define LogRecord_init_zero                      {"", 0, "", _LogRecord_Level_MIN}
-#define FromRadio_init_zero                      {0, 0, {MeshPacket_init_zero}}
+#define FromRadio_init_zero                      {0, 0, {MyNodeInfo_init_zero}}
 #define ToRadio_init_zero                        {0, {MeshPacket_init_zero}}
 
 /* Field tags (for use in manual encoding/decoding) */
-#define ChannelSettings_tx_power_tag             1
-#define ChannelSettings_modem_config_tag         3
-#define ChannelSettings_psk_tag                  4
-#define ChannelSettings_name_tag                 5
-#define ChannelSettings_bandwidth_tag            6
-#define ChannelSettings_spread_factor_tag        7
-#define ChannelSettings_coding_rate_tag          8
-#define ChannelSettings_channel_num_tag          9
-#define ChannelSettings_id_tag                   10
-#define ChannelSettings_uplink_enabled_tag       16
-#define ChannelSettings_downlink_enabled_tag     17
 #define Data_portnum_tag                         1
 #define Data_payload_tag                         2
+#define Data_want_response_tag                   3
+#define Data_dest_tag                            4
+#define Data_source_tag                          5
+#define Data_request_id_tag                      6
 #define LogRecord_message_tag                    1
 #define LogRecord_time_tag                       2
 #define LogRecord_source_tag                     3
 #define LogRecord_level_tag                      4
 #define MyNodeInfo_my_node_num_tag               1
 #define MyNodeInfo_has_gps_tag                   2
-#define MyNodeInfo_num_channels_tag              3
+#define MyNodeInfo_num_bands_tag                 3
 #define MyNodeInfo_region_tag                    4
 #define MyNodeInfo_hw_model_tag                  5
 #define MyNodeInfo_firmware_version_tag          6
 #define MyNodeInfo_error_code_tag                7
 #define MyNodeInfo_error_address_tag             8
 #define MyNodeInfo_error_count_tag               9
-#define MyNodeInfo_packet_id_bits_tag            10
-#define MyNodeInfo_current_packet_id_tag         11
-#define MyNodeInfo_node_num_bits_tag             12
 #define MyNodeInfo_message_timeout_msec_tag      13
 #define MyNodeInfo_min_app_version_tag           14
+#define MyNodeInfo_max_channels_tag              15
+#define Position_latitude_i_tag                  1
+#define Position_longitude_i_tag                 2
 #define Position_altitude_tag                    3
 #define Position_battery_level_tag               4
-#define Position_latitude_i_tag                  7
-#define Position_longitude_i_tag                 8
 #define Position_time_tag                        9
-#define RadioConfig_UserPreferences_position_broadcast_secs_tag 1
-#define RadioConfig_UserPreferences_send_owner_interval_tag 2
-#define RadioConfig_UserPreferences_wait_bluetooth_secs_tag 4
-#define RadioConfig_UserPreferences_screen_on_secs_tag 5
-#define RadioConfig_UserPreferences_phone_timeout_secs_tag 6
-#define RadioConfig_UserPreferences_phone_sds_timeout_sec_tag 7
-#define RadioConfig_UserPreferences_mesh_sds_timeout_secs_tag 8
-#define RadioConfig_UserPreferences_sds_secs_tag 9
-#define RadioConfig_UserPreferences_ls_secs_tag  10
-#define RadioConfig_UserPreferences_min_wake_secs_tag 11
-#define RadioConfig_UserPreferences_wifi_ssid_tag 12
-#define RadioConfig_UserPreferences_wifi_password_tag 13
-#define RadioConfig_UserPreferences_wifi_ap_mode_tag 14
-#define RadioConfig_UserPreferences_region_tag   15
-#define RadioConfig_UserPreferences_charge_current_tag 16
-#define RadioConfig_UserPreferences_location_share_tag 32
-#define RadioConfig_UserPreferences_gps_operation_tag 33
-#define RadioConfig_UserPreferences_gps_update_interval_tag 34
-#define RadioConfig_UserPreferences_gps_attempt_time_tag 36
-#define RadioConfig_UserPreferences_is_router_tag 37
-#define RadioConfig_UserPreferences_is_low_power_tag 38
-#define RadioConfig_UserPreferences_fixed_position_tag 39
-#define RadioConfig_UserPreferences_factory_reset_tag 100
-#define RadioConfig_UserPreferences_debug_log_enabled_tag 101
-#define RadioConfig_UserPreferences_ignore_incoming_tag 103
-#define RadioConfig_UserPreferences_serialplugin_enabled_tag 120
-#define RadioConfig_UserPreferences_serialplugin_echo_tag 121
-#define RadioConfig_UserPreferences_serialplugin_rxd_tag 122
-#define RadioConfig_UserPreferences_serialplugin_txd_tag 123
-#define RadioConfig_UserPreferences_serialplugin_timeout_tag 124
-#define RadioConfig_UserPreferences_serialplugin_mode_tag 125
-#define RadioConfig_UserPreferences_ext_notification_plugin_enabled_tag 126
-#define RadioConfig_UserPreferences_ext_notification_plugin_output_ms_tag 127
-#define RadioConfig_UserPreferences_ext_notification_plugin_output_tag 128
-#define RadioConfig_UserPreferences_ext_notification_plugin_active_tag 129
-#define RadioConfig_UserPreferences_ext_notification_plugin_alert_message_tag 130
-#define RadioConfig_UserPreferences_ext_notification_plugin_alert_bell_tag 131
-#define RadioConfig_UserPreferences_range_test_plugin_enabled_tag 132
-#define RadioConfig_UserPreferences_range_test_plugin_sender_tag 133
-#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 RouteDiscovery_route_tag                 2
 #define User_id_tag                              1
 #define User_long_name_tag                       2
 #define User_short_name_tag                      3
 #define User_macaddr_tag                         4
+#define MeshPacket_from_tag                      1
+#define MeshPacket_to_tag                        2
+#define MeshPacket_channel_tag                   3
+#define MeshPacket_decoded_tag                   4
+#define MeshPacket_encrypted_tag                 5
+#define MeshPacket_id_tag                        6
+#define MeshPacket_rx_time_tag                   7
+#define MeshPacket_rx_snr_tag                    8
+#define MeshPacket_hop_limit_tag                 10
+#define MeshPacket_want_ack_tag                  11
+#define MeshPacket_priority_tag                  12
 #define NodeInfo_num_tag                         1
 #define NodeInfo_user_tag                        2
 #define NodeInfo_position_tag                    3
 #define NodeInfo_next_hop_tag                    5
 #define NodeInfo_snr_tag                         7
-#define RadioConfig_preferences_tag              1
-#define RadioConfig_channel_settings_tag         2
-#define SubPacket_position_tag                   1
-#define SubPacket_data_tag                       3
-#define SubPacket_user_tag                       4
-#define SubPacket_route_request_tag              6
-#define SubPacket_route_reply_tag                7
-#define SubPacket_error_reason_tag               13
-#define SubPacket_original_id_tag                2
-#define SubPacket_want_response_tag              5
-#define SubPacket_dest_tag                       9
-#define SubPacket_success_id_tag                 10
-#define SubPacket_fail_id_tag                    11
-#define SubPacket_source_tag                     12
-#define MeshPacket_from_tag                      1
-#define MeshPacket_to_tag                        2
-#define MeshPacket_decoded_tag                   3
-#define MeshPacket_encrypted_tag                 8
-#define MeshPacket_channel_index_tag             4
-#define MeshPacket_id_tag                        6
-#define MeshPacket_rx_snr_tag                    7
-#define MeshPacket_rx_time_tag                   9
-#define MeshPacket_hop_limit_tag                 10
-#define MeshPacket_want_ack_tag                  11
-#define MeshPacket_priority_tag                  12
+#define Routing_route_request_tag                1
+#define Routing_route_reply_tag                  2
+#define Routing_error_reason_tag                 3
 #define FromRadio_num_tag                        1
-#define FromRadio_packet_tag                     2
 #define FromRadio_my_info_tag                    3
 #define FromRadio_node_info_tag                  4
-#define FromRadio_radio_tag                      6
 #define FromRadio_log_record_tag                 7
 #define FromRadio_config_complete_id_tag         8
 #define FromRadio_rebooted_tag                   9
-#define FromRadio_channel_tag                    10
-#define ToRadio_packet_tag                       1
+#define FromRadio_packet_tag                     11
+#define ToRadio_packet_tag                       2
 #define ToRadio_want_config_id_tag               100
-#define ToRadio_set_radio_tag                    101
-#define ToRadio_set_owner_tag                    102
-#define ToRadio_set_channel_tag                  103
 
 /* Struct field encoding specification for nanopb */
 #define Position_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, SFIXED32, latitude_i,        1) \
+X(a, STATIC,   SINGULAR, SFIXED32, longitude_i,       2) \
 X(a, STATIC,   SINGULAR, INT32,    altitude,          3) \
 X(a, STATIC,   SINGULAR, INT32,    battery_level,     4) \
-X(a, STATIC,   SINGULAR, SINT32,   latitude_i,        7) \
-X(a, STATIC,   SINGULAR, SINT32,   longitude_i,       8) \
 X(a, STATIC,   SINGULAR, FIXED32,  time,              9)
 #define Position_CALLBACK NULL
 #define Position_DEFAULT NULL
 
-#define Data_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UENUM,    portnum,           1) \
-X(a, STATIC,   SINGULAR, BYTES,    payload,           2)
-#define Data_CALLBACK NULL
-#define Data_DEFAULT NULL
-
 #define User_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, STRING,   id,                1) \
 X(a, STATIC,   SINGULAR, STRING,   long_name,         2) \
@@ -535,115 +302,44 @@ X(a, STATIC,   SINGULAR, FIXED_LENGTH_BYTES, macaddr,           4)
 #define User_DEFAULT NULL
 
 #define RouteDiscovery_FIELDLIST(X, a) \
-X(a, STATIC,   REPEATED, INT32,    route,             2)
+X(a, STATIC,   REPEATED, FIXED32,  route,             2)
 #define RouteDiscovery_CALLBACK NULL
 #define RouteDiscovery_DEFAULT NULL
 
-#define SubPacket_FIELDLIST(X, a) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,position,position),   1) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,data,data),   3) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,user,user),   4) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,route_request,route_request),   6) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,route_reply,route_reply),   7) \
-X(a, STATIC,   ONEOF,    UENUM,    (payloadVariant,error_reason,error_reason),  13) \
-X(a, STATIC,   SINGULAR, UINT32,   original_id,       2) \
-X(a, STATIC,   SINGULAR, BOOL,     want_response,     5) \
-X(a, STATIC,   SINGULAR, UINT32,   dest,              9) \
-X(a, STATIC,   ONEOF,    UINT32,   (ackVariant,success_id,ackVariant.success_id),  10) \
-X(a, STATIC,   ONEOF,    UINT32,   (ackVariant,fail_id,ackVariant.fail_id),  11) \
-X(a, STATIC,   SINGULAR, UINT32,   source,           12)
-#define SubPacket_CALLBACK NULL
-#define SubPacket_DEFAULT NULL
-#define SubPacket_payloadVariant_position_MSGTYPE Position
-#define SubPacket_payloadVariant_data_MSGTYPE Data
-#define SubPacket_payloadVariant_user_MSGTYPE User
-#define SubPacket_payloadVariant_route_request_MSGTYPE RouteDiscovery
-#define SubPacket_payloadVariant_route_reply_MSGTYPE RouteDiscovery
+#define Routing_FIELDLIST(X, a) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,route_request,route_request),   1) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,route_reply,route_reply),   2) \
+X(a, STATIC,   ONEOF,    UENUM,    (variant,error_reason,error_reason),   3)
+#define Routing_CALLBACK NULL
+#define Routing_DEFAULT NULL
+#define Routing_variant_route_request_MSGTYPE RouteDiscovery
+#define Routing_variant_route_reply_MSGTYPE RouteDiscovery
+
+#define Data_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UENUM,    portnum,           1) \
+X(a, STATIC,   SINGULAR, BYTES,    payload,           2) \
+X(a, STATIC,   SINGULAR, BOOL,     want_response,     3) \
+X(a, STATIC,   SINGULAR, FIXED32,  dest,              4) \
+X(a, STATIC,   SINGULAR, FIXED32,  source,            5) \
+X(a, STATIC,   SINGULAR, FIXED32,  request_id,        6)
+#define Data_CALLBACK NULL
+#define Data_DEFAULT NULL
 
 #define MeshPacket_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UINT32,   from,              1) \
-X(a, STATIC,   SINGULAR, UINT32,   to,                2) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,decoded,decoded),   3) \
-X(a, STATIC,   ONEOF,    BYTES,    (payloadVariant,encrypted,encrypted),   8) \
-X(a, STATIC,   SINGULAR, UINT32,   channel_index,     4) \
-X(a, STATIC,   SINGULAR, UINT32,   id,                6) \
-X(a, STATIC,   SINGULAR, FLOAT,    rx_snr,            7) \
-X(a, STATIC,   SINGULAR, FIXED32,  rx_time,           9) \
+X(a, STATIC,   SINGULAR, FIXED32,  from,              1) \
+X(a, STATIC,   SINGULAR, FIXED32,  to,                2) \
+X(a, STATIC,   SINGULAR, UINT32,   channel,           3) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,decoded,decoded),   4) \
+X(a, STATIC,   ONEOF,    BYTES,    (payloadVariant,encrypted,encrypted),   5) \
+X(a, STATIC,   SINGULAR, FIXED32,  id,                6) \
+X(a, STATIC,   SINGULAR, FIXED32,  rx_time,           7) \
+X(a, STATIC,   SINGULAR, FLOAT,    rx_snr,            8) \
 X(a, STATIC,   SINGULAR, UINT32,   hop_limit,        10) \
 X(a, STATIC,   SINGULAR, BOOL,     want_ack,         11) \
 X(a, STATIC,   SINGULAR, UENUM,    priority,         12)
 #define MeshPacket_CALLBACK NULL
 #define MeshPacket_DEFAULT NULL
-#define MeshPacket_payloadVariant_decoded_MSGTYPE SubPacket
-
-#define ChannelSettings_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, INT32,    tx_power,          1) \
-X(a, STATIC,   SINGULAR, UENUM,    modem_config,      3) \
-X(a, STATIC,   SINGULAR, BYTES,    psk,               4) \
-X(a, STATIC,   SINGULAR, STRING,   name,              5) \
-X(a, STATIC,   SINGULAR, UINT32,   bandwidth,         6) \
-X(a, STATIC,   SINGULAR, UINT32,   spread_factor,     7) \
-X(a, STATIC,   SINGULAR, UINT32,   coding_rate,       8) \
-X(a, STATIC,   SINGULAR, UINT32,   channel_num,       9) \
-X(a, STATIC,   SINGULAR, FIXED32,  id,               10) \
-X(a, STATIC,   SINGULAR, BOOL,     uplink_enabled,   16) \
-X(a, STATIC,   SINGULAR, BOOL,     downlink_enabled,  17)
-#define ChannelSettings_CALLBACK NULL
-#define ChannelSettings_DEFAULT NULL
-
-#define RadioConfig_FIELDLIST(X, a) \
-X(a, STATIC,   OPTIONAL, MESSAGE,  preferences,       1) \
-X(a, STATIC,   OPTIONAL, MESSAGE,  channel_settings,   2)
-#define RadioConfig_CALLBACK NULL
-#define RadioConfig_DEFAULT NULL
-#define RadioConfig_preferences_MSGTYPE RadioConfig_UserPreferences
-#define RadioConfig_channel_settings_MSGTYPE ChannelSettings
-
-#define RadioConfig_UserPreferences_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UINT32,   position_broadcast_secs,   1) \
-X(a, STATIC,   SINGULAR, UINT32,   send_owner_interval,   2) \
-X(a, STATIC,   SINGULAR, UINT32,   wait_bluetooth_secs,   4) \
-X(a, STATIC,   SINGULAR, UINT32,   screen_on_secs,    5) \
-X(a, STATIC,   SINGULAR, UINT32,   phone_timeout_secs,   6) \
-X(a, STATIC,   SINGULAR, UINT32,   phone_sds_timeout_sec,   7) \
-X(a, STATIC,   SINGULAR, UINT32,   mesh_sds_timeout_secs,   8) \
-X(a, STATIC,   SINGULAR, UINT32,   sds_secs,          9) \
-X(a, STATIC,   SINGULAR, UINT32,   ls_secs,          10) \
-X(a, STATIC,   SINGULAR, UINT32,   min_wake_secs,    11) \
-X(a, STATIC,   SINGULAR, STRING,   wifi_ssid,        12) \
-X(a, STATIC,   SINGULAR, STRING,   wifi_password,    13) \
-X(a, STATIC,   SINGULAR, BOOL,     wifi_ap_mode,     14) \
-X(a, STATIC,   SINGULAR, UENUM,    region,           15) \
-X(a, STATIC,   SINGULAR, UENUM,    charge_current,   16) \
-X(a, STATIC,   SINGULAR, UENUM,    location_share,   32) \
-X(a, STATIC,   SINGULAR, UENUM,    gps_operation,    33) \
-X(a, STATIC,   SINGULAR, UINT32,   gps_update_interval,  34) \
-X(a, STATIC,   SINGULAR, UINT32,   gps_attempt_time,  36) \
-X(a, STATIC,   SINGULAR, BOOL,     is_router,        37) \
-X(a, STATIC,   SINGULAR, BOOL,     is_low_power,     38) \
-X(a, STATIC,   SINGULAR, BOOL,     fixed_position,   39) \
-X(a, STATIC,   SINGULAR, BOOL,     factory_reset,   100) \
-X(a, STATIC,   SINGULAR, BOOL,     debug_log_enabled, 101) \
-X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103) \
-X(a, STATIC,   SINGULAR, BOOL,     serialplugin_enabled, 120) \
-X(a, STATIC,   SINGULAR, BOOL,     serialplugin_echo, 121) \
-X(a, STATIC,   SINGULAR, UINT32,   serialplugin_rxd, 122) \
-X(a, STATIC,   SINGULAR, UINT32,   serialplugin_txd, 123) \
-X(a, STATIC,   SINGULAR, UINT32,   serialplugin_timeout, 124) \
-X(a, STATIC,   SINGULAR, UINT32,   serialplugin_mode, 125) \
-X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_enabled, 126) \
-X(a, STATIC,   SINGULAR, UINT32,   ext_notification_plugin_output_ms, 127) \
-X(a, STATIC,   SINGULAR, UINT32,   ext_notification_plugin_output, 128) \
-X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_active, 129) \
-X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_alert_message, 130) \
-X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_alert_bell, 131) \
-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)
-#define RadioConfig_UserPreferences_CALLBACK NULL
-#define RadioConfig_UserPreferences_DEFAULT NULL
+#define MeshPacket_payloadVariant_decoded_MSGTYPE Data
 
 #define NodeInfo_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
@@ -659,18 +355,16 @@ X(a, STATIC,   SINGULAR, FLOAT,    snr,               7)
 #define MyNodeInfo_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   my_node_num,       1) \
 X(a, STATIC,   SINGULAR, BOOL,     has_gps,           2) \
-X(a, STATIC,   SINGULAR, INT32,    num_channels,      3) \
+X(a, STATIC,   SINGULAR, UINT32,   num_bands,         3) \
 X(a, STATIC,   SINGULAR, STRING,   region,            4) \
 X(a, STATIC,   SINGULAR, STRING,   hw_model,          5) \
 X(a, STATIC,   SINGULAR, STRING,   firmware_version,   6) \
 X(a, STATIC,   SINGULAR, UENUM,    error_code,        7) \
 X(a, STATIC,   SINGULAR, UINT32,   error_address,     8) \
 X(a, STATIC,   SINGULAR, UINT32,   error_count,       9) \
-X(a, STATIC,   SINGULAR, UINT32,   packet_id_bits,   10) \
-X(a, STATIC,   SINGULAR, UINT32,   current_packet_id,  11) \
-X(a, STATIC,   SINGULAR, UINT32,   node_num_bits,    12) \
 X(a, STATIC,   SINGULAR, UINT32,   message_timeout_msec,  13) \
-X(a, STATIC,   SINGULAR, UINT32,   min_app_version,  14)
+X(a, STATIC,   SINGULAR, UINT32,   min_app_version,  14) \
+X(a, STATIC,   SINGULAR, UINT32,   max_channels,     15)
 #define MyNodeInfo_CALLBACK NULL
 #define MyNodeInfo_DEFAULT NULL
 
@@ -684,45 +378,32 @@ X(a, STATIC,   SINGULAR, UENUM,    level,             4)
 
 #define FromRadio_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,packet,packet),   2) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,my_info,my_info),   3) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,node_info,node_info),   4) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,radio,radio),   6) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,log_record,log_record),   7) \
 X(a, STATIC,   ONEOF,    UINT32,   (payloadVariant,config_complete_id,config_complete_id),   8) \
 X(a, STATIC,   ONEOF,    BOOL,     (payloadVariant,rebooted,rebooted),   9) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,channel,channel),  10)
+X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,packet,packet),  11)
 #define FromRadio_CALLBACK NULL
 #define FromRadio_DEFAULT NULL
-#define FromRadio_payloadVariant_packet_MSGTYPE MeshPacket
 #define FromRadio_payloadVariant_my_info_MSGTYPE MyNodeInfo
 #define FromRadio_payloadVariant_node_info_MSGTYPE NodeInfo
-#define FromRadio_payloadVariant_radio_MSGTYPE RadioConfig
 #define FromRadio_payloadVariant_log_record_MSGTYPE LogRecord
-#define FromRadio_payloadVariant_channel_MSGTYPE ChannelSettings
+#define FromRadio_payloadVariant_packet_MSGTYPE MeshPacket
 
 #define ToRadio_FIELDLIST(X, a) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,packet,packet),   1) \
-X(a, STATIC,   ONEOF,    UINT32,   (payloadVariant,want_config_id,want_config_id), 100) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,set_radio,set_radio), 101) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,set_owner,set_owner), 102) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,set_channel,set_channel), 103)
+X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,packet,packet),   2) \
+X(a, STATIC,   ONEOF,    UINT32,   (payloadVariant,want_config_id,want_config_id), 100)
 #define ToRadio_CALLBACK NULL
 #define ToRadio_DEFAULT NULL
 #define ToRadio_payloadVariant_packet_MSGTYPE MeshPacket
-#define ToRadio_payloadVariant_set_radio_MSGTYPE RadioConfig
-#define ToRadio_payloadVariant_set_owner_MSGTYPE User
-#define ToRadio_payloadVariant_set_channel_MSGTYPE ChannelSettings
 
 extern const pb_msgdesc_t Position_msg;
-extern const pb_msgdesc_t Data_msg;
 extern const pb_msgdesc_t User_msg;
 extern const pb_msgdesc_t RouteDiscovery_msg;
-extern const pb_msgdesc_t SubPacket_msg;
+extern const pb_msgdesc_t Routing_msg;
+extern const pb_msgdesc_t Data_msg;
 extern const pb_msgdesc_t MeshPacket_msg;
-extern const pb_msgdesc_t ChannelSettings_msg;
-extern const pb_msgdesc_t RadioConfig_msg;
-extern const pb_msgdesc_t RadioConfig_UserPreferences_msg;
 extern const pb_msgdesc_t NodeInfo_msg;
 extern const pb_msgdesc_t MyNodeInfo_msg;
 extern const pb_msgdesc_t LogRecord_msg;
@@ -731,14 +412,11 @@ extern const pb_msgdesc_t ToRadio_msg;
 
 /* Defines for backwards compatibility with code written before nanopb-0.4.0 */
 #define Position_fields &Position_msg
-#define Data_fields &Data_msg
 #define User_fields &User_msg
 #define RouteDiscovery_fields &RouteDiscovery_msg
-#define SubPacket_fields &SubPacket_msg
+#define Routing_fields &Routing_msg
+#define Data_fields &Data_msg
 #define MeshPacket_fields &MeshPacket_msg
-#define ChannelSettings_fields &ChannelSettings_msg
-#define RadioConfig_fields &RadioConfig_msg
-#define RadioConfig_UserPreferences_fields &RadioConfig_UserPreferences_msg
 #define NodeInfo_fields &NodeInfo_msg
 #define MyNodeInfo_fields &MyNodeInfo_msg
 #define LogRecord_fields &LogRecord_msg
@@ -746,20 +424,17 @@ extern const pb_msgdesc_t ToRadio_msg;
 #define ToRadio_fields &ToRadio_msg
 
 /* Maximum encoded size of messages (where known) */
-#define Position_size                            39
-#define Data_size                                246
+#define Position_size                            37
 #define User_size                                72
-#define RouteDiscovery_size                      88
-#define SubPacket_size                           275
-#define MeshPacket_size                          322
-#define ChannelSettings_size                     95
-#define RadioConfig_size                         405
-#define RadioConfig_UserPreferences_size         305
-#define NodeInfo_size                            132
-#define MyNodeInfo_size                          106
+#define RouteDiscovery_size                      40
+#define Routing_size                             42
+#define Data_size                                260
+#define MeshPacket_size                          298
+#define NodeInfo_size                            130
+#define MyNodeInfo_size                          89
 #define LogRecord_size                           81
-#define FromRadio_size                           414
-#define ToRadio_size                             409
+#define FromRadio_size                           307
+#define ToRadio_size                             301
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/portnums.pb.h

@@ -16,19 +16,23 @@ typedef enum _PortNum {
     PortNum_REMOTE_HARDWARE_APP = 2,
     PortNum_POSITION_APP = 3,
     PortNum_NODEINFO_APP = 4,
+    PortNum_ROUTING_APP = 5,
+    PortNum_ADMIN_APP = 6,
     PortNum_REPLY_APP = 32,
     PortNum_IP_TUNNEL_APP = 33,
     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_ATAK_FORWARDER = 257,
+    PortNum_MAX = 511
 } PortNum;
 
 /* Helper constants for enums */
 #define _PortNum_MIN PortNum_UNKNOWN_APP
-#define _PortNum_MAX PortNum_ATAK_FORWARDER
-#define _PortNum_ARRAYSIZE ((PortNum)(PortNum_ATAK_FORWARDER+1))
+#define _PortNum_MAX PortNum_MAX
+#define _PortNum_ARRAYSIZE ((PortNum)(PortNum_MAX+1))
 
 
 #ifdef __cplusplus

src/mesh/generated/radioconfig.pb.c

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

src/mesh/generated/radioconfig.pb.h

@@ -0,0 +1,285 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.4 */
+
+#ifndef PB_RADIOCONFIG_PB_H_INCLUDED
+#define PB_RADIOCONFIG_PB_H_INCLUDED
+#include <pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Enum definitions */
+typedef enum _RegionCode {
+    RegionCode_Unset = 0,
+    RegionCode_US = 1,
+    RegionCode_EU433 = 2,
+    RegionCode_EU865 = 3,
+    RegionCode_CN = 4,
+    RegionCode_JP = 5,
+    RegionCode_ANZ = 6,
+    RegionCode_KR = 7,
+    RegionCode_TW = 8
+} RegionCode;
+
+typedef enum _ChargeCurrent {
+    ChargeCurrent_MAUnset = 0,
+    ChargeCurrent_MA100 = 1,
+    ChargeCurrent_MA190 = 2,
+    ChargeCurrent_MA280 = 3,
+    ChargeCurrent_MA360 = 4,
+    ChargeCurrent_MA450 = 5,
+    ChargeCurrent_MA550 = 6,
+    ChargeCurrent_MA630 = 7,
+    ChargeCurrent_MA700 = 8,
+    ChargeCurrent_MA780 = 9,
+    ChargeCurrent_MA880 = 10,
+    ChargeCurrent_MA960 = 11,
+    ChargeCurrent_MA1000 = 12,
+    ChargeCurrent_MA1080 = 13,
+    ChargeCurrent_MA1160 = 14,
+    ChargeCurrent_MA1240 = 15,
+    ChargeCurrent_MA1320 = 16
+} ChargeCurrent;
+
+typedef enum _GpsOperation {
+    GpsOperation_GpsOpUnset = 0,
+    GpsOperation_GpsOpStationary = 1,
+    GpsOperation_GpsOpMobile = 2,
+    GpsOperation_GpsOpTimeOnly = 3,
+    GpsOperation_GpsOpDisabled = 4
+} GpsOperation;
+
+typedef enum _LocationSharing {
+    LocationSharing_LocUnset = 0,
+    LocationSharing_LocEnabled = 1,
+    LocationSharing_LocDisabled = 2
+} LocationSharing;
+
+typedef enum _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType {
+    RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_DHT11 = 0
+} RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType;
+
+/* Struct definitions */
+typedef struct _RadioConfig_UserPreferences {
+    uint32_t position_broadcast_secs;
+    uint32_t send_owner_interval;
+    uint32_t wait_bluetooth_secs;
+    uint32_t screen_on_secs;
+    uint32_t phone_timeout_secs;
+    uint32_t phone_sds_timeout_sec;
+    uint32_t mesh_sds_timeout_secs;
+    uint32_t sds_secs;
+    uint32_t ls_secs;
+    uint32_t min_wake_secs;
+    char wifi_ssid[33];
+    char wifi_password[64];
+    bool wifi_ap_mode;
+    RegionCode region;
+    ChargeCurrent charge_current;
+    LocationSharing location_share;
+    GpsOperation gps_operation;
+    uint32_t gps_update_interval;
+    uint32_t gps_attempt_time;
+    bool is_router;
+    bool is_low_power;
+    bool fixed_position;
+    bool factory_reset;
+    bool debug_log_enabled;
+    pb_size_t ignore_incoming_count;
+    uint32_t ignore_incoming[3];
+    bool serialplugin_enabled;
+    bool serialplugin_echo;
+    uint32_t serialplugin_rxd;
+    uint32_t serialplugin_txd;
+    uint32_t serialplugin_timeout;
+    uint32_t serialplugin_mode;
+    bool ext_notification_plugin_enabled;
+    uint32_t ext_notification_plugin_output_ms;
+    uint32_t ext_notification_plugin_output;
+    bool ext_notification_plugin_active;
+    bool ext_notification_plugin_alert_message;
+    bool ext_notification_plugin_alert_bell;
+    bool range_test_plugin_enabled;
+    uint32_t range_test_plugin_sender;
+    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;
+    bool environmental_measurement_plugin_display_farenheit;
+    RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType environmental_measurement_plugin_sensor_type;
+    uint32_t environmental_measurement_plugin_sensor_pin;
+} RadioConfig_UserPreferences;
+
+typedef struct _RadioConfig {
+    bool has_preferences;
+    RadioConfig_UserPreferences preferences;
+} RadioConfig;
+
+
+/* Helper constants for enums */
+#define _RegionCode_MIN RegionCode_Unset
+#define _RegionCode_MAX RegionCode_TW
+#define _RegionCode_ARRAYSIZE ((RegionCode)(RegionCode_TW+1))
+
+#define _ChargeCurrent_MIN ChargeCurrent_MAUnset
+#define _ChargeCurrent_MAX ChargeCurrent_MA1320
+#define _ChargeCurrent_ARRAYSIZE ((ChargeCurrent)(ChargeCurrent_MA1320+1))
+
+#define _GpsOperation_MIN GpsOperation_GpsOpUnset
+#define _GpsOperation_MAX GpsOperation_GpsOpDisabled
+#define _GpsOperation_ARRAYSIZE ((GpsOperation)(GpsOperation_GpsOpDisabled+1))
+
+#define _LocationSharing_MIN LocationSharing_LocUnset
+#define _LocationSharing_MAX LocationSharing_LocDisabled
+#define _LocationSharing_ARRAYSIZE ((LocationSharing)(LocationSharing_LocDisabled+1))
+
+#define _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_DHT11
+#define _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MAX RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_DHT11
+#define _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_ARRAYSIZE ((RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType)(RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_DHT11+1))
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define RadioConfig_init_default                 {false, RadioConfig_UserPreferences_init_default}
+#define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0}
+#define RadioConfig_init_zero                    {false, RadioConfig_UserPreferences_init_zero}
+#define RadioConfig_UserPreferences_init_zero    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define RadioConfig_UserPreferences_position_broadcast_secs_tag 1
+#define RadioConfig_UserPreferences_send_owner_interval_tag 2
+#define RadioConfig_UserPreferences_wait_bluetooth_secs_tag 4
+#define RadioConfig_UserPreferences_screen_on_secs_tag 5
+#define RadioConfig_UserPreferences_phone_timeout_secs_tag 6
+#define RadioConfig_UserPreferences_phone_sds_timeout_sec_tag 7
+#define RadioConfig_UserPreferences_mesh_sds_timeout_secs_tag 8
+#define RadioConfig_UserPreferences_sds_secs_tag 9
+#define RadioConfig_UserPreferences_ls_secs_tag  10
+#define RadioConfig_UserPreferences_min_wake_secs_tag 11
+#define RadioConfig_UserPreferences_wifi_ssid_tag 12
+#define RadioConfig_UserPreferences_wifi_password_tag 13
+#define RadioConfig_UserPreferences_wifi_ap_mode_tag 14
+#define RadioConfig_UserPreferences_region_tag   15
+#define RadioConfig_UserPreferences_charge_current_tag 16
+#define RadioConfig_UserPreferences_location_share_tag 32
+#define RadioConfig_UserPreferences_gps_operation_tag 33
+#define RadioConfig_UserPreferences_gps_update_interval_tag 34
+#define RadioConfig_UserPreferences_gps_attempt_time_tag 36
+#define RadioConfig_UserPreferences_is_router_tag 37
+#define RadioConfig_UserPreferences_is_low_power_tag 38
+#define RadioConfig_UserPreferences_fixed_position_tag 39
+#define RadioConfig_UserPreferences_factory_reset_tag 100
+#define RadioConfig_UserPreferences_debug_log_enabled_tag 101
+#define RadioConfig_UserPreferences_ignore_incoming_tag 103
+#define RadioConfig_UserPreferences_serialplugin_enabled_tag 120
+#define RadioConfig_UserPreferences_serialplugin_echo_tag 121
+#define RadioConfig_UserPreferences_serialplugin_rxd_tag 122
+#define RadioConfig_UserPreferences_serialplugin_txd_tag 123
+#define RadioConfig_UserPreferences_serialplugin_timeout_tag 124
+#define RadioConfig_UserPreferences_serialplugin_mode_tag 125
+#define RadioConfig_UserPreferences_ext_notification_plugin_enabled_tag 126
+#define RadioConfig_UserPreferences_ext_notification_plugin_output_ms_tag 127
+#define RadioConfig_UserPreferences_ext_notification_plugin_output_tag 128
+#define RadioConfig_UserPreferences_ext_notification_plugin_active_tag 129
+#define RadioConfig_UserPreferences_ext_notification_plugin_alert_message_tag 130
+#define RadioConfig_UserPreferences_ext_notification_plugin_alert_bell_tag 131
+#define RadioConfig_UserPreferences_range_test_plugin_enabled_tag 132
+#define RadioConfig_UserPreferences_range_test_plugin_sender_tag 133
+#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 RadioConfig_UserPreferences_environmental_measurement_plugin_display_farenheit_tag 145
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_sensor_type_tag 146
+#define RadioConfig_UserPreferences_environmental_measurement_plugin_sensor_pin_tag 147
+#define RadioConfig_preferences_tag              1
+
+/* Struct field encoding specification for nanopb */
+#define RadioConfig_FIELDLIST(X, a) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  preferences,       1)
+#define RadioConfig_CALLBACK NULL
+#define RadioConfig_DEFAULT NULL
+#define RadioConfig_preferences_MSGTYPE RadioConfig_UserPreferences
+
+#define RadioConfig_UserPreferences_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, UINT32,   position_broadcast_secs,   1) \
+X(a, STATIC,   SINGULAR, UINT32,   send_owner_interval,   2) \
+X(a, STATIC,   SINGULAR, UINT32,   wait_bluetooth_secs,   4) \
+X(a, STATIC,   SINGULAR, UINT32,   screen_on_secs,    5) \
+X(a, STATIC,   SINGULAR, UINT32,   phone_timeout_secs,   6) \
+X(a, STATIC,   SINGULAR, UINT32,   phone_sds_timeout_sec,   7) \
+X(a, STATIC,   SINGULAR, UINT32,   mesh_sds_timeout_secs,   8) \
+X(a, STATIC,   SINGULAR, UINT32,   sds_secs,          9) \
+X(a, STATIC,   SINGULAR, UINT32,   ls_secs,          10) \
+X(a, STATIC,   SINGULAR, UINT32,   min_wake_secs,    11) \
+X(a, STATIC,   SINGULAR, STRING,   wifi_ssid,        12) \
+X(a, STATIC,   SINGULAR, STRING,   wifi_password,    13) \
+X(a, STATIC,   SINGULAR, BOOL,     wifi_ap_mode,     14) \
+X(a, STATIC,   SINGULAR, UENUM,    region,           15) \
+X(a, STATIC,   SINGULAR, UENUM,    charge_current,   16) \
+X(a, STATIC,   SINGULAR, UENUM,    location_share,   32) \
+X(a, STATIC,   SINGULAR, UENUM,    gps_operation,    33) \
+X(a, STATIC,   SINGULAR, UINT32,   gps_update_interval,  34) \
+X(a, STATIC,   SINGULAR, UINT32,   gps_attempt_time,  36) \
+X(a, STATIC,   SINGULAR, BOOL,     is_router,        37) \
+X(a, STATIC,   SINGULAR, BOOL,     is_low_power,     38) \
+X(a, STATIC,   SINGULAR, BOOL,     fixed_position,   39) \
+X(a, STATIC,   SINGULAR, BOOL,     factory_reset,   100) \
+X(a, STATIC,   SINGULAR, BOOL,     debug_log_enabled, 101) \
+X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103) \
+X(a, STATIC,   SINGULAR, BOOL,     serialplugin_enabled, 120) \
+X(a, STATIC,   SINGULAR, BOOL,     serialplugin_echo, 121) \
+X(a, STATIC,   SINGULAR, UINT32,   serialplugin_rxd, 122) \
+X(a, STATIC,   SINGULAR, UINT32,   serialplugin_txd, 123) \
+X(a, STATIC,   SINGULAR, UINT32,   serialplugin_timeout, 124) \
+X(a, STATIC,   SINGULAR, UINT32,   serialplugin_mode, 125) \
+X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_enabled, 126) \
+X(a, STATIC,   SINGULAR, UINT32,   ext_notification_plugin_output_ms, 127) \
+X(a, STATIC,   SINGULAR, UINT32,   ext_notification_plugin_output, 128) \
+X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_active, 129) \
+X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_alert_message, 130) \
+X(a, STATIC,   SINGULAR, BOOL,     ext_notification_plugin_alert_bell, 131) \
+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, 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) \
+X(a, STATIC,   SINGULAR, BOOL,     environmental_measurement_plugin_display_farenheit, 145) \
+X(a, STATIC,   SINGULAR, UENUM,    environmental_measurement_plugin_sensor_type, 146) \
+X(a, STATIC,   SINGULAR, UINT32,   environmental_measurement_plugin_sensor_pin, 147)
+#define RadioConfig_UserPreferences_CALLBACK NULL
+#define RadioConfig_UserPreferences_DEFAULT NULL
+
+extern const pb_msgdesc_t RadioConfig_msg;
+extern const pb_msgdesc_t RadioConfig_UserPreferences_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define RadioConfig_fields &RadioConfig_msg
+#define RadioConfig_UserPreferences_fields &RadioConfig_UserPreferences_msg
+
+/* Maximum encoded size of messages (where known) */
+#define RadioConfig_size                         348
+#define RadioConfig_UserPreferences_size         345
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

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/mesh/mesh-pb-constants.h

@@ -2,6 +2,7 @@
 
 #include "mesh/generated/mesh.pb.h"
 #include "mesh/generated/deviceonly.pb.h"
+#include "mesh/generated/admin.pb.h"
 
 // this file defines constants which come from mesh.options
 
@@ -16,6 +17,9 @@
 /// max number of nodes allowed in the mesh
 #define MAX_NUM_NODES (member_size(DeviceState, node_db) / member_size(DeviceState, node_db[0]))
 
+/// Max number of channels allowed
+#define MAX_NUM_CHANNELS (member_size(DeviceState, channels) / member_size(DeviceState, channels[0]))
+
 /// helper function for encoding a record as a protobuf, any failures to encode are fatal and we will panic
 /// returns the encoded packet size
 size_t pb_encode_to_bytes(uint8_t *destbuf, size_t destbufsize, const pb_msgdesc_t *fields, const void *src_struct);

src/nrf52/NRF52CryptoEngine.cpp

@@ -6,30 +6,13 @@
 class NRF52CryptoEngine : public CryptoEngine
 {
 
-    /// How many bytes in our key
-    uint8_t keySize = 0;
-    const uint8_t *keyBytes;
+
 
   public:
     NRF52CryptoEngine() {}
 
     ~NRF52CryptoEngine() {}
 
-    /**
-     * Set the key used for encrypt, decrypt.
-     *
-     * As a special case: If all bytes are zero, we assume _no encryption_ and send all data in cleartext.
-     *
-     * @param numBytes must be 16 (AES128), 32 (AES256) or 0 (no crypt)
-     * @param bytes a _static_ buffer that will remain valid for the life of this crypto instance (i.e. this class will cache the
-     * provided pointer)
-     */
-    virtual void setKey(size_t numBytes, uint8_t *bytes)
-    {
-        keySize = numBytes;
-        keyBytes = bytes;
-    }
-
     /**
      * Encrypt a packet
      *
@@ -39,11 +22,11 @@ class NRF52CryptoEngine : public CryptoEngine
     {
         // DEBUG_MSG("NRF52 encrypt!\n");
 
-        if (keySize != 0) {
+        if (key.length > 0) {
             ocrypto_aes_ctr_ctx ctx;
 
             initNonce(fromNode, packetNum);
-            ocrypto_aes_ctr_init(&ctx, keyBytes, keySize, nonce);
+            ocrypto_aes_ctr_init(&ctx, key.bytes, key.length, nonce);
 
             ocrypto_aes_ctr_encrypt(&ctx, bytes, bytes, numBytes);
         }
@@ -53,11 +36,11 @@ class NRF52CryptoEngine : public CryptoEngine
     {
         // DEBUG_MSG("NRF52 decrypt!\n");
 
-        if (keySize != 0) {
+        if (key.length > 0) {
             ocrypto_aes_ctr_ctx ctx;
 
             initNonce(fromNode, packetNum);
-            ocrypto_aes_ctr_init(&ctx, keyBytes, keySize, nonce);
+            ocrypto_aes_ctr_init(&ctx, key.bytes, key.length, nonce);
 
             ocrypto_aes_ctr_decrypt(&ctx, bytes, bytes, numBytes);
         }

src/plugins/AdminPlugin.cpp

@@ -0,0 +1,119 @@
+#include "AdminPlugin.h"
+#include "Channels.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "Router.h"
+#include "configuration.h"
+#include "main.h"
+
+AdminPlugin *adminPlugin;
+
+void AdminPlugin::handleGetChannel(const MeshPacket &req, uint32_t channelIndex) {
+        if (req.decoded.want_response) {
+        // We create the reply here
+        AdminMessage r = AdminMessage_init_default;
+        r.get_channel_response = channels.getByIndex(channelIndex);
+        r.which_variant = AdminMessage_get_channel_response_tag;
+        reply = allocDataProtobuf(r);
+    }
+}
+
+void AdminPlugin::handleGetRadio(const MeshPacket &req)
+{
+    if (req.decoded.want_response) {
+        // We create the reply here
+        AdminMessage r = AdminMessage_init_default;
+        r.get_radio_response = devicestate.radio;
+        r.which_variant = AdminMessage_get_radio_response_tag;
+        reply = allocDataProtobuf(r);
+    }
+}
+
+bool AdminPlugin::handleReceivedProtobuf(const MeshPacket &mp, const AdminMessage *r)
+{
+    assert(r);
+    switch (r->which_variant) {
+    case AdminMessage_set_owner_tag:
+        DEBUG_MSG("Client is setting owner\n");
+        handleSetOwner(r->set_owner);
+        break;
+
+    case AdminMessage_set_radio_tag:
+        DEBUG_MSG("Client is setting radio\n");
+        handleSetRadio(r->set_radio);
+        break;
+
+    case AdminMessage_set_channel_tag:
+        DEBUG_MSG("Client is setting channel\n");
+        handleSetChannel(r->set_channel);
+        break;
+
+    case AdminMessage_get_channel_request_tag:
+        DEBUG_MSG("Client is getting channel %d\n", r->get_channel_request - 1);
+        handleGetChannel(mp, r->get_channel_request - 1);
+        break;
+
+    case AdminMessage_get_radio_request_tag:
+        DEBUG_MSG("Client is getting radio\n");
+        handleGetRadio(mp);
+        break;
+
+    default:
+        break;
+    }
+    return false; // Let others look at this message also if they want
+}
+
+void AdminPlugin::handleSetOwner(const User &o)
+{
+    int changed = 0;
+
+    if (*o.long_name) {
+        changed |= strcmp(owner.long_name, o.long_name);
+        strcpy(owner.long_name, o.long_name);
+    }
+    if (*o.short_name) {
+        changed |= strcmp(owner.short_name, o.short_name);
+        strcpy(owner.short_name, o.short_name);
+    }
+    if (*o.id) {
+        changed |= strcmp(owner.id, o.id);
+        strcpy(owner.id, o.id);
+    }
+
+    if (changed) // If nothing really changed, don't broadcast on the network or write to flash
+        service.reloadOwner();
+}
+
+void AdminPlugin::handleSetChannel(const Channel &cc)
+{
+    channels.setChannel(cc);
+
+    bool didReset = service.reloadConfig();
+    /* FIXME - do we need this still?
+    if (didReset) {
+        state = STATE_SEND_MY_INFO; // Squirt a completely new set of configs to the client
+    } */
+}
+
+void AdminPlugin::handleSetRadio(const RadioConfig &r)
+{
+    radioConfig = r;
+
+    bool didReset = service.reloadConfig();
+    /* FIXME - do we need this still?  if (didReset) {
+        state = STATE_SEND_MY_INFO; // Squirt a completely new set of configs to the client
+    } */
+}
+
+MeshPacket *AdminPlugin::allocReply()
+{
+    auto r = reply;
+    reply = NULL; // Only use each reply once
+    return r;
+}
+
+AdminPlugin::AdminPlugin() : ProtobufPlugin("Admin", PortNum_ADMIN_APP, AdminMessage_fields)
+{
+    // FIXME, restrict to the admin channel for rx
+}

src/plugins/AdminPlugin.h

@@ -0,0 +1,37 @@
+#pragma once
+#include "ProtobufPlugin.h"
+
+/**
+ * Routing plugin for router control messages
+ */
+class AdminPlugin : public ProtobufPlugin<AdminMessage>
+{
+  MeshPacket *reply = NULL;
+  
+  public:
+    /** Constructor
+     * name is for debugging output
+     */
+    AdminPlugin();
+
+  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 AdminMessage *p);
+
+    /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
+     * so that subclasses can (optionally) send a response back to the original sender.  */
+    virtual MeshPacket *allocReply();
+
+  private:
+    void handleSetOwner(const User &o);
+    void handleSetChannel(const Channel &cc);
+    void handleSetRadio(const RadioConfig &r);
+
+    void handleGetChannel(const MeshPacket &req, uint32_t channelIndex);
+    void handleGetRadio(const MeshPacket &req);
+};
+
+extern AdminPlugin *adminPlugin;

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
@@ -145,9 +145,9 @@ bool ExternalNotificationPluginRadio::handleReceived(const MeshPacket &mp)
 
     if (radioConfig.preferences.ext_notification_plugin_enabled) {
 
-        auto &p = mp.decoded.data;
+        auto &p = mp.decoded;
 
-        if (mp.from != nodeDB.getNodeNum()) {
+        if (getFrom(&mp) != nodeDB.getNodeNum()) {
 
             // TODO: This may be a problem if messages are sent in unicide, but I'm not sure if it will.
             //   Need to know if and how this could be a problem.

src/plugins/NodeInfoPlugin.cpp

@@ -8,12 +8,11 @@
 
 NodeInfoPlugin *nodeInfoPlugin;
 
-bool NodeInfoPlugin::handleReceivedProtobuf(const MeshPacket &mp, const User &p)
+bool NodeInfoPlugin::handleReceivedProtobuf(const MeshPacket &mp, const User *pptr)
 {
-    // FIXME - we currently update NodeInfo data in the DB only if the message was a broadcast or destined to us
-    // it would be better to update even if the message was destined to others.
+    auto p = *pptr;
 
-    nodeDB.updateUser(mp.from, p);
+    nodeDB.updateUser(getFrom(&mp), p);
 
     bool wasBroadcast = mp.to == NODENUM_BROADCAST;
 
@@ -29,7 +28,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 +47,27 @@ 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")
+{
+    isPromiscuous = true; // We always want to update our nodedb, even if we are sniffing on others
+    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
      */
@@ -25,11 +26,14 @@ class NodeInfoPlugin : public ProtobufPlugin<User>
 
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const User &p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const User *p);
 
     /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
      * so that subclasses can (optionally) send a response back to the original sender.  */
     virtual MeshPacket *allocReply();
+
+    /** Does our periodic broadcast */
+    virtual int32_t runOnce();      
 };
 
 extern NodeInfoPlugin *nodeInfoPlugin;

src/plugins/Plugins.cpp

@@ -3,14 +3,24 @@
 #include "plugins/PositionPlugin.h"
 #include "plugins/RemoteHardwarePlugin.h"
 #include "plugins/ReplyPlugin.h"
+#include "plugins/TextMessagePlugin.h" 
 #include "plugins/SerialPlugin.h"
 #include "plugins/TextMessagePlugin.h"
+#include "plugins/RoutingPlugin.h"
+#include "plugins/AdminPlugin.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)
  */
 void setupPlugins()
 {
+    adminPlugin = new AdminPlugin();
     nodeInfoPlugin = new NodeInfoPlugin();
     positionPlugin = new PositionPlugin();
     textMessagePlugin = new TextMessagePlugin();
@@ -24,7 +34,20 @@ 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
+
+    // NOTE! This plugin must be added LAST because it likes to check for replies from other plugins and avoid sending extra acks
+    routingPlugin = new RoutingPlugin();
 }

src/plugins/PositionPlugin.cpp

@@ -7,10 +7,18 @@
 
 PositionPlugin *positionPlugin;
 
-bool PositionPlugin::handleReceivedProtobuf(const MeshPacket &mp, const Position &p)
+PositionPlugin::PositionPlugin()
+    : ProtobufPlugin("position", PortNum_POSITION_APP, Position_fields), concurrency::OSThread("PositionPlugin")
 {
-    // FIXME - we currently update position data in the DB only if the message was a broadcast or destined to us
-    // it would be better to update even if the message was destined to others.
+    isPromiscuous = true; // We always want to update our nodedb, even if we are sniffing on others
+    setIntervalFromNow(60 *
+                       1000); // Send our initial position 60 seconds after we start (to give GPS time to setup)
+
+}
+
+bool PositionPlugin::handleReceivedProtobuf(const MeshPacket &mp, const Position *pptr)
+{
+    auto p = *pptr;
 
     if (p.time) {
         struct timeval tv;
@@ -22,7 +30,7 @@ bool PositionPlugin::handleReceivedProtobuf(const MeshPacket &mp, const Position
         perhapsSetRTC(RTCQualityFromNet, &tv);
     }
 
-    nodeDB.updatePosition(mp.from, p);
+    nodeDB.updatePosition(getFrom(&mp), p);
 
     return false; // Let others look at this message also if they want
 }
@@ -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
      */
@@ -26,11 +33,14 @@ class PositionPlugin : public ProtobufPlugin<Position>
 
     @return true if you've guaranteed you've handled this message and no other handlers should be considered for it
     */
-    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const Position &p);
+    virtual bool handleReceivedProtobuf(const MeshPacket &mp, const Position *p);
 
     /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
      * so that subclasses can (optionally) send a response back to the original sender.  */
     virtual MeshPacket *allocReply();
+
+    /** Does our periodic broadcast */
+    virtual int32_t runOnce();  
 };
 
 extern PositionPlugin *positionPlugin;

src/plugins/RemoteHardwarePlugin.cpp

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

src/plugins/RemoteHardwarePlugin.h

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

src/plugins/ReplyPlugin.cpp

@@ -9,7 +9,7 @@ MeshPacket *ReplyPlugin::allocReply()
 {
     assert(currentRequest); // should always be !NULL
     auto req = *currentRequest;
-    auto &p = req.decoded.data;
+    auto &p = req.decoded;
     // The incoming message is in p.payload
     DEBUG_MSG("Received message from=0x%0x, id=%d, msg=%.*s\n", req.from, req.id, p.payload.size, p.payload.bytes);
 
@@ -17,8 +17,8 @@ MeshPacket *ReplyPlugin::allocReply()
 
     const char *replyStr = "Message Received";
     auto reply = allocDataPacket();                      // Allocate a packet for sending
-    reply->decoded.data.payload.size = strlen(replyStr); // You must specify how many bytes are in the reply
-    memcpy(reply->decoded.data.payload.bytes, replyStr, reply->decoded.data.payload.size);
+    reply->decoded.payload.size = strlen(replyStr); // You must specify how many bytes are in the reply
+    memcpy(reply->decoded.payload.bytes, replyStr, reply->decoded.payload.size);
 
     return reply;
 }

src/plugins/RoutingPlugin.cpp

@@ -0,0 +1,61 @@
+#include "RoutingPlugin.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include "Router.h"
+#include "configuration.h"
+#include "main.h"
+
+RoutingPlugin *routingPlugin;
+
+bool RoutingPlugin::handleReceivedProtobuf(const MeshPacket &mp, const Routing *r)
+{
+    printPacket("Routing sniffing", &mp);
+    router->sniffReceived(&mp, r);
+
+    // FIXME - move this to a non promsicious PhoneAPI plugin?
+    // Note: we are careful not to send back packets that started with the phone back to the phone
+    if ((mp.to == NODENUM_BROADCAST || mp.to == nodeDB.getNodeNum()) && (mp.from != 0)) {
+        printPacket("Delivering rx packet", &mp);
+        service.handleFromRadio(&mp);
+    }
+        
+    return false; // Let others look at this message also if they want
+}
+
+
+MeshPacket *RoutingPlugin::allocReply()
+{
+    assert(currentRequest);
+
+    // We only consider making replies if the request was a legit routing packet (not just something we were sniffing)
+    if(currentRequest->decoded.portnum == PortNum_ROUTING_APP) {
+        assert(0); // 1.2 refactoring fixme, Not sure if anything needs this yet?
+        // return allocDataProtobuf(u);
+    }
+    return NULL;
+}
+
+void RoutingPlugin::sendAckNak(Routing_Error err, NodeNum to, PacketId idFrom)
+{
+    Routing c = Routing_init_default;
+    
+    c.error_reason = err;
+
+    auto p = allocDataProtobuf(c);
+    p->priority = MeshPacket_Priority_ACK;
+
+    p->hop_limit = 0; // Assume just immediate neighbors for now
+    p->to = to;
+    p->decoded.request_id = idFrom;
+    DEBUG_MSG("Sending an err=%d,to=0x%x,idFrom=0x%x,id=0x%x\n", err, to, idFrom, p->id);
+
+    router->sendLocal(p); // we sometimes send directly to the local node
+}
+
+RoutingPlugin::RoutingPlugin()
+    : ProtobufPlugin("routing", PortNum_ROUTING_APP, Routing_fields)
+{
+    isPromiscuous = true;
+}
+
+

src/plugins/RoutingPlugin.h

@@ -0,0 +1,34 @@
+#pragma once
+#include "ProtobufPlugin.h"
+
+/**
+ * Routing plugin for router control messages
+ */
+class RoutingPlugin : public ProtobufPlugin<Routing>
+{
+  public:
+    /** Constructor
+     * name is for debugging output
+     */
+    RoutingPlugin();
+
+  protected:
+    friend class Router;
+
+    /** 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 Routing *p);
+
+    /** Messages can be received that have the want_response bit set.  If set, this callback will be invoked
+     * so that subclasses can (optionally) send a response back to the original sender.  */
+    virtual MeshPacket *allocReply(); 
+
+    /// Override wantPacket to say we want to see all packets, not just those for our port number
+    virtual bool wantPacket(const MeshPacket *p) { return true; }
+
+    void sendAckNak(Routing_Error err, NodeNum to, PacketId idFrom);
+};
+
+extern RoutingPlugin *routingPlugin;

src/plugins/SerialPlugin.cpp

@@ -144,8 +144,8 @@ void SerialPluginRadio::sendPayload(NodeNum dest, bool wantReplies)
 
     p->want_ack = SERIALPLUGIN_ACK;
 
-    p->decoded.data.payload.size = strlen(serialStringChar); // You must specify how many bytes are in the reply
-    memcpy(p->decoded.data.payload.bytes, serialStringChar, p->decoded.data.payload.size);
+    p->decoded.payload.size = strlen(serialStringChar); // You must specify how many bytes are in the reply
+    memcpy(p->decoded.payload.bytes, serialStringChar, p->decoded.payload.size);
 
     service.sendToMesh(p);
 }
@@ -156,11 +156,11 @@ bool SerialPluginRadio::handleReceived(const MeshPacket &mp)
 
     if (radioConfig.preferences.serialplugin_enabled) {
 
-        auto &p = mp.decoded.data;
+        auto &p = mp.decoded;
         // 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()) {
+        if (getFrom(&mp) == nodeDB.getNodeNum()) {
 
             /*
              * If radioConfig.preferences.serialplugin_echo is true, then echo the packets that are sent out back to the TX

src/plugins/TextMessagePlugin.cpp

@@ -7,7 +7,7 @@ TextMessagePlugin *textMessagePlugin;
 
 bool TextMessagePlugin::handleReceived(const MeshPacket &mp)
 {
-    auto &p = mp.decoded.data;
+    auto &p = mp.decoded;
     DEBUG_MSG("Received text msg from=0x%0x, id=%d, msg=%.*s\n", mp.from, mp.id, p.payload.size, p.payload.bytes);
 
     // We only store/display messages destined for us.

src/plugins/esp32/EnvironmentalMeasurementPlugin.cpp

@@ -0,0 +1,253 @@
+#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>
+
+#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
+
+
+#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 = 60;
+    radioConfig.preferences.environmental_measurement_plugin_display_farenheit = true;
+    radioConfig.preferences.environmental_measurement_plugin_sensor_pin = 13;
+    radioConfig.preferences.environmental_measurement_plugin_sensor_type = RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType::RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_DHT11;*/
+
+    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
+       
+        firstTime = 0;
+       
+        if (radioConfig.preferences.environmental_measurement_plugin_measurement_enabled)
+        {
+            DEBUG_MSG("EnvironmentalMeasurement: Initializing\n");
+            // 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
+            switch(radioConfig.preferences.environmental_measurement_plugin_sensor_type) {
+                case RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_DHT11:
+                    dht = new DHT(radioConfig.preferences.environmental_measurement_plugin_sensor_pin,DHT11);
+                    this->dht->begin();
+                    this->dht->read();
+                    DEBUG_MSG("EnvironmentalMeasurement: Opened DHT11 on pin: %d\n",radioConfig.preferences.environmental_measurement_plugin_sensor_pin);
+                break;
+                default:
+                    DEBUG_MSG("EnvironmentalMeasurement: Invalid sensor type selected; Disabling plugin");
+                    return (INT32_MAX);
+                    break;
+            }
+            // 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()"
+            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);
+                    sensor_read_error_count = 0;
+                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 (!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 EnvironmentalMeasurementPlugin::wantUIFrame() {
+    return radioConfig.preferences.environmental_measurement_plugin_screen_enabled;
+}
+
+String GetSenderName(const MeshPacket &mp) {
+    String sender;
+
+    auto node = nodeDB.getNode(getFrom(&mp));
+    if (node){
+        sender = node->user.short_name;
+    }
+    else {
+        sender = "UNK";
+    }
+    return sender;
+}
+
+uint32_t GetTimeSinceMeshPacket(const MeshPacket *mp) {
+    uint32_t now = getTime();
+
+    uint32_t last_seen = mp->rx_time;
+    int delta = (int)(now - last_seen);
+    if (delta < 0) // our clock must be slightly off still - not set from GPS yet
+        delta = 0;
+
+    return delta;
+
+}
+
+
+float EnvironmentalMeasurementPlugin::CelsiusToFarenheit(float c) {
+    return (c*9)/5 + 32;
+}
+
+
+void EnvironmentalMeasurementPlugin::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");
+    if (lastMeasurementPacket == nullptr) {
+        display->setFont(FONT_SMALL);
+        display->drawString(x, y += fontHeight(FONT_MEDIUM), "No measurement");
+        //DEBUG_MSG("EnvironmentalMeasurement: No previous measurement; not drawing frame\n");
+        return;
+    }
+
+    EnvironmentalMeasurement lastMeasurement;
+    
+   
+    uint32_t agoSecs = GetTimeSinceMeshPacket(lastMeasurementPacket);
+    String lastSender = GetSenderName(*lastMeasurementPacket);
+
+    auto &p = lastMeasurementPacket->decoded;
+    if (!pb_decode_from_bytes(p.payload.bytes, 
+            p.payload.size,
+            EnvironmentalMeasurement_fields, 
+            &lastMeasurement)) {
+        display->setFont(FONT_SMALL);
+        display->drawString(x, y += fontHeight(FONT_MEDIUM), "Measurement Error");
+        DEBUG_MSG("EnvironmentalMeasurement: unable to decode last packet");
+        return;
+    }
+
+    display->setFont(FONT_SMALL);
+    String last_temp =  String(lastMeasurement.temperature,0) +"°C";
+    if (radioConfig.preferences.environmental_measurement_plugin_display_farenheit){
+        last_temp = String(CelsiusToFarenheit(lastMeasurement.temperature),0) +"°F";;
+    }
+
+    display->drawString(x, y += fontHeight(FONT_MEDIUM), lastSender+": "+last_temp +"/"+ String(lastMeasurement.relative_humidity,0) + "%("+String(agoSecs)+"s)");
+
+}
+
+bool EnvironmentalMeasurementPlugin::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;
+    }
+
+    String sender = GetSenderName(mp);
+
+    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);
+
+    lastMeasurementPacket = packetPool.allocCopy(mp);
+
+    return false; // Let others look at this message also if they want
+}
+
+bool EnvironmentalMeasurementPlugin::sendOurEnvironmentalMeasurement(NodeNum dest, bool wantReplies)
+{
+    EnvironmentalMeasurement m;
+
+    m.barometric_pressure = 0; // TODO: Add support for barometric sensors
+    DEBUG_MSG("-----------------------------------------\n");
+
+    DEBUG_MSG("EnvironmentalMeasurement: Read data\n");
+    if (!this->dht->read(true)){
+        sensor_read_error_count++;
+        DEBUG_MSG("EnvironmentalMeasurement: FAILED TO READ DATA\n");
+        return false;
+    }
+    m.relative_humidity = this->dht->readHumidity();
+    m.temperature = this->dht->readTemperature();
+
+    DEBUG_MSG("EnvironmentalMeasurement->relative_humidity: %f\n", m.relative_humidity);
+    DEBUG_MSG("EnvironmentalMeasurement->temperature: %f\n", m.temperature);
+
+    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,34 @@
+#pragma once
+#include "ProtobufPlugin.h"
+#include "../mesh/generated/environmental_measurement.pb.h"
+#include <OLEDDisplay.h>
+#include <OLEDDisplayUi.h>
+#include <DHT.h>
+
+class EnvironmentalMeasurementPlugin : private concurrency::OSThread, public ProtobufPlugin<EnvironmentalMeasurement>
+{
+  public:
+    EnvironmentalMeasurementPlugin(): concurrency::OSThread("EnvironmentalMeasurementPlugin"), ProtobufPlugin("EnvironmentalMeasurement", PortNum_ENVIRONMENTAL_MEASUREMENT_APP, &EnvironmentalMeasurement_msg) { 
+      lastMeasurementPacket = nullptr;
+    }
+    virtual bool wantUIFrame();
+    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 int32_t runOnce();
+    /**
+     * Send our EnvironmentalMeasurement into the mesh
+     */
+    bool sendOurEnvironmentalMeasurement(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
+    
+  private:
+    float CelsiusToFarenheit(float c);
+    bool firstTime = 1;
+    DHT* dht;
+    const MeshPacket *lastMeasurementPacket;
+    uint32_t sensor_read_error_count = 0;
+};

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.payload.size = strlen(heartbeatString); // You must specify how many bytes are in the reply
+    memcpy(p->decoded.payload.bytes, heartbeatString, p->decoded.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;
+        // 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 (getFrom(&mp) != 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(getFrom(&mp));
+
+            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;
+
+    NodeInfo *n = nodeDB.getNode(getFrom(&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");
+    */
+    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,", getFrom(&mp));                          // 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), Data_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 (getFrom(&mp) != 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(getFrom(&mp) & 0xffffffff);
+            DEBUG_MSG("We last saw this node (%u), %u sec ago\n", mp.from & 0xffffffff, (millis() - sawTime) / 1000);
+
+            if (mp.decoded.portnum == PortNum_UNKNOWN_APP) {
+                DEBUG_MSG("Packet came from - PortNum_UNKNOWN_APP\n");
+            } else if (mp.decoded.portnum == PortNum_TEXT_MESSAGE_APP) {
+                DEBUG_MSG("Packet came from - PortNum_TEXT_MESSAGE_APP\n");
+
+                storeForwardPlugin->historyAdd(&mp);
+
+            } else if (mp.decoded.portnum == PortNum_REMOTE_HARDWARE_APP) {
+                DEBUG_MSG("Packet came from - PortNum_REMOTE_HARDWARE_APP\n");
+            } else if (mp.decoded.portnum == PortNum_POSITION_APP) {
+                DEBUG_MSG("Packet came from - PortNum_POSITION_APP\n");
+            } else if (mp.decoded.portnum == PortNum_NODEINFO_APP) {
+                DEBUG_MSG("Packet came from - PortNum_NODEINFO_APP\n");
+            } else if (mp.decoded.portnum == PortNum_REPLY_APP) {
+                DEBUG_MSG("Packet came from - PortNum_REPLY_APP\n");
+            } else if (mp.decoded.portnum == PortNum_IP_TUNNEL_APP) {
+                DEBUG_MSG("Packet came from - PortNum_IP_TUNNEL_APP\n");
+            } else if (mp.decoded.portnum == PortNum_SERIAL_APP) {
+                DEBUG_MSG("Packet came from - PortNum_SERIAL_APP\n");
+            } else if (mp.decoded.portnum == PortNum_STORE_FORWARD_APP) {
+                DEBUG_MSG("Packet came from - PortNum_STORE_FORWARD_APP\n");
+            } else if (mp.decoded.portnum == PortNum_RANGE_TEST_APP) {
+                DEBUG_MSG("Packet came from - PortNum_RANGE_TEST_APP\n");
+            } else if (mp.decoded.portnum == PortNum_PRIVATE_APP) {
+                DEBUG_MSG("Packet came from - PortNum_PRIVATE_APP\n");
+            } else if (mp.decoded.portnum == PortNum_RANGE_TEST_APP) {
+                DEBUG_MSG("Packet came from - PortNum_RANGE_TEST_APP\n");
+            } else if (mp.decoded.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.portnum);
+            }
+
+            if ((millis() - sawTime) > STOREFORWARD_SEND_HISTORY_SHORT) {
+                // Node has been away for a while. 
+                storeForwardPlugin->historySend(sawTime, getFrom(&mp));
+            }
+        }
+
+    } 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;

src/portduino/CrossPlatformCryptoEngine.cpp

@@ -10,9 +10,6 @@ class CrossPlatformCryptoEngine : public CryptoEngine
 
     CTRCommon *ctr = NULL;
 
-    /// How many bytes in our key
-    uint8_t keySize = 0;
-
   public:
     CrossPlatformCryptoEngine() {}
 
@@ -27,21 +24,21 @@ class CrossPlatformCryptoEngine : public CryptoEngine
      * @param bytes a _static_ buffer that will remain valid for the life of this crypto instance (i.e. this class will cache the
      * provided pointer)
      */
-    virtual void setKey(size_t numBytes, uint8_t *bytes)
+    virtual void setKey(const CryptoKey &k)
     {
-        keySize = numBytes;
-        DEBUG_MSG("Installing AES%d key!\n", numBytes * 8);
+        CryptoEngine::setKey(k);
+        DEBUG_MSG("Installing AES%d key!\n", key.length * 8);
         if (ctr) {
             delete ctr;
             ctr = NULL;
         }
-        if (numBytes != 0) {
-            if (numBytes == 16)
+        if (key.length != 0) {
+            if (key.length == 16)
                 ctr = new CTR<AES128>();
             else
                 ctr = new CTR<AES256>();
 
-            ctr->setKey(bytes, numBytes);
+            ctr->setKey(key.bytes, key.length);
         }
     }
 
@@ -52,7 +49,7 @@ class CrossPlatformCryptoEngine : public CryptoEngine
      */
     virtual void encrypt(uint32_t fromNode, uint64_t packetNum, size_t numBytes, uint8_t *bytes)
     {
-        if (keySize != 0) {
+        if (key.length > 0) {
             uint8_t stream_block[16];
             static uint8_t scratch[MAX_BLOCKSIZE];
             size_t nc_off = 0;

version.properties

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