Merge pull request #783 from geeksville/mqtt

Mqtt

.github/workflows/main.yml

@@ -22,9 +22,6 @@ jobs:
       - name: Install extra python tools
         run: |
           pip install -U adafruit-nrfutil
-      - name: Install libs needed for linux build
-        run: |
-          sudo apt install -y libpsocksxx-dev
       - name: Build for tbeam
         run: platformio run -e tbeam
       - name: Build for heltec
@@ -36,6 +33,7 @@ jobs:
       - name: Integration test
         run: |
           .pio/build/native/program &
-          sleep 1
+          sleep 5
+          echo "Simulator started, launching python test..."
           python3 -c 'from meshtastic.test import testSimulator; testSimulator()'
 

.idea/workspace.xml

@@ -15,16 +15,15 @@
   <component name="ChangeListManager">
     <list default="true" id="58922733-b05b-4b90-9655-b9b18914977a" name="Default Changelist" comment="">
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/docs/software/TODO.md" beforeDir="false" afterPath="$PROJECT_DIR$/docs/software/TODO.md" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/proto" beforeDir="false" afterPath="$PROJECT_DIR$/proto" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/mesh/generated/mesh.pb.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/mesh/generated/mesh.pb.h" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/proto/docs/docs.md" beforeDir="false" afterPath="$PROJECT_DIR$/proto/docs/docs.md" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/mqtt/MQTT.h" beforeDir="false" afterPath="$PROJECT_DIR$/src/mqtt/MQTT.h" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
     <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
     <option name="LAST_RESOLUTION" value="IGNORE" />
   </component>
-  <component name="ExecutionTargetManager" SELECTED_TARGET="CMakeBuildProfile:native" />
   <component name="Git.Settings">
     <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
   </component>
@@ -49,7 +48,7 @@
     <property name="node.js.selected.package.tslint" value="(autodetect)" />
     <property name="settings.editor.selected.configurable" value="CMakeSettings" />
   </component>
-  <component name="RunManager" selected="PlatformIO.PlatformIO Upload">
+  <component name="RunManager" selected="GDB Remote Debug.gdbremote-localhost-2345">
     <configuration default="true" type="CLion_Remote" version="1" remoteCommand="tcp:localhost:2345" symbolFile="" sysroot="">
       <debugger kind="GDB" isBundled="true" />
       <method v="2" />
@@ -63,6 +62,11 @@
         <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
       </method>
     </configuration>
+    <configuration default="true" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" PASS_PARENT_ENVS_2="true">
+      <method v="2">
+        <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+      </method>
+    </configuration>
     <configuration default="true" type="GradleAppRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" PASS_PARENT_ENVS_2="true">
       <method v="2">
         <option name="com.jetbrains.cidr.cpp.gradle.execution.GradleNativeBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
@@ -96,6 +100,13 @@
       <workItem from="1615788663210" duration="6661000" />
       <workItem from="1615938346019" duration="1208000" />
       <workItem from="1615971126983" duration="5945000" />
+      <workItem from="1617115374907" duration="357000" />
+      <workItem from="1617115747078" duration="1391000" />
+      <workItem from="1617117632667" duration="307000" />
+      <workItem from="1617160691713" duration="1016000" />
+      <workItem from="1617279002260" duration="1626000" />
+      <workItem from="1617425689081" duration="1896000" />
+      <workItem from="1617437366919" duration="1182000" />
     </task>
     <servers />
   </component>
@@ -117,18 +128,33 @@
   <component name="XDebuggerManager">
     <breakpoint-manager>
       <breakpoints>
-        <line-breakpoint enabled="true" type="com.jetbrains.cidr.execution.debugger.OCBreakpointType">
-          <url>file://$PROJECT_DIR$/src/mesh/StreamAPI.cpp</url>
-          <line>20</line>
-          <option name="timeStamp" value="4" />
-        </line-breakpoint>
         <line-breakpoint enabled="true" type="com.jetbrains.cidr.execution.debugger.OCBreakpointType">
           <url>file://$PROJECT_DIR$/src/mesh/wifi/WiFiServerAPI.cpp</url>
           <line>53</line>
           <option name="timeStamp" value="6" />
         </line-breakpoint>
+        <line-breakpoint enabled="true" type="com.jetbrains.cidr.execution.debugger.OCBreakpointType">
+          <url>file://$PROJECT_DIR$/src/mesh/wifi/WiFiServerAPI.cpp</url>
+          <line>37</line>
+          <option name="timeStamp" value="7" />
+        </line-breakpoint>
+        <line-breakpoint enabled="true" type="com.jetbrains.cidr.execution.debugger.OCBreakpointType">
+          <url>file://$PROJECT_DIR$/src/mqtt/MQTT.cpp</url>
+          <line>84</line>
+          <option name="timeStamp" value="10" />
+        </line-breakpoint>
+        <line-breakpoint enabled="true" type="com.jetbrains.cidr.execution.debugger.OCBreakpointType">
+          <url>file://$PROJECT_DIR$/.pio/libdeps/native/PubSubClient/src/PubSubClient.cpp</url>
+          <line>468</line>
+          <option name="timeStamp" value="11" />
+        </line-breakpoint>
       </breakpoints>
     </breakpoint-manager>
+    <watches-manager>
+      <configuration name="CLion_Remote">
+        <watch expression="radioConfig" language="ObjectiveC" />
+      </configuration>
+    </watches-manager>
   </component>
   <component name="XSLT-Support.FileAssociations.UIState">
     <expand />

README.md

@@ -199,7 +199,7 @@ We'd love to have you join us on this merry little project. Please see our [deve
 
 # Credits
 
-This project is run by volunteers. Past contributors include:
+This project is run by volunteers. We are a friendly group and welcome any contribution (code fixes, documentation, features, bug reports etc...).  We try to be good about listing contributor names in release notes, but it has become unwieldy for the main-devs to keep updating the list below and we've neglected it too long.  If you'd like your name included in this list please send a pull request to edit this README and simply add your line yourself.  Thank you very much for your help!
 
 - @astro-arphid: Added support for 433MHz radios in europe.
 - @claesg: Various documentation fixes and 3D print enclosures

bin/build-all.sh

@@ -4,7 +4,7 @@ set -e
 
 VERSION=`bin/buildinfo.py`
 
-BOARDS_ESP32="tlora-v2 tlora-v1 tlora-v2-1-1.6 tbeam heltec tbeam0.7"
+BOARDS_ESP32="tlora-v2 tlora-v1 tlora_v1_3 tlora-v2-1-1.6 tbeam heltec tbeam0.7"
 #BOARDS_ESP32=tbeam
 
 # FIXME note nrf52840dk build is for some reason only generating a BIN file but not a HEX file nrf52840dk-geeksville is fine

bin/build-nightly.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+source ~/.bashrc
+
+# Meshtastic Nightly Build Script.
+#  McHamster (jm@casler.org)
+#
+# This is the script that is used for the nightly build server.
+#
+# It's probably not useful for most people, but you may want to run your own
+#   nightly builds.
+#
+# The last line of ~/.bashrc contains an inclusion of platformio in the path.
+#   Without this, the build script won't run from the crontab:
+#
+#    export PATH="$HOME/.platformio/penv/bin:$PATH" 
+#
+# The crontab contains:
+#  0 2 * * * cd ~/meshtastic/github/meshtastic && source "~/.bashrc"; ./build-nightly.sh > ~/cronout.txt 2> ~/cronout.txt
+
+cd Meshtastic-device
+
+git pull
+
+bin/build-all.sh
+
+date_stamp=$(date +'%Y-%m-%d')
+
+cd ..
+
+# TODO: Archive the same binaries used by the build-all script.
+#zip -r meshtastic_device_nightly_${date_stamp} Meshtastic-device/release/latest/bins
+cp Meshtastic-device/release/archive/`ls -t ./Meshtastic-device/release/archive/| head -1` meshtastic_device_nightly_${date_stamp}.zip
+
+# Copy the file to the webserver
+scp meshtastic_device_nightly_${date_stamp}.zip jm@10.11.12.20:/volume1/web/meshtastic/nightly_builds/
+
+# Delete the local copy
+rm meshtastic_device_nightly_${date_stamp}.zip

bin/device-install.sh

@@ -1,21 +1,24 @@
 #!/bin/sh
 
+PYTHON=${PYTHON:-$(which python3 python|head -n 1)}
+
 set -e
 
 # Usage info
 show_help() {
 cat << EOF
-Usage: ${0##*/} [-h] [-p ESPTOOL_PORT] [-f FILENAME]
+Usage: $(basename $0) [-h] [-p ESPTOOL_PORT] [-P PYTHON] [-f FILENAME|FILENAME]
 Flash image file to device, but first erasing and writing system information"
 
     -h               Display this help and exit
     -p ESPTOOL_PORT  Set the environment variable for ESPTOOL_PORT.  If not set, ESPTOOL iterates all ports (Dangerrous).
-    -f FILENAME         The .bin file to flash.  Custom to your device type and region.
+    -P PYTHON        Specify alternate python interpreter to use to invoke esptool. (Default: "$PYTHON")
+    -f FILENAME      The .bin file to flash.  Custom to your device type and region.
 EOF
 }
 
 
-while getopts ":h:p:f:" opt; do
+while getopts ":hp:P:f:" opt; do
     case "${opt}" in
         h)
             show_help
@@ -23,6 +26,8 @@ while getopts ":h:p:f:" opt; do
             ;;
         p)  export ESPTOOL_PORT=${OPTARG}
 	    ;;
+        P)  PYTHON=${OPTARG}
+            ;;
         f)  FILENAME=${OPTARG}
             ;;
         *)
@@ -34,12 +39,17 @@ while getopts ":h:p:f:" opt; do
 done
 shift "$((OPTIND-1))"
 
+[ -z "$FILENAME" -a -n "$1" ] && {
+    FILENAME=$1
+    shift
+}
+
 if [ -f "${FILENAME}" ]; then
 	echo "Trying to flash ${FILENAME}, but first erasing and writing system information"
-	esptool.py --baud 921600 erase_flash
-	esptool.py --baud 921600 write_flash 0x1000 system-info.bin
-    esptool.py --baud 921600 write_flash 0x00390000 spiffs-*.bin
-	esptool.py --baud 921600 write_flash 0x10000 ${FILENAME}
+	$PYTHON -m esptool --baud 921600 erase_flash
+	$PYTHON -m esptool --baud 921600 write_flash 0x1000 system-info.bin
+	$PYTHON -m esptool --baud 921600 write_flash 0x00390000 spiffs-*.bin
+	$PYTHON -m esptool --baud 921600 write_flash 0x10000 ${FILENAME}
 else
 	echo "Invalid file: ${FILENAME}"
 	show_help

bin/device-update.sh

@@ -1,19 +1,22 @@
 #!/bin/sh
 
+PYTHON=${PYTHON:-$(which python3 python|head -n 1)}
+
 # Usage info
 show_help() {
 cat << EOF
-Usage: ${0##*/} [-h] [-p ESPTOOL_PORT] -f FILENAME
+Usage: $(basename $0) [-h] [-p ESPTOOL_PORT] [-P PYTHON] [-f FILENAME|FILENAME]
 Flash image file to device, leave existing system intact."
 
     -h               Display this help and exit
     -p ESPTOOL_PORT  Set the environment variable for ESPTOOL_PORT.  If not set, ESPTOOL iterates all ports (Dangerrous).
-    -f FILENAME         The .bin file to flash.  Custom to your device type and region.
+    -P PYTHON        Specify alternate python interpreter to use to invoke esptool. (Default: "$PYTHON")
+    -f FILENAME      The .bin file to flash.  Custom to your device type and region.
 EOF
 }
 
 
-while getopts ":h:p:f:" opt; do
+while getopts ":hp:P:f:" opt; do
     case "${opt}" in
         h)
             show_help
@@ -21,6 +24,8 @@ while getopts ":h:p:f:" opt; do
             ;;
         p)  export ESPTOOL_PORT=${OPTARG}
 	    ;;
+        P)  PYTHON=${OPTARG}
+            ;;
         f)  FILENAME=${OPTARG}
             ;;
         *)
@@ -32,11 +37,16 @@ while getopts ":h:p:f:" opt; do
 done
 shift "$((OPTIND-1))"
 
+[ -z "$FILENAME" -a -n "$1" ] && {
+    FILENAME=$1
+    shift
+}
+
 if [ -f "${FILENAME}" ]; then
 	echo "Trying to flash update ${FILENAME}."
-	esptool.py --baud 921600 write_flash 0x10000 ${FILENAME}
+	$PYTHON -m esptool --baud 921600 write_flash 0x10000 ${FILENAME}
 	echo "Erasing the otadata partition, which will turn off flash flippy-flop and force the first image to be used"
-	esptool.py --baud 921600 erase_region 0xe000 0x2000
+	$PYTHON -m esptool --baud 921600 erase_region 0xe000 0x2000
 else
 	echo "Invalid file: ${FILENAME}"
 	show_help

bin/mqtt-listen.sh

@@ -0,0 +1,3 @@
+
+mosquitto_sub -h mqtt.meshtastic.org -v -t \$SYS/\# -t msh/+/stat/\# -t msh/+/json/\#
+# mosquitto_sub -h test.mosquitto.org -v -t mesh/\# -F "%j"

bin/mqtt-send-status.sh

@@ -0,0 +1 @@
+mosquitto_pub -h mqtt.meshtastic.org -u meshdev -P large4cats -t msh/1/stat/FakeNode -m online -d

bin/native-gdbserver.sh

@@ -1,3 +1,3 @@
 set -e
 pio run --environment native
-gdbserver --once localhost:2345 .pio/build/native/program
+gdbserver --once localhost:2345 .pio/build/native/program "$@"

bin/native-run.sh

@@ -1,3 +1,3 @@
 set -e
 pio run --environment native
-.pio/build/native/program
+.pio/build/native/program "$@"

bin/run-both.sh

@@ -1,11 +1,13 @@
 set -e 
 
-pio run
+TARG=tbeam
+
+pio run -e $TARG
 
 echo uploading to usb1
-pio run --upload-port /dev/ttyUSB1 -t upload &
+pio run --upload-port /dev/ttyUSB1 -t upload -e $TARG &
 
 echo uploading to usb0
-pio run --upload-port /dev/ttyUSB0 -t upload &
+pio run --upload-port /dev/ttyUSB0 -t upload -e $TARG &
 
-wait
+wait

boards/lora_isp4520.json

@@ -0,0 +1,48 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52832_s132_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DNRF52832_XXAA -DNRF52",
+    "f_cpu": "64000000L",
+    "mcu": "nrf52832",
+    "variant": "lora_isp4520",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS132",
+      "sd_name": "s132",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B7"
+    }
+  },
+  "connectivity": [
+    "bluetooth"
+  ],
+  "debug": {
+    "jlink_device": "nRF52832_xxAA",
+    "svd_path": "nrf52.svd"
+  },
+  "frameworks": [
+    "arduino"
+  ],
+  "name": "lora ISP4520",
+  "upload": {
+    "maximum_ram_size": 65536,
+    "maximum_size": 524288,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": [
+      "jlink",
+      "nrfjprog",
+      "nrfutil",
+      "stlink"
+    ]
+  },
+  "url": "",
+  "vendor": "PsiSoft"
+}

docs/software/TODO.md

@@ -4,28 +4,59 @@ You probably don't care about this section - skip to the next one.
 
 ## before next release
 
+* DONE remote admin busted? 
+* DONE check android code - @havealoha comments about odd sleep behavior
+* ABANDONED test github actions locally on linux
+* DONE fix github actions per sasha tip
+* tell ttgo to preinstall new bins
+* DONE sendtext busted in portduino, due to bytetime calculations
+* remove linux dependency in native build
+* DONE tcp stream problem in python+pordtuino, server thinks client dropped when client DID NOT DROP
+* DONE TCP mode for android, localhost is at 10.0.2.2
+* DONE make sure USB still works in android
+* add portduino builds to zip
+* add license to portduino and make announcement
+* DONE naks are being dropped (though enqueuedLocal) sometimes before phone/PC gets them
+* DONE have android fill in if local GPS has poor signal
+* optionally restrict position sends to a named channel
+* release to beta and amazon
+* add reference counting to mesh packets
+* allow multiple simultanteous phoneapi connections
+* DONE split position.time and last_heard
+* DONE update android app to use last_heard
+* DONE turn off bluetooth interface ENTIRELY while using serial API (was python client times out on connect sometimes)
+* DONE gps assistance from phone not working?
+* DONE test latest firmware update with is_router
+* DONE firmware OTA updates of is_router true nodes fails?
+* DONE add UI in android app to reset to defaults https://github.com/meshtastic/Meshtastic-Android/issues/263 
+* DONE TEST THIS! changing channels requires a reboot to take effect https://github.com/meshtastic/Meshtastic-device/issues/752 
+* DONE bug report with remote info request timing out
+* DONE retest channel changing in android (using sim?)
+* DONE move remote admin doc from forum into git
+* DONE check crashlytics
+* DONE ask for a documentation czar
 * DONE timestamps on oled screen are wrong - don't seem to be updating based on message rx (actually: this is expected behavior when no node on the mesh has GPS time)
 * DONE add ch-del
 * DONE channel hash suffixes are wrong on android
 * DONE before next relase: test empty channel sets on android
 * DONE channel sharing in android
 * DONE test 1.0 firmware update on android
-* DONE test 1.1 firmware update on android
-* test 1.2.10 firmware update on android
+* DONE test 1.1 firmwhttps://github.com/meshtastic/Meshtastic-Android/issues/271are update on android
+* DONE test 1.2.10 firmware update on android
 * DONE test link sharing on android
-* luxon bug report - seeing rx acks for nodes that are not on the network
-* document how to do remote admin
-* release py, android, device
-  
-## 1.2 cleanup & multichannel support:
+* FIXED? luxon bug report - seeing rx acks for nodes that are not on the network
+* DONE release py
+* DONE show GPS time only if we know what global time is
+* DONE android should always provide time to nodes - so that it is easier for the mesh to learn the current time
+
+## Multichannel support
 
 * DONE cleanup the external notification and serial plugins
 * non ack version of stress test fails sometimes!
-
-* tx fault test has a bug #734
+* tx fault test has a bug #734 - * turn off fault 8: https://github.com/meshtastic/Meshtastic-device/issues/734
 * DONE move device types into an enum in nodeinfo
-* fix android to use new device types for firmware update
-  
+* DONE fix android to use new device types for firmware update
+* nrf52 should preserve local time across reset
 * cdcacm bug on nrf52: emittx thinks it emitted but client sees nothing.  works again later
 * nrf52: segger logs have errors in formatting that should be impossible (because not going through serial, try stalling on segger)
 * DONE call RouterPlugin for *all* packets - not just Router packets
@@ -53,12 +84,11 @@ You probably don't care about this section - skip to the next one.
 * DONE release protobufs
 * DONE release to developers
 * DONE fix setch-fast in python tool
-* turn off fault 8: https://github.com/meshtastic/Meshtastic-device/issues/734
 * 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
+* DONE fix 1.1.50 android debug panel display
 * DONE test android channel setting
 * DONE release to users
 * DONE warn in android app about unset regions
@@ -67,19 +97,20 @@ You probably don't care about this section - skip to the next one.
 * DONE clean up python channel usage
 * DONE use bindToChannel to limit admin access for remote nodes
 * DONE move channels and radio config out of device settings
-* test remote info and remote settings changes
+* DONE test remote info and remote settings changes
 * make python tests more exhaustive
-* pick default random admin key
+* DONE 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
 * generalize the concept of "shortstrings" use it for both PSKs and well known channel names.  Possibly use a ShortString class.
+* use single byte 'well known' channel names for admin, gpio, etc...
+* use presence of gpio channel to enable gpio ops, same for serial etc...
+* DONE restrict gpio & serial & settings operations to the admin channel (unless local to the current node)
+* DONE add channel restrictions for plugins (and restrict routing plugin to the "control" channel)
+* stress test multi channel
+* DONE investigate @mc-hamster report of heap corruption
+* DONE use set-user from android
+* untrusted users should not be allowed to provide bogus times (via position broadcasts) to the rest of the mesh.  Invent a new lowest quality notion of UntrustedTime.
 * 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)
@@ -91,18 +122,21 @@ You probably don't care about this section - skip to the next one.
 * 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
+* DONE confirm we are still calling the plugins for messages inbound from the phone (or generated locally)
+* DONE confirm we are still multi hop routing flood broadcasts
+* DONE 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)
+* use reference counting and dynamic sizing for meshpackets. - use https://docs.microsoft.com/en-us/cpp/cpp/how-to-create-and-use-shared-ptr-instances?view=msvc-160 (already used in arduino)
+* let multiple PhoneAPI endpoints work at once
+* allow multiple simultaneous bluetooth connections (create the bluetooth phoneapi instance dynamically based on client id)
 * 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 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
@@ -113,44 +147,9 @@ You probably don't care about this section - skip to the next one.
   are allowed on any channel (this lets the local user do anything)."  Probably by adding a "secure_local_interface" settings bool.
 * DOUBLE CHECK android app can still upgrade 1.1 and 1.0 loads
  
-eink:
-
-* DONE check email of reported issues
-* DONE turn off vbus driving (in bootloader)
-* new battery level sensing
-* current draw no good
-* DONE: fix backlight
-* DONE - USB is busted because of power enable mode?
-* test CPU voltage? something is bad with RAM (removing eink module does not help)
-* test that board leaves bootloader always
-* test USB - works in bootloader
-* test LEDs
-* Test BME280
-* test gps
-* check GPS fast locking
-* tested! dlora
-* test eink backlight
-* tested! eink
-* test buttons
-* test battery charging
-* test serial flash
-* send updated app and bootloader image
-* OHH BME280!  THAT IS GREAT!
-* make new screen work, ask for datasheet
-* say I think you could ship this
-* leds seem busted
-* fix hw_model: "nrf52unknown"
-* use larger icon for meshtastic logo
-* send email about variants & faster flash programming - https://github.com/geeksville/Meshtastic-esp32/commit/f110225173a77326aac029321cdb6491bfa640f6
-* send PR for bootloader
-* fix nrf52 time/date
-* send new master bin file
-* send email about low power mode problems
-* support new flash chip in appload, possibly use low power mode
-* swbug! stuck busy tx occurred!
-  
 For app cleanup:
 
+* don't store redundant User admin or position broadcasts in the ToPhone queue (only keep one per sending node per proto type, and only most recent)
 * use structured logging to kep logs in ram.  Also send logs as packets to api clients
 * DONE writeup nice python options docs (common cases, link to protobuf docs)
 * have android app link to user manual
@@ -200,6 +199,44 @@ This should nicely help 'router' nodes do the right thing when long range, or if
 * turn on amazon reviews support
 * add a tablet layout (with map next to messages) in the android app
 
+# Completed
+
+## eink 1.0
+
+* DONE check email of reported issues
+* DONE turn off vbus driving (in bootloader)
+* new battery level sensing
+* current draw no good
+* DONE: fix backlight
+* DONE - USB is busted because of power enable mode?
+* test CPU voltage? something is bad with RAM (removing eink module does not help)
+* test that board leaves bootloader always
+* test USB - works in bootloader
+* test LEDs
+* Test BME280
+* test gps
+* check GPS fast locking
+* tested! dlora
+* test eink backlight
+* tested! eink
+* test buttons
+* test battery charging
+* test serial flash
+* send updated app and bootloader image
+* OHH BME280!  THAT IS GREAT!
+* make new screen work, ask for datasheet
+* say I think you could ship this
+* leds seem busted
+* fix hw_model: "nrf52unknown"
+* use larger icon for meshtastic logo
+* send email about variants & faster flash programming - https://github.com/geeksville/Meshtastic-esp32/commit/f110225173a77326aac029321cdb6491bfa640f6
+* send PR for bootloader
+* fix nrf52 time/date
+* send new master bin file
+* send email about low power mode problems
+* support new flash chip in appload, possibly use low power mode
+* swbug! stuck busy tx occurred!
+  
 # Old docs to merge
 
 MESH RADIO PROTOCOL

docs/software/android-too-old.md

@@ -2,12 +2,6 @@
 
 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.
+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 about once a year we have a "major protocol update" which requires all apps and devices to update to keep working with that version.  Version 1.2 in March 2021 was one of those updates.
 
-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.
+If you have problems/questions please post in our [forum](https://meshtastic.discourse.group) and some nice person will probably help.

docs/software/channels.md

@@ -0,0 +1,17 @@
+# Multiple channel support
+
+Version 1.2 of the software adds support for "multiple (simultaneous) channels".  The idea behind this feature is that a mesh can allow multiple users/groups to be share common mesh infrastructure.  Even including routing messages for others when no one except that subgroup of users has the encryption keys for their private channel.
+
+### What is the PRIMARY channel
+
+The way this works is that each node keeps a list of channels it knows about.  One of those channels (normally the first 1) is labelled as the "PRIMARY" channel.  The primary channel is the **only** channel that is used to set radio parameters.  i.e. this channel controls things like spread factor, coding rate, bandwidth etc... Indirectly this channel also is used to select the specific frequency that all members of this mesh are talking over.
+
+This channel may or may not have a PSK (encryption).  If you are providing mesh to 'the public' we recommend that you always leave this channel with its default psk.  The default PSK is technically encrypted (and random users sniffing the ether would have to use meshtastic to decode it), but the key is included in the github source code and you should assume any 'attacker' would have it.  But for a 'public' mesh you want this, because it allows anyone using meshtastic in your area to send packets through 'your' mesh.
+
+Note: Older meshtastic applications that don't yet understand multi-channel support will only show the user this channel.  
+
+### How to use SECONDARY channels
+
+Any channel you add after that PRIMARY channel is SECONDARY.  Secondary channels are used only for encyryption and (in the case of some special applications) security.  If you would like to have a private channel over a more public mesh, you probably want to create a SECONDARY channel.  When sharing that URL with your private group you will share the "Complete URL".  The complete URL includes your secondary channel (for encryption) and the primary channel (to provide radio/mesh access).
+
+Secondary channels **must** have a PSK (encryption).

docs/software/crypto.md

@@ -36,6 +36,14 @@ If you are reviewing our implementation, this is a brief statement of our method
 - Each 16 byte BLOCK for a packet has an incrementing COUNTER. COUNTER starts at zero for the first block of each packet.
 - The IV for each block is constructed by concatenating the NONCE as the upper 96 bits of the IV and the COUNTER as the bottom 32 bits. Since our packets are small counter portion will really never be higher than 32 (five bits).
 
+### Details on the nonce encoding
+
+(For those porting to other architectures)
+Bytes 0-3 of the nonce are the "packet number" in little-endian order
+Bytes 4-7 are currently zero
+Bytes 8-11 are the sending node ID in little-endian order
+Bytes 12-15 are currently zero
+
 ## Comments from reviewer #1
 
 This reviewer is a cryptography professional, but would like to remain anonymous. We thank them for their comments ;-):

docs/software/mqtt.md

@@ -12,14 +12,18 @@
       - [NODEID](#nodeid)
       - [USERID](#userid)
       - [CHANNELID](#channelid)
+      - [PORTID](#portid)
     - [Gateway nodes](#gateway-nodes)
-    - [Optional web services](#optional-web-services)
-      - [Public MQTT broker service](#public-mqtt-broker-service)
-      - [Riot.im messaging bridge](#riotim-messaging-bridge)
-    - [Deprecated concepts](#deprecated-concepts)
-      - [MESHID (deprecated)](#meshid-deprecated)
-      - [DESTCLASS (deprecated)](#destclass-deprecated)
-      - [DESTID (deprecated)](#destid-deprecated)
+    - [MQTTSimInterface](#mqttsiminterface)
+  - [Web services](#web-services)
+    - [Public MQTT broker service](#public-mqtt-broker-service)
+      - [Broker selection](#broker-selection)
+    - [Admin service](#admin-service)
+    - [Riot.im messaging bridge](#riotim-messaging-bridge)
+  - [Deprecated concepts](#deprecated-concepts)
+    - [MESHID (deprecated)](#meshid-deprecated)
+    - [DESTCLASS (deprecated)](#destclass-deprecated)
+    - [DESTID (deprecated)](#destid-deprecated)
   - [Rejected idea: RAW UDP](#rejected-idea-raw-udp)
   - [Development plan](#development-plan)
     - [Work items](#work-items)
@@ -68,17 +72,23 @@ Any gateway-device will contact the MQTT broker.
 
 ### Topics
 
-The "mesh/crypt/CHANNELID/NODEID/PORTID" [topic](https://www.hivemq.com/blog/mqtt-essentials-part-5-mqtt-topics-best-practices/) will be used for messages sent from/to a mesh.
+* The "/msh/1/c/CHANNELID/NODEID" [topic](https://www.hivemq.com/blog/mqtt-essentials-part-5-mqtt-topics-best-practices/) will be used for (encrypted) messages sent from/to a mesh. (The "1" in this path is for protocol version 1, other values are reserved. "c" is for "enCrypted")
 
 Gateway nodes will foward any MeshPacket from a local mesh channel with uplink_enabled.  The packet (encapsulated in a ServiceEnvelope) will remain encrypted with the key for the specified channel.  
 
-For any channels in the local node with downlink_enabled, the gateway node will forward packets from MQTT to the local mesh.  It will do this by subscribing to mesh/crypt/CHANNELID/# and forwarding relevant packets.
+For any channels in the gateway node with downlink_enabled, the gateway node will forward packets from MQTT to the local mesh.  It will do this by subscribing to msh/1/c/CHANNELID/# and forwarding relevant packets.
 
-If the channelid 'well known'/public it could be decrypted by a web service (if the web service was provided with the associated channel key), in which case it will be decrypted by a web service and appear at "mesh/clear/CHANNELID/NODEID/PORTID". Note: This is not in the initial deliverable. 
+* If the channelid 'well known'/public it could be decrypted by a web service (if the web service was provided with the associated channel key), in which case it will be decrypted by a web service and appear at "msh/1/CLEAR/CHANNELID/NODEID/PORTID". 
 
-FIXME, discuss how text message global mirroring could scale (or not)
+* If it was possible to republish on msh/1/CLEAR/... and the PORTID is wellknown (i.e. the protobufs needed for decoding it are in the master github), it will be decoded and republished as JSON on msh/1/JSON/CHANNELID/NODEID/PortName.  This is to facilitate the development of third party apps to visualize 'live' node positions and 'texts' (for users that have opted to send on those explicitly public channels).
+
+Note: Normally "CLEAR" is simply "clear" (for cleartext), but during development we might run **multiple** testing services, and in that case those service might appear using a different string here (i.e. "cleardev" etc...).  Similarly normally "JSON" is "json", but other values might be used.
+
+FIXME, consider how text message global mirroring could scale (or not)
 FIXME, possibly don't global mirror text messages - instead rely on matrix/riot? 
-FIXME, discuss possible attacks by griefers and how they can be prvented
+FIXME, consider possible attacks by griefers and how they can be prvented
+
+* The "/mesh/stat/NODEID" topic contains a simple string showing connection status of nodes.  We rely on the MQTT feature for automatically publishing special failrue messages to this topic when the device disconnects.
 
 #### Service Envelope
 
@@ -88,7 +98,7 @@ ServiceEnvelope will include the message, and full information about arrival tim
 
 #### NODEID
 
-The unique ID for a node. A hex string that starts with a ! symbol.
+The unique ID for a node. A 8 byte (16 character) hex string that starts with a ! symbol.
 
 #### USERID
 
@@ -96,7 +106,15 @@ A user ID string. This string is either a user ID if known or a nodeid to simply
 
 #### CHANNELID
 
-FIXME, figure out how channelids work
+For the time being we simply use the local "channel name" - which is not quite good enough.
+
+FIXME, figure out how channelids work in more detail.  They should generally be globally unique, but this is not a requirement.  If someone accidentially (or maliciously) sends data using a channel ID they do not 'own' they will still lacking a valid AES256 encryption, so it will be ignored by others.
+
+idea to be pondered: When the user clicks to enable uplink/downlink check the name they entered and 'claim' it on the server?
+
+#### PORTID
+
+Portid is used to descriminated between different packet types which are sent over a channel.  As used here it is an integer typically (but not necessarily) chosen from portnums.proto.
 
 ### Gateway nodes
 
@@ -107,31 +125,74 @@ Gateway nodes (via code running in the phone) will contain two tables to whiteli
 Since multiple gateway nodes might be connected to a single mesh, it is possible that duplicate messages will be published on any particular topic.  Therefore subscribers to these topics should
 deduplicate if needed by using the packet ID of each message.
 
-### Optional web services
 
-#### Public MQTT broker service
+### MQTTSimInterface
+
+This is a bit orthogonal from the main MQTT feature set, but a special simulated LoRa interface called MQTTSimInterface uses the
+MQTT messaging infrastructure to send "LoRa" packets between simulated nodes running on Linux.  This allows us to test radio topologies and code without having to use real hardware.
+
+This service uses the standard mesh/crypt/... topic, but it picks a special CHANNEL_ID.  That CHANNEL_ID is typcially of the form "simmesh_xxx".  
+
+FIXME: Figure out how to secure the creation and use of well known CHANNEL_IDs.
+
+
+## Web services
+
+### Public MQTT broker service
 
 An existing public [MQTT broker](https://mosquitto.org/) will be the default for this service, but clients can use any MQTT broker they choose. 
 
 FIXME - figure out how to avoid impersonation (because we are initially using a public mqtt server with no special security options).  FIXME, include some ideas on this in the ServiceEnvelope documentation.
 
-#### Riot.im messaging bridge
+#### Broker selection
+
+On a previous project I used mosqitto, which I liked, but the admin interface for programmatically managing access was ugly.  [This](https://www.openlogic.com/blog/activemq-vs-rabbitmq) article makes me think RabbitMQ might be best for us.
+
+Initially I will try to avoid using any non MQTT broker/library/API
+
+### Admin service
+
+(This is a WIP draft collection of not complete ideas)
+
+The admin service deals with misc global arbibration/access tasks.  It is actually reached **through** the MQTT broker, though for security we depend on that broker having a few specialized rules about who can post to or see particular topics (see below).
+
+Topics:
+
+* mesh/ta/# - all requests going towards the admin server (only the admin server can see this topic)
+* mesh/tn/NODEID/# - all responses/requests going towards a particlar gateway node (only this particular gateway node is allowed to see this topic)
+* mesh/to/NODEID/# - unsecured messages sent to a gateway node (any attacker can see this topic) - used only for "request gateway id" responses
+* mesh/ta/toadmin - a request to the admin server, payload is a ToAdmin protobuf
+* mesh/tn/NODEID/tonode - a request/response to a particular gateway node.  payload is a ToNode protobuf
+
+Operations provided via the ToAdmin/ToNode protocol:
+
+* Register a global channel ID (request a new channel ID).  Optionally include the AES key if you would like the web service to automatically decrypt in the cloud
+* Request gateway ID - the response is used to re-sign in to the broker.  
+
+Possibly might need public key encryption for the gateway request?  Since the response is sent to the mesh/to endpoint?  I would really like to use MQTT for all comms so I don't need yet another protocol/port from the device.
+
+Idea 1: A gateway ID/signin can only be assigned once per node ID.  If a user loses their signin info, they'll need to change their node number.  yucky.
+Idea 2: Instead gateway signins are assigned at "manufacture" time (and if lost, yes the user would need to "remanufacture" their node).  Possibly a simple web service (which can be accessed via the python install script?) that goes to an https endpoint, gets signin info (and server keeps a copy) and stores it in the device.  Hardware manufacturers could ask for N gateway IDs via the same API and get back a bunch of small files that could be programmed on each device.  Would include node id, etc...  Investigate alternatives like storing a particular private key to allow each device to generate their own signin key and the server would trust it by checking against a public key?
+
+TODO/FIXME: look into mqtt broker options, possibly find one with better API support than mosquitto?
+
+### Riot.im messaging bridge
 
 @Geeksville will run a riot.im bridge that talks to the public MQTT broker and sends/receives into the riot.im network.
 
 There is apparently [already](https://github.com/derEisele/tuple) a riot.im [bridge](https://matrix.org/bridges/) for MQTT. That will possibly need to be customized a bit. But by doing this, we should be able to let random riot.im users send/receive messages to/from any meshtastic device. (FIXME ponder security).  See this [issue](https://github.com/meshtastic/Meshtastic-Android/issues/2#issuecomment-645660990) with discussion with the dev.
 
-### Deprecated concepts
+## Deprecated concepts
 
 You can ignore these for now...
 
-#### MESHID (deprecated)
+### MESHID (deprecated)
 
 Earlier drafts of this document included the concept of a MESHID.  That concept has been removed for now, but might be useful in the future.  The old idea is listed below:
 
 A unique ID for this mesh. There will be some sort of key exchange process so that the mesh ID can not be impersonated by other meshes. 
 
-#### DESTCLASS (deprecated)
+### DESTCLASS (deprecated)
 
 Earlier drafts of this document included the concept of a DESTCLASS.  That concept has been removed for now, but might be useful in the future.  The old idea is listed below:
 
@@ -145,7 +206,7 @@ The type of DESTID this message should be delivered to. A short one letter seque
 | S      | SMS gateway, DESTID is a phone number to reach via Twilio.com |
 | E      | Emergency message, see bug #fixme for more context            |
 
-#### DESTID (deprecated)
+### DESTID (deprecated)
 
 Earlier drafts of this document included the concept of a DESTCLASS.  That concept has been removed for now, but might be useful in the future.  The old idea is listed below:
 

docs/software/plugins/RangeTestPlugin.md

@@ -26,7 +26,7 @@ These are the settings that can be configured.
 
 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:
+The first thing to do is to turn on the plugin. The device will need to be restarted after appling the settings. With the plugin turned on, the other settings will be available:
 
 	range_test_plugin_enabled = 1
 
@@ -63,6 +63,36 @@ Be sure to turn off either the plugin configured as a sender or the device where
 
 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.
 
+# Application Examples
+
+## Google Integration
+
+@jfirwin on our forum [meshtastic.discourse.org](https://meshtastic.discourse.group/t/new-plugin-rangetestplugin/2591/49?u=mc-hamster) shared how to integrate the resulting csv file with Google Products.
+
+### Earth
+
+Steps:
+
+1. [Download](https://www.google.com/earth/versions/#download-pro) 1 and open Google Earth
+   1. Select File > Import
+   2. Select CSV
+   3. Select Delimited, Comma
+   4. Make sure the button that states “This dataset does not contain latitude/longitude information, but street addresses” is unchecked
+   5. Select “rx lat” & “rx long” for the appropriate lat/lng fields
+   6. Click finish
+2. When it prompts you to create a style template, click yes.
+   1. Set the name field to whichever column you want to be displayed on the map (don’t worry about this too much, when you click on an icon, all the relavant data appears)
+   2. select a color, icon, etc. and hit ok.
+
+Your data will load onto the map, make sure to click the checkbox next to your dataset in the sidebar to view it.
+
+### My Maps
+
+You can use [My Maps](http://mymaps.google.com/). It takes CSVs and the whole interface is much easier to work with.
+
+Google has instructions on how to do that [here](https://support.google.com/mymaps/answer/3024836?co=GENIE.Platform%3DDesktop&hl=en#zippy=%2Cstep-prepare-your-info%2Cstep-import-info-into-the-map).
+
+You can style the ranges differently based on the values, so you can have the pins be darker the if the SNR or RSSI (if that gets added) is higher. 
 
 # Known Problems
 

docs/software/rak-wizblock.md

@@ -0,0 +1,19 @@
+# RAK Wireless RisBlock
+
+https://docs.rakwireless.com/Product-Categories/WisBlock/Quickstart/#wisblock-base-2
+
+GPS module:
+Supposedly "Install in slot A only" but I think installing on the back would fit better with the OLED.  FIXME.
+https://docs.rakwireless.com/Product-Categories/WisBlock/RAK1910/Overview/#product-description
+
+ST KPS22HB
+baro sensor
+https://docs.rakwireless.com/Product-Categories/WisBlock/RAK1902/Overview/#product-description
+
+OLED
+https://docs.rakwireless.com/Product-Categories/WisBlock/RAK1921/Overview/#product-features
+Must be installed on the front for the I2C wires to lineup
+
+Solar enclosure
+https://docs.rakwireless.com/Product-Categories/Accessories/RAKBox-B2/Overview/#product-description
+

docs/software/remote-admin.md

@@ -0,0 +1,121 @@
+# Remote node administration
+
+This is the first documentation for how to use the [multiple channels](channels.md) feature to enable remote adminstration of meshtastic nodes.  i.e. let you talk through the mesh to some far away node and change that nodes settings.  This is an advanced feature that (currently) few users would need.  Also, keep in mind it is possible (if you are not careful) to assign settings to that remote node that cause it to completely drop off of your mesh.
+
+Btw: I promised to document how multi-channel is now used to secure remote GPIO/serial access.  But probably best to debug these instructions first, so I'll wait on that.  If you **do** need to use remote GPIO/serial now, just follow these instructions but name your new channel "gpio" or "serial".
+
+## Creating the "admin" channel
+
+Okay - now that we've summarized what multiple-channel support is, we can move on to using it to provide remote administrative access to a node.
+
+By default, nodes will **only** respond to adminstrative commands via the local USB/bluetooth/TCP interface.  This provides basic security to prevent unauthorized access.  This is actually how 'normal' administration and settings changes work.  The only difference for the remote case is that we are sending those commands over the mesh.
+
+Before a node will allow remote admin access, it must find a channel 
+```
+meshtastic --info
+Connected to radio
+...
+Channels:
+  PRIMARY psk=default { "modemConfig": "Bw125Cr48Sf4096", "psk": "AQ==" }
+
+Primary channel URL: https://www.meshtastic.org/d/#CgUYAyIBAQ
+```
+
+So from this output you see that this node knows about only one channel and that its PSK is set to the default value.
+
+But if you then add an admin channel (with "meshtastic --ch-add admin").  Note: the name is important it must be "admin" (sorry):
+
+Your channels will now look like this:
+```
+meshtastic --ch-add admin
+Connected to radio
+Writing modified channels to device
+
+meshtastic --info
+Connected to radio
+...
+Channels:
+  PRIMARY psk=default { "modemConfig": "Bw125Cr48Sf4096", "psk": "AQ==" }
+  SECONDARY psk=secret { "psk": "HW7E3nMbiNbvr6MhsDonLCmj7eSAhttzjbIx/r5OQmg=", "name": "admin" }
+
+Primary channel URL: https://www.meshtastic.org/d/#CgUYAyIBAQ
+Complete URL (includes all channels): https://www.meshtastic.org/d/#CgUYAyIBAQopIiAdbsTecxuI1u-voyGwOicsKaPt5ICG23ONsjH-vk5CaCoFYWRtaW4
+```
+
+Notice that now we have a new secondary channel.  Also, the "--info" option prints out TWO URLs.  The "complete URL" includes all of the channels this node understands.  You should consider this URL something you should be very cautious about sharing.  In the case of remote adminstration, you only need the node you want to adminster and the node you are locally connected to know this new "admin" channel.
+
+## Sharing the admin channel with other nodes
+
+I'm going to assume you've already created the admin channel on your "local node" i.e. the meshtastic node sitting on your desk at your home.  But now you want to enable access on the "remote node" you want to eventually have far away from you.
+
+For this step you need physical access to both the nodes.
+
+1. Create the "admin" channel on the "local node" using the instructions above.
+2. Copy the "Complete URL" someplace for permanent reference/access.
+3. Connect meshtastic-python to the "remote node" over the USB port.
+4. For the "remote node" type "meshtastic --seturl the-url-from-step-2".
+5. Run "meshtastic --info" and confirm that the "Complete URL" is the same for both of the nodes.
+6. Done!
+
+At this point you can take your remote node and install it far away and still be able to change any of its settings.
+
+## Remotely administering your node
+
+Now that both your local node and the remote node contain your secret admin channel key, you can do things like this:
+
+Get the node list from the local node.
+
+```
+meshtastic --nodes
+Connected to radio
+/----------------------------------------------------------------------------------------------------------\
+|N|    User    |AKA|   ID    |        Position        |Battery|   SNR   |     LastHeard     |    Since     |
+|-+------------+---+---------+------------------------+-------+---------+-------------------+--------------|
+|1|Unknown 9058|?58|!28979058|25.0382°, 121.5731°, N/A|  N/A  |-13.50 dB|2021-03-22 09:25:42|19 seconds ago|
+\----------------------------------------------------------------------------------------------------------/
+```
+
+Using the node ID from that list, send a message through the mesh telling that node to change its owner name.
+
+```
+meshtastic --dest \!28979058 --set-owner "Im Remote"
+Connected to radio
+Setting device owner to Im Remote
+INFO:root:Requesting configuration from remote node (this could take a while)
+```
+
+And you can now confirm via the local node that the remote node has changed:
+
+```
+meshtastic --nodes 
+Connected to radio
+/----------------------------------------------------------------------------------------------------\
+|N|  User   |AKA|   ID    |        Position        |Battery|  SNR  |     LastHeard     |    Since    |
+|-+---------+---+---------+------------------------+-------+-------+-------------------+-------------|
+|1|Im Remote|IR |!28979058|25.0382°, 121.5731°, N/A|  N/A  |8.75 dB|2021-03-22 09:35:42|3 minutes ago|
+\----------------------------------------------------------------------------------------------------/
+```
+
+Note: you can change **any** parameter, add channels or get info from the remote node.  Here's an example of setting ls_secs and printing the complete device info from the remote node.
+
+```
+meshtastic --dest \!28979058 --set ls_secs 301 --info
+Connected to radio
+INFO:root:Requesting configuration from remote node (this could take a while)
+Set ls_secs to 301
+Writing modified preferences to device
+
+
+Preferences: { "lsSecs": 301, "region": "TW" }
+
+Channels:
+  PRIMARY psk=default { "modemConfig": "Bw125Cr48Sf4096", "psk": "AQ==" }
+  SECONDARY psk=secret { "psk": "HW7E3nMbiNbvr6MhsDonLCmj7eSAhttzjbIx/r5OQmg=", "name": "admin" }
+
+Primary channel URL: https://www.meshtastic.org/d/#CgUYAyIBAQ
+Complete URL (includes all channels): https://www.meshtastic.org/d/#CgUYAyIBAQopIiAdbsTecxuI1u-voyGwOicsKaPt5ICG23ONsjH-vk5CaCoFYWRtaW4
+```
+
+## Areas for future development
+
+In the future we will add a "deadman timer" to this feature so that the remote node will revert any changes if you fail to send a special "commit changes" command.  This will protect against sending bad settings to nodes that you can't physically access.  Instead if the node does not receive a commit message within 10 minutes it will revert all changes and (hopefully) rejoin the mesh.

docs/software/remote-hardware-service.md

@@ -1,23 +1,60 @@
 # Remote Hardware Service
 
-FIXME - the following are a collection of notes moved from elsewhere.  We need to refactor these notes into actual documentation on the remote-hardware/gpio service.
+These are 'programmer focused' notes on using the "remote hardware" feature.  
 
-### 1.7.2. New 'no-code-IOT' mini-app
+Note: This feature uses a preinstalled plugin in the device code and associated commandline flags/classes in the python code.  You'll need to be running at least version 1.2.23 (or later) of the python and device code to use this feature.
 
-Add a new 'remote GPIO/serial port/SPI/I2C access' mini-app. This new standard app would use the MQTT messaging layer to let users (developers that don't need to write device code) do basic (potentially dangerous) operations remotely.
+You can get the latest python tool/library with "pip3 install --upgrade meshtastic" on Windows/Linux/OS-X.
 
-#### 1.7.2.1. Supported operations in the initial release
-
-Initially supported features for no-code-IOT.
+## Supported operations in the initial release
 
 - Set any GPIO
 - Read any GPIO
+- Receive notification of changes in any GPIO.
 
-#### 1.7.2.2. Supported operations eventually
+## Setup
 
-General ideas for no-code IOT.
+GPIO access is fundamentally 'dangerous' because invalid options can physically burn-up hardware.  To prevent access from untrusted users you must first make a "gpio" channel that is used for authenticated access to this feature.  You'll need to install this channel on both the local and remote node.
 
-- Subscribe for notification of GPIO input status change (i.e. when pin goes low, send my app a message)
-- Write/read N bytes over I2C/SPI bus Y (as one atomic I2C/SPI transaction)
-- Send N bytes out serial port Z
-- Subscribe for notification for when regex X matches the bytes that were received on serial port Z
+The procedure using the python command line tool is:
+
+1. Connect local device via USB
+2. "meshtastic --ch-add admin; meshtastic --info" thn copy the (long) "Complete URL" that info printed
+3. Connect remote device via USB (or use the remote admin feature to reach it through the mesh, but that's beyond the scope of this tutorial)
+4. "meshtastic --seturl theurlyoucopiedinstep2"
+
+Now both devices can talk over the "gpio" channel.
+
+## Doing GPIO operations
+
+Here's some examples using the command line tool.  
+
+## Using GPIOs from python
+
+You can programmatically do operations from your own python code by using the meshtastic "RemoteHardwareClient" class - see the python documentation for more details.
+
+Writing a GPIO
+```
+meshtastic  --port /dev/ttyUSB0 --gpio-wrb 4 1 --dest \!28979058 
+Connected to radio
+Writing GPIO mask 0x10 with value 0x10 to !28979058
+```
+
+Reading a GPIO
+```
+meshtastic --port /dev/ttyUSB0 --gpio-rd 0x10 --dest \!28979058 
+Connected to radio
+Reading GPIO mask 0x10 from !28979058
+GPIO read response gpio_value=16
+```
+
+Watching for GPIO changes:
+```
+meshtastic --port /dev/ttyUSB0 --gpio-watch 0x10 --dest \!28979058 
+Connected to radio
+Watching GPIO mask 0x10 from !28979058
+Received RemoteHardware typ=GPIOS_CHANGED, gpio_value=16
+Received RemoteHardware typ=GPIOS_CHANGED, gpio_value=0
+Received RemoteHardware typ=GPIOS_CHANGED, gpio_value=16
+< press ctrl-c to exit >
+```

docs/software/running-github-actions.md

@@ -0,0 +1,10 @@
+# Running github actions locally
+
+If you'd like to run the **same** integration tests we run on github but on your own machine, you can do the following.
+
+1. Install homebrew per https://brew.sh/
+2. Install https://github.com/nektos/act with "brew install act"
+3. cd into meshtastic-device and run "act"
+4. Select a "medium" sized image
+5. Alas - this "act" build **almost** works, but fails because it can't find lib/nanopb/include/pb.h!  So someone (you the reader? @geeksville ays hopefully...) needs to fix that before these instructions are complete.
+6. 

docs/software/sw-design.md

@@ -6,5 +6,7 @@ This is a mini design doc for developing the meshtastic software.
 * Our [project board](https://github.com/orgs/meshtastic/projects/1) - shows what things we are currently working on and remaining work items for the current release.
 * [Power Management](power.md)
 * [Mesh algorithm](mesh-alg.md)
+* [Channels](channels.md) - documentation on how multiple simultaneous channels are used
+* [Remote adminstration](remote-admin.md)
 * [External client API](device-api.md) and porting guide for new clients (iOS, python, etc...)
 * TODO: how to port the device code to a new device.

lib/nanopb/include/pb.h

@@ -11,7 +11,7 @@
  *****************************************************************/
 
 /* Enable support for dynamically allocated fields */
-/* #define PB_ENABLE_MALLOC 1 */
+#define PB_ENABLE_MALLOC 1
 
 /* Define this if your CPU / compiler combination does not support
  * unaligned memory access to packed structures. */
@@ -52,10 +52,9 @@
  * Feel free to look around and use the defined macros, though.   *
  ******************************************************************/
 
-
 /* Version of the nanopb library. Just in case you want to check it in
  * your own program. */
-#define NANOPB_VERSION nanopb-0.4.4
+#define NANOPB_VERSION nanopb - 0.4.4
 
 /* Include all the system headers needed by nanopb. You will need the
  * definitions of the following:
@@ -71,11 +70,11 @@
 #ifdef PB_SYSTEM_HEADER
 #include PB_SYSTEM_HEADER
 #else
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <string.h>
 #include <limits.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
 
 #ifdef PB_ENABLE_MALLOC
 #include <stdlib.h>
@@ -90,30 +89,30 @@ extern "C" {
  * This just reduces memory requirements, but is not required.
  */
 #if defined(PB_NO_PACKED_STRUCTS)
-    /* Disable struct packing */
-#   define PB_PACKED_STRUCT_START
-#   define PB_PACKED_STRUCT_END
-#   define pb_packed
+/* Disable struct packing */
+#define PB_PACKED_STRUCT_START
+#define PB_PACKED_STRUCT_END
+#define pb_packed
 #elif defined(__GNUC__) || defined(__clang__)
-    /* For GCC and clang */
-#   define PB_PACKED_STRUCT_START
-#   define PB_PACKED_STRUCT_END
-#   define pb_packed __attribute__((packed))
+/* For GCC and clang */
+#define PB_PACKED_STRUCT_START
+#define PB_PACKED_STRUCT_END
+#define pb_packed __attribute__((packed))
 #elif defined(__ICCARM__) || defined(__CC_ARM)
-    /* For IAR ARM and Keil MDK-ARM compilers */
-#   define PB_PACKED_STRUCT_START _Pragma("pack(push, 1)")
-#   define PB_PACKED_STRUCT_END _Pragma("pack(pop)")
-#   define pb_packed
+/* For IAR ARM and Keil MDK-ARM compilers */
+#define PB_PACKED_STRUCT_START _Pragma("pack(push, 1)")
+#define PB_PACKED_STRUCT_END _Pragma("pack(pop)")
+#define pb_packed
 #elif defined(_MSC_VER) && (_MSC_VER >= 1500)
-    /* For Microsoft Visual C++ */
-#   define PB_PACKED_STRUCT_START __pragma(pack(push, 1))
-#   define PB_PACKED_STRUCT_END __pragma(pack(pop))
-#   define pb_packed
+/* For Microsoft Visual C++ */
+#define PB_PACKED_STRUCT_START __pragma(pack(push, 1))
+#define PB_PACKED_STRUCT_END __pragma(pack(pop))
+#define pb_packed
 #else
-    /* Unknown compiler */
-#   define PB_PACKED_STRUCT_START
-#   define PB_PACKED_STRUCT_END
-#   define pb_packed
+/* Unknown compiler */
+#define PB_PACKED_STRUCT_START
+#define PB_PACKED_STRUCT_END
+#define pb_packed
 #endif
 
 /* Handly macro for suppressing unreferenced-parameter compiler warnings. */
@@ -126,11 +125,11 @@ extern "C" {
 #ifndef PB_PROGMEM
 #ifdef __AVR__
 #include <avr/pgmspace.h>
-#define PB_PROGMEM             PROGMEM
-#define PB_PROGMEM_READU32(x)  pgm_read_dword(&x)
+#define PB_PROGMEM PROGMEM
+#define PB_PROGMEM_READU32(x) pgm_read_dword(&x)
 #else
 #define PB_PROGMEM
-#define PB_PROGMEM_READU32(x)  (x)
+#define PB_PROGMEM_READU32(x) (x)
 #endif
 #endif
 
@@ -144,20 +143,20 @@ extern "C" {
  * in the place where the PB_STATIC_ASSERT macro was called.
  */
 #ifndef PB_NO_STATIC_ASSERT
-#  ifndef PB_STATIC_ASSERT
-#    if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
-       /* C11 standard _Static_assert mechanism */
-#      define PB_STATIC_ASSERT(COND,MSG) _Static_assert(COND,#MSG);
-#    else
-       /* Classic negative-size-array static assert mechanism */
-#      define PB_STATIC_ASSERT(COND,MSG) typedef char PB_STATIC_ASSERT_MSG(MSG, __LINE__, __COUNTER__)[(COND)?1:-1];
-#      define PB_STATIC_ASSERT_MSG(MSG, LINE, COUNTER) PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER)
-#      define PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER) pb_static_assertion_##MSG##_##LINE##_##COUNTER
-#    endif
-#  endif
+#ifndef PB_STATIC_ASSERT
+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+/* C11 standard _Static_assert mechanism */
+#define PB_STATIC_ASSERT(COND, MSG) _Static_assert(COND, #MSG);
 #else
-   /* Static asserts disabled by PB_NO_STATIC_ASSERT */
-#  define PB_STATIC_ASSERT(COND,MSG)
+/* Classic negative-size-array static assert mechanism */
+#define PB_STATIC_ASSERT(COND, MSG) typedef char PB_STATIC_ASSERT_MSG(MSG, __LINE__, __COUNTER__)[(COND) ? 1 : -1];
+#define PB_STATIC_ASSERT_MSG(MSG, LINE, COUNTER) PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER)
+#define PB_STATIC_ASSERT_MSG_(MSG, LINE, COUNTER) pb_static_assertion_##MSG##_##LINE##_##COUNTER
+#endif
+#endif
+#else
+/* Static asserts disabled by PB_NO_STATIC_ASSERT */
+#define PB_STATIC_ASSERT(COND, MSG)
 #endif
 
 /* Number of required fields to keep track of. */
@@ -186,8 +185,8 @@ typedef uint_least8_t pb_type_t;
 /**** Field data types ****/
 
 /* Numeric types */
-#define PB_LTYPE_BOOL    0x00U /* bool */
-#define PB_LTYPE_VARINT  0x01U /* int32, int64, enum, bool */
+#define PB_LTYPE_BOOL 0x00U    /* bool */
+#define PB_LTYPE_VARINT 0x01U  /* int32, int64, enum, bool */
 #define PB_LTYPE_UVARINT 0x02U /* uint32, uint64 */
 #define PB_LTYPE_SVARINT 0x03U /* sint32, sint64 */
 #define PB_LTYPE_FIXED32 0x04U /* fixed32, sfixed32, float */
@@ -234,31 +233,30 @@ typedef uint_least8_t pb_type_t;
 #define PB_HTYPE_SINGULAR 0x10U
 #define PB_HTYPE_REPEATED 0x20U
 #define PB_HTYPE_FIXARRAY 0x20U
-#define PB_HTYPE_ONEOF    0x30U
-#define PB_HTYPE_MASK     0x30U
+#define PB_HTYPE_ONEOF 0x30U
+#define PB_HTYPE_MASK 0x30U
 
 /**** Field allocation types ****/
- 
-#define PB_ATYPE_STATIC   0x00U
-#define PB_ATYPE_POINTER  0x80U
-#define PB_ATYPE_CALLBACK 0x40U
-#define PB_ATYPE_MASK     0xC0U
 
-#define PB_ATYPE(x) ((x) & PB_ATYPE_MASK)
-#define PB_HTYPE(x) ((x) & PB_HTYPE_MASK)
-#define PB_LTYPE(x) ((x) & PB_LTYPE_MASK)
-#define PB_LTYPE_IS_SUBMSG(x) (PB_LTYPE(x) == PB_LTYPE_SUBMESSAGE || \
-                               PB_LTYPE(x) == PB_LTYPE_SUBMSG_W_CB)
+#define PB_ATYPE_STATIC 0x00U
+#define PB_ATYPE_POINTER 0x80U
+#define PB_ATYPE_CALLBACK 0x40U
+#define PB_ATYPE_MASK 0xC0U
+
+#define PB_ATYPE(x) ((x)&PB_ATYPE_MASK)
+#define PB_HTYPE(x) ((x)&PB_HTYPE_MASK)
+#define PB_LTYPE(x) ((x)&PB_LTYPE_MASK)
+#define PB_LTYPE_IS_SUBMSG(x) (PB_LTYPE(x) == PB_LTYPE_SUBMESSAGE || PB_LTYPE(x) == PB_LTYPE_SUBMSG_W_CB)
 
 /* Data type used for storing sizes of struct fields
  * and array counts.
  */
 #if defined(PB_FIELD_32BIT)
-    typedef uint32_t pb_size_t;
-    typedef int32_t pb_ssize_t;
+typedef uint32_t pb_size_t;
+typedef int32_t pb_ssize_t;
 #else
-    typedef uint_least16_t pb_size_t;
-    typedef int_least16_t pb_ssize_t;
+typedef uint_least16_t pb_size_t;
+typedef int_least16_t pb_ssize_t;
 #endif
 #define PB_SIZE_MAX ((pb_size_t)-1)
 
@@ -279,7 +277,7 @@ typedef struct pb_field_iter_s pb_field_iter_t;
 typedef struct pb_msgdesc_s pb_msgdesc_t;
 struct pb_msgdesc_s {
     const uint32_t *field_info;
-    const pb_msgdesc_t * const * submsg_info;
+    const pb_msgdesc_t *const *submsg_info;
     const pb_byte_t *default_value;
 
     bool (*field_callback)(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_iter_t *field);
@@ -291,22 +289,22 @@ struct pb_msgdesc_s {
 
 /* Iterator for message descriptor */
 struct pb_field_iter_s {
-    const pb_msgdesc_t *descriptor;  /* Pointer to message descriptor constant */
-    void *message;                   /* Pointer to start of the structure */
+    const pb_msgdesc_t *descriptor; /* Pointer to message descriptor constant */
+    void *message;                  /* Pointer to start of the structure */
 
-    pb_size_t index;                 /* Index of the field */
-    pb_size_t field_info_index;      /* Index to descriptor->field_info array */
-    pb_size_t required_field_index;  /* Index that counts only the required fields */
-    pb_size_t submessage_index;      /* Index that counts only submessages */
+    pb_size_t index;                /* Index of the field */
+    pb_size_t field_info_index;     /* Index to descriptor->field_info array */
+    pb_size_t required_field_index; /* Index that counts only the required fields */
+    pb_size_t submessage_index;     /* Index that counts only submessages */
 
-    pb_size_t tag;                   /* Tag of current field */
-    pb_size_t data_size;             /* sizeof() of a single item */
-    pb_size_t array_size;            /* Number of array entries */
-    pb_type_t type;                  /* Type of current field */
+    pb_size_t tag;        /* Tag of current field */
+    pb_size_t data_size;  /* sizeof() of a single item */
+    pb_size_t array_size; /* Number of array entries */
+    pb_type_t type;       /* Type of current field */
 
-    void *pField;                    /* Pointer to current field in struct */
-    void *pData;                     /* Pointer to current data contents. Different than pField for arrays and pointers. */
-    void *pSize;                     /* Pointer to count/has field */
+    void *pField; /* Pointer to current field in struct */
+    void *pData;  /* Pointer to current data contents. Different than pField for arrays and pointers. */
+    void *pSize;  /* Pointer to count/has field */
 
     const pb_msgdesc_t *submsg_desc; /* For submessage fields, pointer to field descriptor for the submessage. */
 };
@@ -329,7 +327,11 @@ PB_STATIC_ASSERT(sizeof(uint64_t) == 2 * sizeof(uint32_t), UINT64_T_WRONG_SIZE)
  * It has the number of bytes in the beginning, and after that an array.
  * Note that actual structs used will have a different length of bytes array.
  */
-#define PB_BYTES_ARRAY_T(n) struct { pb_size_t size; pb_byte_t bytes[n]; }
+#define PB_BYTES_ARRAY_T(n)                                                                                                      \
+    struct {                                                                                                                     \
+        pb_size_t size;                                                                                                          \
+        pb_byte_t bytes[n];                                                                                                      \
+    }
 #define PB_BYTES_ARRAY_T_ALLOCSIZE(n) ((size_t)n + offsetof(pb_bytes_array_t, bytes))
 
 struct pb_bytes_array_s {
@@ -363,9 +365,9 @@ struct pb_callback_s {
      */
     union {
         bool (*decode)(pb_istream_t *stream, const pb_field_t *field, void **arg);
-        bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, void * const *arg);
+        bool (*encode)(pb_ostream_t *stream, const pb_field_t *field, void *const *arg);
     } funcs;
-    
+
     /* Free arg for use by callback */
     void *arg;
 };
@@ -373,12 +375,7 @@ struct pb_callback_s {
 extern bool pb_default_field_callback(pb_istream_t *istream, pb_ostream_t *ostream, const pb_field_t *field);
 
 /* Wire types. Library user needs these only in encoder callbacks. */
-typedef enum {
-    PB_WT_VARINT = 0,
-    PB_WT_64BIT  = 1,
-    PB_WT_STRING = 2,
-    PB_WT_32BIT  = 5
-} pb_wire_type_t;
+typedef enum { PB_WT_VARINT = 0, PB_WT_64BIT = 1, PB_WT_STRING = 2, PB_WT_32BIT = 5 } pb_wire_type_t;
 
 /* Structure for defining the handling of unknown/extension fields.
  * Usually the pb_extension_type_t structure is automatically generated,
@@ -395,9 +392,8 @@ struct pb_extension_type_s {
      * If you run into an error, return false.
      * Set to NULL for default handler.
      */
-    bool (*decode)(pb_istream_t *stream, pb_extension_t *extension,
-                   uint32_t tag, pb_wire_type_t wire_type);
-    
+    bool (*decode)(pb_istream_t *stream, pb_extension_t *extension, uint32_t tag, pb_wire_type_t wire_type);
+
     /* Called once after all regular fields have been encoded.
      * If you have something to write, do so and return true.
      * If you do not have anything to write, just return true.
@@ -405,7 +401,7 @@ struct pb_extension_type_s {
      * Set to NULL for default handler.
      */
     bool (*encode)(pb_ostream_t *stream, const pb_extension_t *extension);
-    
+
     /* Free field for use by the callback. */
     const void *arg;
 };
@@ -414,11 +410,11 @@ struct pb_extension_s {
     /* Type describing the extension field. Usually you'll initialize
      * this to a pointer to the automatically generated structure. */
     const pb_extension_type_t *type;
-    
+
     /* Destination for the decoded data. This must match the datatype
      * of the extension field. */
     void *dest;
-    
+
     /* Pointer to the next extension handler, or NULL.
      * If this extension does not match a field, the next handler is
      * automatically called. */
@@ -429,17 +425,20 @@ struct pb_extension_s {
     bool found;
 };
 
-#define pb_extension_init_zero {NULL,NULL,NULL,false}
+#define pb_extension_init_zero                                                                                                   \
+    {                                                                                                                            \
+        NULL, NULL, NULL, false                                                                                                  \
+    }
 
 /* Memory allocation functions to use. You can define pb_realloc and
  * pb_free to custom functions if you want. */
 #ifdef PB_ENABLE_MALLOC
-#   ifndef pb_realloc
-#       define pb_realloc(ptr, size) realloc(ptr, size)
-#   endif
-#   ifndef pb_free
-#       define pb_free(ptr) free(ptr)
-#   endif
+#ifndef pb_realloc
+#define pb_realloc(ptr, size) realloc(ptr, size)
+#endif
+#ifndef pb_free
+#define pb_free(ptr) free(ptr)
+#endif
 #endif
 
 /* This is used to inform about need to regenerate .pb.h/.pb.c files. */
@@ -447,7 +446,7 @@ struct pb_extension_s {
 
 /* These macros are used to declare pb_field_t's in the constant array. */
 /* Size of a structure member, in bytes. */
-#define pb_membersize(st, m) (sizeof ((st*)0)->m)
+#define pb_membersize(st, m) (sizeof((st *)0)->m)
 /* Number of entries in an array. */
 #define pb_arraysize(st, m) (pb_membersize(st, m) / pb_membersize(st, m[0]))
 /* Delta from start of one member to the start of another member. */
@@ -457,126 +456,115 @@ struct pb_extension_s {
 #define PB_EXPAND(x) x
 
 /* Binding of a message field set into a specific structure */
-#define PB_BIND(msgname, structname, width) \
-    const uint32_t structname ## _field_info[] PB_PROGMEM = \
-    { \
-        msgname ## _FIELDLIST(PB_GEN_FIELD_INFO_ ## width, structname) \
-        0 \
-    }; \
-    const pb_msgdesc_t* const structname ## _submsg_info[] = \
-    { \
-        msgname ## _FIELDLIST(PB_GEN_SUBMSG_INFO, structname) \
-        NULL \
-    }; \
-    const pb_msgdesc_t structname ## _msg = \
-    { \
-       structname ## _field_info, \
-       structname ## _submsg_info, \
-       msgname ## _DEFAULT, \
-       msgname ## _CALLBACK, \
-       0 msgname ## _FIELDLIST(PB_GEN_FIELD_COUNT, structname), \
-       0 msgname ## _FIELDLIST(PB_GEN_REQ_FIELD_COUNT, structname), \
-       0 msgname ## _FIELDLIST(PB_GEN_LARGEST_TAG, structname), \
-    }; \
-    msgname ## _FIELDLIST(PB_GEN_FIELD_INFO_ASSERT_ ## width, structname)
+#define PB_BIND(msgname, structname, width)                                                                                      \
+    const uint32_t structname##_field_info[] PB_PROGMEM = {msgname##_FIELDLIST(PB_GEN_FIELD_INFO_##width, structname) 0};        \
+    const pb_msgdesc_t *const structname##_submsg_info[] = {msgname##_FIELDLIST(PB_GEN_SUBMSG_INFO, structname) NULL};           \
+    const pb_msgdesc_t structname##_msg = {                                                                                      \
+        structname##_field_info,                                                                                                 \
+        structname##_submsg_info,                                                                                                \
+        msgname##_DEFAULT,                                                                                                       \
+        msgname##_CALLBACK,                                                                                                      \
+        0 msgname##_FIELDLIST(PB_GEN_FIELD_COUNT, structname),                                                                   \
+        0 msgname##_FIELDLIST(PB_GEN_REQ_FIELD_COUNT, structname),                                                               \
+        0 msgname##_FIELDLIST(PB_GEN_LARGEST_TAG, structname),                                                                   \
+    };                                                                                                                           \
+    msgname##_FIELDLIST(PB_GEN_FIELD_INFO_ASSERT_##width, structname)
 
 #define PB_GEN_FIELD_COUNT(structname, atype, htype, ltype, fieldname, tag) +1
-#define PB_GEN_REQ_FIELD_COUNT(structname, atype, htype, ltype, fieldname, tag) \
-    + (PB_HTYPE_ ## htype == PB_HTYPE_REQUIRED)
-#define PB_GEN_LARGEST_TAG(structname, atype, htype, ltype, fieldname, tag) \
-    * 0 + tag
+#define PB_GEN_REQ_FIELD_COUNT(structname, atype, htype, ltype, fieldname, tag) +(PB_HTYPE_##htype == PB_HTYPE_REQUIRED)
+#define PB_GEN_LARGEST_TAG(structname, atype, htype, ltype, fieldname, tag) *0 + tag
 
 /* X-macro for generating the entries in struct_field_info[] array. */
-#define PB_GEN_FIELD_INFO_1(structname, atype, htype, ltype, fieldname, tag) \
-    PB_FIELDINFO_1(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
-                   PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
+#define PB_GEN_FIELD_INFO_1(structname, atype, htype, ltype, fieldname, tag)                                                     \
+    PB_FIELDINFO_1(tag, PB_ATYPE_##atype | PB_HTYPE_##htype | PB_LTYPE_MAP_##ltype,                                              \
+                   PB_DATA_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                             \
+                   PB_DATA_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname),                                               \
+                   PB_SIZE_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                             \
+                   PB_ARRAY_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname))
 
-#define PB_GEN_FIELD_INFO_2(structname, atype, htype, ltype, fieldname, tag) \
-    PB_FIELDINFO_2(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
-                   PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
+#define PB_GEN_FIELD_INFO_2(structname, atype, htype, ltype, fieldname, tag)                                                     \
+    PB_FIELDINFO_2(tag, PB_ATYPE_##atype | PB_HTYPE_##htype | PB_LTYPE_MAP_##ltype,                                              \
+                   PB_DATA_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                             \
+                   PB_DATA_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname),                                               \
+                   PB_SIZE_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                             \
+                   PB_ARRAY_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname))
 
-#define PB_GEN_FIELD_INFO_4(structname, atype, htype, ltype, fieldname, tag) \
-    PB_FIELDINFO_4(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
-                   PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
+#define PB_GEN_FIELD_INFO_4(structname, atype, htype, ltype, fieldname, tag)                                                     \
+    PB_FIELDINFO_4(tag, PB_ATYPE_##atype | PB_HTYPE_##htype | PB_LTYPE_MAP_##ltype,                                              \
+                   PB_DATA_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                             \
+                   PB_DATA_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname),                                               \
+                   PB_SIZE_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                             \
+                   PB_ARRAY_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname))
 
-#define PB_GEN_FIELD_INFO_8(structname, atype, htype, ltype, fieldname, tag) \
-    PB_FIELDINFO_8(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
-                   PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
+#define PB_GEN_FIELD_INFO_8(structname, atype, htype, ltype, fieldname, tag)                                                     \
+    PB_FIELDINFO_8(tag, PB_ATYPE_##atype | PB_HTYPE_##htype | PB_LTYPE_MAP_##ltype,                                              \
+                   PB_DATA_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                             \
+                   PB_DATA_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname),                                               \
+                   PB_SIZE_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                             \
+                   PB_ARRAY_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname))
 
-#define PB_GEN_FIELD_INFO_AUTO(structname, atype, htype, ltype, fieldname, tag) \
-    PB_FIELDINFO_AUTO2(PB_FIELDINFO_WIDTH_AUTO(_PB_ATYPE_ ## atype, _PB_HTYPE_ ## htype, _PB_LTYPE_ ## ltype), \
-                   tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
-                   PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
+#define PB_GEN_FIELD_INFO_AUTO(structname, atype, htype, ltype, fieldname, tag)                                                  \
+    PB_FIELDINFO_AUTO2(PB_FIELDINFO_WIDTH_AUTO(_PB_ATYPE_##atype, _PB_HTYPE_##htype, _PB_LTYPE_##ltype), tag,                    \
+                       PB_ATYPE_##atype | PB_HTYPE_##htype | PB_LTYPE_MAP_##ltype,                                               \
+                       PB_DATA_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                         \
+                       PB_DATA_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname),                                           \
+                       PB_SIZE_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                         \
+                       PB_ARRAY_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname))
 
-#define PB_FIELDINFO_AUTO2(width, tag, type, data_offset, data_size, size_offset, array_size) \
+#define PB_FIELDINFO_AUTO2(width, tag, type, data_offset, data_size, size_offset, array_size)                                    \
     PB_FIELDINFO_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size)
 
-#define PB_FIELDINFO_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size) \
-    PB_FIELDINFO_ ## width(tag, type, data_offset, data_size, size_offset, array_size)
+#define PB_FIELDINFO_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size)                                    \
+    PB_FIELDINFO_##width(tag, type, data_offset, data_size, size_offset, array_size)
 
 /* X-macro for generating asserts that entries fit in struct_field_info[] array.
  * The structure of macros here must match the structure above in PB_GEN_FIELD_INFO_x(),
  * but it is not easily reused because of how macro substitutions work. */
-#define PB_GEN_FIELD_INFO_ASSERT_1(structname, atype, htype, ltype, fieldname, tag) \
-    PB_FIELDINFO_ASSERT_1(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
-                   PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
+#define PB_GEN_FIELD_INFO_ASSERT_1(structname, atype, htype, ltype, fieldname, tag)                                              \
+    PB_FIELDINFO_ASSERT_1(tag, PB_ATYPE_##atype | PB_HTYPE_##htype | PB_LTYPE_MAP_##ltype,                                       \
+                          PB_DATA_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                      \
+                          PB_DATA_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname),                                        \
+                          PB_SIZE_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                      \
+                          PB_ARRAY_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname))
 
-#define PB_GEN_FIELD_INFO_ASSERT_2(structname, atype, htype, ltype, fieldname, tag) \
-    PB_FIELDINFO_ASSERT_2(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
-                   PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
+#define PB_GEN_FIELD_INFO_ASSERT_2(structname, atype, htype, ltype, fieldname, tag)                                              \
+    PB_FIELDINFO_ASSERT_2(tag, PB_ATYPE_##atype | PB_HTYPE_##htype | PB_LTYPE_MAP_##ltype,                                       \
+                          PB_DATA_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                      \
+                          PB_DATA_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname),                                        \
+                          PB_SIZE_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                      \
+                          PB_ARRAY_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname))
 
-#define PB_GEN_FIELD_INFO_ASSERT_4(structname, atype, htype, ltype, fieldname, tag) \
-    PB_FIELDINFO_ASSERT_4(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
-                   PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
+#define PB_GEN_FIELD_INFO_ASSERT_4(structname, atype, htype, ltype, fieldname, tag)                                              \
+    PB_FIELDINFO_ASSERT_4(tag, PB_ATYPE_##atype | PB_HTYPE_##htype | PB_LTYPE_MAP_##ltype,                                       \
+                          PB_DATA_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                      \
+                          PB_DATA_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname),                                        \
+                          PB_SIZE_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                      \
+                          PB_ARRAY_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname))
 
-#define PB_GEN_FIELD_INFO_ASSERT_8(structname, atype, htype, ltype, fieldname, tag) \
-    PB_FIELDINFO_ASSERT_8(tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
-                   PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
+#define PB_GEN_FIELD_INFO_ASSERT_8(structname, atype, htype, ltype, fieldname, tag)                                              \
+    PB_FIELDINFO_ASSERT_8(tag, PB_ATYPE_##atype | PB_HTYPE_##htype | PB_LTYPE_MAP_##ltype,                                       \
+                          PB_DATA_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                      \
+                          PB_DATA_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname),                                        \
+                          PB_SIZE_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                      \
+                          PB_ARRAY_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname))
 
-#define PB_GEN_FIELD_INFO_ASSERT_AUTO(structname, atype, htype, ltype, fieldname, tag) \
-    PB_FIELDINFO_ASSERT_AUTO2(PB_FIELDINFO_WIDTH_AUTO(_PB_ATYPE_ ## atype, _PB_HTYPE_ ## htype, _PB_LTYPE_ ## ltype), \
-                   tag, PB_ATYPE_ ## atype | PB_HTYPE_ ## htype | PB_LTYPE_MAP_ ## ltype, \
-                   PB_DATA_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_DATA_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_SIZE_OFFSET_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname), \
-                   PB_ARRAY_SIZE_ ## atype(_PB_HTYPE_ ## htype, structname, fieldname))
+#define PB_GEN_FIELD_INFO_ASSERT_AUTO(structname, atype, htype, ltype, fieldname, tag)                                           \
+    PB_FIELDINFO_ASSERT_AUTO2(PB_FIELDINFO_WIDTH_AUTO(_PB_ATYPE_##atype, _PB_HTYPE_##htype, _PB_LTYPE_##ltype), tag,             \
+                              PB_ATYPE_##atype | PB_HTYPE_##htype | PB_LTYPE_MAP_##ltype,                                        \
+                              PB_DATA_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                  \
+                              PB_DATA_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname),                                    \
+                              PB_SIZE_OFFSET_##atype(_PB_HTYPE_##htype, structname, fieldname),                                  \
+                              PB_ARRAY_SIZE_##atype(_PB_HTYPE_##htype, structname, fieldname))
 
-#define PB_FIELDINFO_ASSERT_AUTO2(width, tag, type, data_offset, data_size, size_offset, array_size) \
+#define PB_FIELDINFO_ASSERT_AUTO2(width, tag, type, data_offset, data_size, size_offset, array_size)                             \
     PB_FIELDINFO_ASSERT_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size)
 
-#define PB_FIELDINFO_ASSERT_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size) \
-    PB_FIELDINFO_ASSERT_ ## width(tag, type, data_offset, data_size, size_offset, array_size)
+#define PB_FIELDINFO_ASSERT_AUTO3(width, tag, type, data_offset, data_size, size_offset, array_size)                             \
+    PB_FIELDINFO_ASSERT_##width(tag, type, data_offset, data_size, size_offset, array_size)
 
-#define PB_DATA_OFFSET_STATIC(htype, structname, fieldname) PB_DO ## htype(structname, fieldname)
-#define PB_DATA_OFFSET_POINTER(htype, structname, fieldname) PB_DO ## htype(structname, fieldname)
-#define PB_DATA_OFFSET_CALLBACK(htype, structname, fieldname) PB_DO ## htype(structname, fieldname)
+#define PB_DATA_OFFSET_STATIC(htype, structname, fieldname) PB_DO##htype(structname, fieldname)
+#define PB_DATA_OFFSET_POINTER(htype, structname, fieldname) PB_DO##htype(structname, fieldname)
+#define PB_DATA_OFFSET_CALLBACK(htype, structname, fieldname) PB_DO##htype(structname, fieldname)
 #define PB_DO_PB_HTYPE_REQUIRED(structname, fieldname) offsetof(structname, fieldname)
 #define PB_DO_PB_HTYPE_SINGULAR(structname, fieldname) offsetof(structname, fieldname)
 #define PB_DO_PB_HTYPE_ONEOF(structname, fieldname) offsetof(structname, PB_ONEOF_NAME(FULL, fieldname))
@@ -584,16 +572,17 @@ struct pb_extension_s {
 #define PB_DO_PB_HTYPE_REPEATED(structname, fieldname) offsetof(structname, fieldname)
 #define PB_DO_PB_HTYPE_FIXARRAY(structname, fieldname) offsetof(structname, fieldname)
 
-#define PB_SIZE_OFFSET_STATIC(htype, structname, fieldname) PB_SO ## htype(structname, fieldname)
-#define PB_SIZE_OFFSET_POINTER(htype, structname, fieldname) PB_SO_PTR ## htype(structname, fieldname)
-#define PB_SIZE_OFFSET_CALLBACK(htype, structname, fieldname) PB_SO_CB ## htype(structname, fieldname)
+#define PB_SIZE_OFFSET_STATIC(htype, structname, fieldname) PB_SO##htype(structname, fieldname)
+#define PB_SIZE_OFFSET_POINTER(htype, structname, fieldname) PB_SO_PTR##htype(structname, fieldname)
+#define PB_SIZE_OFFSET_CALLBACK(htype, structname, fieldname) PB_SO_CB##htype(structname, fieldname)
 #define PB_SO_PB_HTYPE_REQUIRED(structname, fieldname) 0
 #define PB_SO_PB_HTYPE_SINGULAR(structname, fieldname) 0
-#define PB_SO_PB_HTYPE_ONEOF(structname, fieldname) PB_SO_PB_HTYPE_ONEOF2(structname, PB_ONEOF_NAME(FULL, fieldname), PB_ONEOF_NAME(UNION, fieldname))
+#define PB_SO_PB_HTYPE_ONEOF(structname, fieldname)                                                                              \
+    PB_SO_PB_HTYPE_ONEOF2(structname, PB_ONEOF_NAME(FULL, fieldname), PB_ONEOF_NAME(UNION, fieldname))
 #define PB_SO_PB_HTYPE_ONEOF2(structname, fullname, unionname) PB_SO_PB_HTYPE_ONEOF3(structname, fullname, unionname)
-#define PB_SO_PB_HTYPE_ONEOF3(structname, fullname, unionname) pb_delta(structname, fullname, which_ ## unionname)
-#define PB_SO_PB_HTYPE_OPTIONAL(structname, fieldname) pb_delta(structname, fieldname, has_ ## fieldname)
-#define PB_SO_PB_HTYPE_REPEATED(structname, fieldname) pb_delta(structname, fieldname, fieldname ## _count)
+#define PB_SO_PB_HTYPE_ONEOF3(structname, fullname, unionname) pb_delta(structname, fullname, which_##unionname)
+#define PB_SO_PB_HTYPE_OPTIONAL(structname, fieldname) pb_delta(structname, fieldname, has_##fieldname)
+#define PB_SO_PB_HTYPE_REPEATED(structname, fieldname) pb_delta(structname, fieldname, fieldname##_count)
 #define PB_SO_PB_HTYPE_FIXARRAY(structname, fieldname) 0
 #define PB_SO_PTR_PB_HTYPE_REQUIRED(structname, fieldname) 0
 #define PB_SO_PTR_PB_HTYPE_SINGULAR(structname, fieldname) 0
@@ -608,8 +597,8 @@ struct pb_extension_s {
 #define PB_SO_CB_PB_HTYPE_REPEATED(structname, fieldname) 0
 #define PB_SO_CB_PB_HTYPE_FIXARRAY(structname, fieldname) 0
 
-#define PB_ARRAY_SIZE_STATIC(htype, structname, fieldname) PB_AS ## htype(structname, fieldname)
-#define PB_ARRAY_SIZE_POINTER(htype, structname, fieldname) PB_AS_PTR ## htype(structname, fieldname)
+#define PB_ARRAY_SIZE_STATIC(htype, structname, fieldname) PB_AS##htype(structname, fieldname)
+#define PB_ARRAY_SIZE_POINTER(htype, structname, fieldname) PB_AS_PTR##htype(structname, fieldname)
 #define PB_ARRAY_SIZE_CALLBACK(htype, structname, fieldname) 1
 #define PB_AS_PB_HTYPE_REQUIRED(structname, fieldname) 1
 #define PB_AS_PB_HTYPE_SINGULAR(structname, fieldname) 1
@@ -624,9 +613,9 @@ struct pb_extension_s {
 #define PB_AS_PTR_PB_HTYPE_REPEATED(structname, fieldname) 1
 #define PB_AS_PTR_PB_HTYPE_FIXARRAY(structname, fieldname) pb_arraysize(structname, fieldname[0])
 
-#define PB_DATA_SIZE_STATIC(htype, structname, fieldname) PB_DS ## htype(structname, fieldname)
-#define PB_DATA_SIZE_POINTER(htype, structname, fieldname) PB_DS_PTR ## htype(structname, fieldname)
-#define PB_DATA_SIZE_CALLBACK(htype, structname, fieldname) PB_DS_CB ## htype(structname, fieldname)
+#define PB_DATA_SIZE_STATIC(htype, structname, fieldname) PB_DS##htype(structname, fieldname)
+#define PB_DATA_SIZE_POINTER(htype, structname, fieldname) PB_DS_PTR##htype(structname, fieldname)
+#define PB_DATA_SIZE_CALLBACK(htype, structname, fieldname) PB_DS_CB##htype(structname, fieldname)
 #define PB_DS_PB_HTYPE_REQUIRED(structname, fieldname) pb_membersize(structname, fieldname)
 #define PB_DS_PB_HTYPE_SINGULAR(structname, fieldname) pb_membersize(structname, fieldname)
 #define PB_DS_PB_HTYPE_OPTIONAL(structname, fieldname) pb_membersize(structname, fieldname)
@@ -646,22 +635,25 @@ struct pb_extension_s {
 #define PB_DS_CB_PB_HTYPE_REPEATED(structname, fieldname) pb_membersize(structname, fieldname)
 #define PB_DS_CB_PB_HTYPE_FIXARRAY(structname, fieldname) pb_membersize(structname, fieldname)
 
-#define PB_ONEOF_NAME(type, tuple) PB_EXPAND(PB_ONEOF_NAME_ ## type tuple)
-#define PB_ONEOF_NAME_UNION(unionname,membername,fullname) unionname
-#define PB_ONEOF_NAME_MEMBER(unionname,membername,fullname) membername
-#define PB_ONEOF_NAME_FULL(unionname,membername,fullname) fullname
+#define PB_ONEOF_NAME(type, tuple) PB_EXPAND(PB_ONEOF_NAME_##type tuple)
+#define PB_ONEOF_NAME_UNION(unionname, membername, fullname) unionname
+#define PB_ONEOF_NAME_MEMBER(unionname, membername, fullname) membername
+#define PB_ONEOF_NAME_FULL(unionname, membername, fullname) fullname
 
-#define PB_GEN_SUBMSG_INFO(structname, atype, htype, ltype, fieldname, tag) \
-    PB_SUBMSG_INFO_ ## htype(_PB_LTYPE_ ## ltype, structname, fieldname)
+#define PB_GEN_SUBMSG_INFO(structname, atype, htype, ltype, fieldname, tag)                                                      \
+    PB_SUBMSG_INFO_##htype(_PB_LTYPE_##ltype, structname, fieldname)
 
-#define PB_SUBMSG_INFO_REQUIRED(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE)
-#define PB_SUBMSG_INFO_SINGULAR(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE)
-#define PB_SUBMSG_INFO_OPTIONAL(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE)
-#define PB_SUBMSG_INFO_ONEOF(ltype, structname, fieldname) PB_SUBMSG_INFO_ONEOF2(ltype, structname, PB_ONEOF_NAME(UNION, fieldname), PB_ONEOF_NAME(MEMBER, fieldname))
-#define PB_SUBMSG_INFO_ONEOF2(ltype, structname, unionname, membername) PB_SUBMSG_INFO_ONEOF3(ltype, structname, unionname, membername)
-#define PB_SUBMSG_INFO_ONEOF3(ltype, structname, unionname, membername) PB_SI ## ltype(structname ## _ ## unionname ## _ ## membername ## _MSGTYPE)
-#define PB_SUBMSG_INFO_REPEATED(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE)
-#define PB_SUBMSG_INFO_FIXARRAY(ltype, structname, fieldname) PB_SI ## ltype(structname ## _ ## fieldname ## _MSGTYPE)
+#define PB_SUBMSG_INFO_REQUIRED(ltype, structname, fieldname) PB_SI##ltype(structname##_##fieldname##_MSGTYPE)
+#define PB_SUBMSG_INFO_SINGULAR(ltype, structname, fieldname) PB_SI##ltype(structname##_##fieldname##_MSGTYPE)
+#define PB_SUBMSG_INFO_OPTIONAL(ltype, structname, fieldname) PB_SI##ltype(structname##_##fieldname##_MSGTYPE)
+#define PB_SUBMSG_INFO_ONEOF(ltype, structname, fieldname)                                                                       \
+    PB_SUBMSG_INFO_ONEOF2(ltype, structname, PB_ONEOF_NAME(UNION, fieldname), PB_ONEOF_NAME(MEMBER, fieldname))
+#define PB_SUBMSG_INFO_ONEOF2(ltype, structname, unionname, membername)                                                          \
+    PB_SUBMSG_INFO_ONEOF3(ltype, structname, unionname, membername)
+#define PB_SUBMSG_INFO_ONEOF3(ltype, structname, unionname, membername)                                                          \
+    PB_SI##ltype(structname##_##unionname##_##membername##_MSGTYPE)
+#define PB_SUBMSG_INFO_REPEATED(ltype, structname, fieldname) PB_SI##ltype(structname##_##fieldname##_MSGTYPE)
+#define PB_SUBMSG_INFO_FIXARRAY(ltype, structname, fieldname) PB_SI##ltype(structname##_##fieldname##_MSGTYPE)
 #define PB_SI_PB_LTYPE_BOOL(t)
 #define PB_SI_PB_LTYPE_BYTES(t)
 #define PB_SI_PB_LTYPE_DOUBLE(t)
@@ -672,7 +664,7 @@ struct pb_extension_s {
 #define PB_SI_PB_LTYPE_FLOAT(t)
 #define PB_SI_PB_LTYPE_INT32(t)
 #define PB_SI_PB_LTYPE_INT64(t)
-#define PB_SI_PB_LTYPE_MESSAGE(t)  PB_SUBMSG_DESCRIPTOR(t)
+#define PB_SI_PB_LTYPE_MESSAGE(t) PB_SUBMSG_DESCRIPTOR(t)
 #define PB_SI_PB_LTYPE_MSG_W_CB(t) PB_SUBMSG_DESCRIPTOR(t)
 #define PB_SI_PB_LTYPE_SFIXED32(t)
 #define PB_SI_PB_LTYPE_SFIXED64(t)
@@ -683,7 +675,7 @@ struct pb_extension_s {
 #define PB_SI_PB_LTYPE_UINT64(t)
 #define PB_SI_PB_LTYPE_EXTENSION(t)
 #define PB_SI_PB_LTYPE_FIXED_LENGTH_BYTES(t)
-#define PB_SUBMSG_DESCRIPTOR(t)    &(t ## _msg),
+#define PB_SUBMSG_DESCRIPTOR(t) &(t##_msg),
 
 /* The field descriptors use a variable width format, with width of either
  * 1, 2, 4 or 8 of 32-bit words. The two lowest bytes of the first byte always
@@ -713,23 +705,23 @@ struct pb_extension_s {
  *          [32-bit reserved]
  */
 
-#define PB_FIELDINFO_1(tag, type, data_offset, data_size, size_offset, array_size) \
-    (0 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(data_offset) & 0xFF) << 16) | \
-     (((uint32_t)(size_offset) & 0x0F) << 24) | (((uint32_t)(data_size) & 0x0F) << 28)),
+#define PB_FIELDINFO_1(tag, type, data_offset, data_size, size_offset, array_size)                                               \
+    (0 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(data_offset)&0xFF) << 16) |                                        \
+     (((uint32_t)(size_offset)&0x0F) << 24) | (((uint32_t)(data_size)&0x0F) << 28)),
 
-#define PB_FIELDINFO_2(tag, type, data_offset, data_size, size_offset, array_size) \
-    (1 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(array_size) & 0xFFF) << 16) | (((uint32_t)(size_offset) & 0x0F) << 28)), \
-    (((uint32_t)(data_offset) & 0xFFFF) | (((uint32_t)(data_size) & 0xFFF) << 16) | (((uint32_t)(tag) & 0x3c0) << 22)),
+#define PB_FIELDINFO_2(tag, type, data_offset, data_size, size_offset, array_size)                                               \
+    (1 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(array_size)&0xFFF) << 16) |                                        \
+     (((uint32_t)(size_offset)&0x0F) << 28)),                                                                                    \
+        (((uint32_t)(data_offset)&0xFFFF) | (((uint32_t)(data_size)&0xFFF) << 16) | (((uint32_t)(tag)&0x3c0) << 22)),
 
-#define PB_FIELDINFO_4(tag, type, data_offset, data_size, size_offset, array_size) \
-    (2 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(array_size) & 0xFFFF) << 16)), \
-    ((uint32_t)(int_least8_t)(size_offset) | (((uint32_t)(tag) << 2) & 0xFFFFFF00)), \
-    (data_offset), (data_size),
+#define PB_FIELDINFO_4(tag, type, data_offset, data_size, size_offset, array_size)                                               \
+    (2 | (((tag) << 2) & 0xFF) | ((type) << 8) | (((uint32_t)(array_size)&0xFFFF) << 16)),                                       \
+        ((uint32_t)(int_least8_t)(size_offset) | (((uint32_t)(tag) << 2) & 0xFFFFFF00)), (data_offset), (data_size),
 
-#define PB_FIELDINFO_8(tag, type, data_offset, data_size, size_offset, array_size) \
-    (3 | (((tag) << 2) & 0xFF) | ((type) << 8)), \
-    ((uint32_t)(int_least8_t)(size_offset) | (((uint32_t)(tag) << 2) & 0xFFFFFF00)), \
-    (data_offset), (data_size), (array_size), 0, 0, 0,
+#define PB_FIELDINFO_8(tag, type, data_offset, data_size, size_offset, array_size)                                               \
+    (3 | (((tag) << 2) & 0xFF) | ((type) << 8)),                                                                                 \
+        ((uint32_t)(int_least8_t)(size_offset) | (((uint32_t)(tag) << 2) & 0xFFFFFF00)), (data_offset), (data_size),             \
+        (array_size), 0, 0, 0,
 
 /* These assertions verify that the field information fits in the allocated space.
  * The generator tries to automatically determine the correct width that can fit all
@@ -738,92 +730,103 @@ struct pb_extension_s {
  * you can increase the descriptor width by defining PB_FIELDINFO_WIDTH or by setting
  * descriptorsize option in .options file.
  */
-#define PB_FITS(value,bits) ((uint32_t)(value) < ((uint32_t)1<<bits))
-#define PB_FIELDINFO_ASSERT_1(tag, type, data_offset, data_size, size_offset, array_size) \
-    PB_STATIC_ASSERT(PB_FITS(tag,6) && PB_FITS(data_offset,8) && PB_FITS(size_offset,4) && PB_FITS(data_size,4) && PB_FITS(array_size,1), FIELDINFO_DOES_NOT_FIT_width1_field ## tag)
+#define PB_FITS(value, bits) ((uint32_t)(value) < ((uint32_t)1 << bits))
+#define PB_FIELDINFO_ASSERT_1(tag, type, data_offset, data_size, size_offset, array_size)                                        \
+    PB_STATIC_ASSERT(PB_FITS(tag, 6) && PB_FITS(data_offset, 8) && PB_FITS(size_offset, 4) && PB_FITS(data_size, 4) &&           \
+                         PB_FITS(array_size, 1),                                                                                 \
+                     FIELDINFO_DOES_NOT_FIT_width1_field##tag)
 
-#define PB_FIELDINFO_ASSERT_2(tag, type, data_offset, data_size, size_offset, array_size) \
-    PB_STATIC_ASSERT(PB_FITS(tag,10) && PB_FITS(data_offset,16) && PB_FITS(size_offset,4) && PB_FITS(data_size,12) && PB_FITS(array_size,12), FIELDINFO_DOES_NOT_FIT_width2_field ## tag)
+#define PB_FIELDINFO_ASSERT_2(tag, type, data_offset, data_size, size_offset, array_size)                                        \
+    PB_STATIC_ASSERT(PB_FITS(tag, 10) && PB_FITS(data_offset, 16) && PB_FITS(size_offset, 4) && PB_FITS(data_size, 12) &&        \
+                         PB_FITS(array_size, 12),                                                                                \
+                     FIELDINFO_DOES_NOT_FIT_width2_field##tag)
 
 #ifndef PB_FIELD_32BIT
 /* Maximum field sizes are still 16-bit if pb_size_t is 16-bit */
-#define PB_FIELDINFO_ASSERT_4(tag, type, data_offset, data_size, size_offset, array_size) \
-    PB_STATIC_ASSERT(PB_FITS(tag,16) && PB_FITS(data_offset,16) && PB_FITS((int_least8_t)size_offset,8) && PB_FITS(data_size,16) && PB_FITS(array_size,16), FIELDINFO_DOES_NOT_FIT_width4_field ## tag)
+#define PB_FIELDINFO_ASSERT_4(tag, type, data_offset, data_size, size_offset, array_size)                                        \
+    PB_STATIC_ASSERT(PB_FITS(tag, 16) && PB_FITS(data_offset, 16) && PB_FITS((int_least8_t)size_offset, 8) &&                    \
+                         PB_FITS(data_size, 16) && PB_FITS(array_size, 16),                                                      \
+                     FIELDINFO_DOES_NOT_FIT_width4_field##tag)
 
-#define PB_FIELDINFO_ASSERT_8(tag, type, data_offset, data_size, size_offset, array_size) \
-    PB_STATIC_ASSERT(PB_FITS(tag,16) && PB_FITS(data_offset,16) && PB_FITS((int_least8_t)size_offset,8) && PB_FITS(data_size,16) && PB_FITS(array_size,16), FIELDINFO_DOES_NOT_FIT_width8_field ## tag)
+#define PB_FIELDINFO_ASSERT_8(tag, type, data_offset, data_size, size_offset, array_size)                                        \
+    PB_STATIC_ASSERT(PB_FITS(tag, 16) && PB_FITS(data_offset, 16) && PB_FITS((int_least8_t)size_offset, 8) &&                    \
+                         PB_FITS(data_size, 16) && PB_FITS(array_size, 16),                                                      \
+                     FIELDINFO_DOES_NOT_FIT_width8_field##tag)
 #else
 /* Up to 32-bit fields supported.
  * Note that the checks are against 31 bits to avoid compiler warnings about shift wider than type in the test.
  * I expect that there is no reasonable use for >2GB messages with nanopb anyway.
  */
-#define PB_FIELDINFO_ASSERT_4(tag, type, data_offset, data_size, size_offset, array_size) \
-    PB_STATIC_ASSERT(PB_FITS(tag,30) && PB_FITS(data_offset,31) && PB_FITS(size_offset,8) && PB_FITS(data_size,31) && PB_FITS(array_size,16), FIELDINFO_DOES_NOT_FIT_width4_field ## tag)
+#define PB_FIELDINFO_ASSERT_4(tag, type, data_offset, data_size, size_offset, array_size)                                        \
+    PB_STATIC_ASSERT(PB_FITS(tag, 30) && PB_FITS(data_offset, 31) && PB_FITS(size_offset, 8) && PB_FITS(data_size, 31) &&        \
+                         PB_FITS(array_size, 16),                                                                                \
+                     FIELDINFO_DOES_NOT_FIT_width4_field##tag)
 
-#define PB_FIELDINFO_ASSERT_8(tag, type, data_offset, data_size, size_offset, array_size) \
-    PB_STATIC_ASSERT(PB_FITS(tag,30) && PB_FITS(data_offset,31) && PB_FITS(size_offset,8) && PB_FITS(data_size,31) && PB_FITS(array_size,31), FIELDINFO_DOES_NOT_FIT_width8_field ## tag)
+#define PB_FIELDINFO_ASSERT_8(tag, type, data_offset, data_size, size_offset, array_size)                                        \
+    PB_STATIC_ASSERT(PB_FITS(tag, 30) && PB_FITS(data_offset, 31) && PB_FITS(size_offset, 8) && PB_FITS(data_size, 31) &&        \
+                         PB_FITS(array_size, 31),                                                                                \
+                     FIELDINFO_DOES_NOT_FIT_width8_field##tag)
 #endif
 
-
 /* Automatic picking of FIELDINFO width:
  * Uses width 1 when possible, otherwise resorts to width 2.
  * This is used when PB_BIND() is called with "AUTO" as the argument.
  * The generator will give explicit size argument when it knows that a message
  * structure grows beyond 1-word format limits.
  */
-#define PB_FIELDINFO_WIDTH_AUTO(atype, htype, ltype) PB_FI_WIDTH ## atype(htype, ltype)
-#define PB_FI_WIDTH_PB_ATYPE_STATIC(htype, ltype) PB_FI_WIDTH ## htype(ltype)
-#define PB_FI_WIDTH_PB_ATYPE_POINTER(htype, ltype) PB_FI_WIDTH ## htype(ltype)
+#define PB_FIELDINFO_WIDTH_AUTO(atype, htype, ltype) PB_FI_WIDTH##atype(htype, ltype)
+#define PB_FI_WIDTH_PB_ATYPE_STATIC(htype, ltype) PB_FI_WIDTH##htype(ltype)
+#define PB_FI_WIDTH_PB_ATYPE_POINTER(htype, ltype) PB_FI_WIDTH##htype(ltype)
 #define PB_FI_WIDTH_PB_ATYPE_CALLBACK(htype, ltype) 2
-#define PB_FI_WIDTH_PB_HTYPE_REQUIRED(ltype) PB_FI_WIDTH ## ltype
-#define PB_FI_WIDTH_PB_HTYPE_SINGULAR(ltype) PB_FI_WIDTH ## ltype
-#define PB_FI_WIDTH_PB_HTYPE_OPTIONAL(ltype) PB_FI_WIDTH ## ltype
-#define PB_FI_WIDTH_PB_HTYPE_ONEOF(ltype) PB_FI_WIDTH ## ltype
+#define PB_FI_WIDTH_PB_HTYPE_REQUIRED(ltype) PB_FI_WIDTH##ltype
+#define PB_FI_WIDTH_PB_HTYPE_SINGULAR(ltype) PB_FI_WIDTH##ltype
+#define PB_FI_WIDTH_PB_HTYPE_OPTIONAL(ltype) PB_FI_WIDTH##ltype
+#define PB_FI_WIDTH_PB_HTYPE_ONEOF(ltype) PB_FI_WIDTH##ltype
 #define PB_FI_WIDTH_PB_HTYPE_REPEATED(ltype) 2
 #define PB_FI_WIDTH_PB_HTYPE_FIXARRAY(ltype) 2
-#define PB_FI_WIDTH_PB_LTYPE_BOOL      1
-#define PB_FI_WIDTH_PB_LTYPE_BYTES     2
-#define PB_FI_WIDTH_PB_LTYPE_DOUBLE    1
-#define PB_FI_WIDTH_PB_LTYPE_ENUM      1
-#define PB_FI_WIDTH_PB_LTYPE_UENUM     1
-#define PB_FI_WIDTH_PB_LTYPE_FIXED32   1
-#define PB_FI_WIDTH_PB_LTYPE_FIXED64   1
-#define PB_FI_WIDTH_PB_LTYPE_FLOAT     1
-#define PB_FI_WIDTH_PB_LTYPE_INT32     1
-#define PB_FI_WIDTH_PB_LTYPE_INT64     1
-#define PB_FI_WIDTH_PB_LTYPE_MESSAGE   2
-#define PB_FI_WIDTH_PB_LTYPE_MSG_W_CB  2
-#define PB_FI_WIDTH_PB_LTYPE_SFIXED32  1
-#define PB_FI_WIDTH_PB_LTYPE_SFIXED64  1
-#define PB_FI_WIDTH_PB_LTYPE_SINT32    1
-#define PB_FI_WIDTH_PB_LTYPE_SINT64    1
-#define PB_FI_WIDTH_PB_LTYPE_STRING    2
-#define PB_FI_WIDTH_PB_LTYPE_UINT32    1
-#define PB_FI_WIDTH_PB_LTYPE_UINT64    1
+#define PB_FI_WIDTH_PB_LTYPE_BOOL 1
+#define PB_FI_WIDTH_PB_LTYPE_BYTES 2
+#define PB_FI_WIDTH_PB_LTYPE_DOUBLE 1
+#define PB_FI_WIDTH_PB_LTYPE_ENUM 1
+#define PB_FI_WIDTH_PB_LTYPE_UENUM 1
+#define PB_FI_WIDTH_PB_LTYPE_FIXED32 1
+#define PB_FI_WIDTH_PB_LTYPE_FIXED64 1
+#define PB_FI_WIDTH_PB_LTYPE_FLOAT 1
+#define PB_FI_WIDTH_PB_LTYPE_INT32 1
+#define PB_FI_WIDTH_PB_LTYPE_INT64 1
+#define PB_FI_WIDTH_PB_LTYPE_MESSAGE 2
+#define PB_FI_WIDTH_PB_LTYPE_MSG_W_CB 2
+#define PB_FI_WIDTH_PB_LTYPE_SFIXED32 1
+#define PB_FI_WIDTH_PB_LTYPE_SFIXED64 1
+#define PB_FI_WIDTH_PB_LTYPE_SINT32 1
+#define PB_FI_WIDTH_PB_LTYPE_SINT64 1
+#define PB_FI_WIDTH_PB_LTYPE_STRING 2
+#define PB_FI_WIDTH_PB_LTYPE_UINT32 1
+#define PB_FI_WIDTH_PB_LTYPE_UINT64 1
 #define PB_FI_WIDTH_PB_LTYPE_EXTENSION 1
 #define PB_FI_WIDTH_PB_LTYPE_FIXED_LENGTH_BYTES 2
 
 /* The mapping from protobuf types to LTYPEs is done using these macros. */
-#define PB_LTYPE_MAP_BOOL               PB_LTYPE_BOOL
-#define PB_LTYPE_MAP_BYTES              PB_LTYPE_BYTES
-#define PB_LTYPE_MAP_DOUBLE             PB_LTYPE_FIXED64
-#define PB_LTYPE_MAP_ENUM               PB_LTYPE_VARINT
-#define PB_LTYPE_MAP_UENUM              PB_LTYPE_UVARINT
-#define PB_LTYPE_MAP_FIXED32            PB_LTYPE_FIXED32
-#define PB_LTYPE_MAP_FIXED64            PB_LTYPE_FIXED64
-#define PB_LTYPE_MAP_FLOAT              PB_LTYPE_FIXED32
-#define PB_LTYPE_MAP_INT32              PB_LTYPE_VARINT
-#define PB_LTYPE_MAP_INT64              PB_LTYPE_VARINT
-#define PB_LTYPE_MAP_MESSAGE            PB_LTYPE_SUBMESSAGE
-#define PB_LTYPE_MAP_MSG_W_CB           PB_LTYPE_SUBMSG_W_CB
-#define PB_LTYPE_MAP_SFIXED32           PB_LTYPE_FIXED32
-#define PB_LTYPE_MAP_SFIXED64           PB_LTYPE_FIXED64
-#define PB_LTYPE_MAP_SINT32             PB_LTYPE_SVARINT
-#define PB_LTYPE_MAP_SINT64             PB_LTYPE_SVARINT
-#define PB_LTYPE_MAP_STRING             PB_LTYPE_STRING
-#define PB_LTYPE_MAP_UINT32             PB_LTYPE_UVARINT
-#define PB_LTYPE_MAP_UINT64             PB_LTYPE_UVARINT
-#define PB_LTYPE_MAP_EXTENSION          PB_LTYPE_EXTENSION
+#define PB_LTYPE_MAP_BOOL PB_LTYPE_BOOL
+#define PB_LTYPE_MAP_BYTES PB_LTYPE_BYTES
+#define PB_LTYPE_MAP_DOUBLE PB_LTYPE_FIXED64
+#define PB_LTYPE_MAP_ENUM PB_LTYPE_VARINT
+#define PB_LTYPE_MAP_UENUM PB_LTYPE_UVARINT
+#define PB_LTYPE_MAP_FIXED32 PB_LTYPE_FIXED32
+#define PB_LTYPE_MAP_FIXED64 PB_LTYPE_FIXED64
+#define PB_LTYPE_MAP_FLOAT PB_LTYPE_FIXED32
+#define PB_LTYPE_MAP_INT32 PB_LTYPE_VARINT
+#define PB_LTYPE_MAP_INT64 PB_LTYPE_VARINT
+#define PB_LTYPE_MAP_MESSAGE PB_LTYPE_SUBMESSAGE
+#define PB_LTYPE_MAP_MSG_W_CB PB_LTYPE_SUBMSG_W_CB
+#define PB_LTYPE_MAP_SFIXED32 PB_LTYPE_FIXED32
+#define PB_LTYPE_MAP_SFIXED64 PB_LTYPE_FIXED64
+#define PB_LTYPE_MAP_SINT32 PB_LTYPE_SVARINT
+#define PB_LTYPE_MAP_SINT64 PB_LTYPE_SVARINT
+#define PB_LTYPE_MAP_STRING PB_LTYPE_STRING
+#define PB_LTYPE_MAP_UINT32 PB_LTYPE_UVARINT
+#define PB_LTYPE_MAP_UINT64 PB_LTYPE_UVARINT
+#define PB_LTYPE_MAP_EXTENSION PB_LTYPE_EXTENSION
 #define PB_LTYPE_MAP_FIXED_LENGTH_BYTES PB_LTYPE_FIXED_LENGTH_BYTES
 
 /* These macros are used for giving out error messages.
@@ -855,21 +858,21 @@ struct pb_extension_s {
 #ifdef __cplusplus
 #if __cplusplus >= 201103L
 #define PB_CONSTEXPR constexpr
-#else  // __cplusplus >= 201103L
+#else // __cplusplus >= 201103L
 #define PB_CONSTEXPR
-#endif  // __cplusplus >= 201103L
+#endif // __cplusplus >= 201103L
 
 #if __cplusplus >= 201703L
 #define PB_INLINE_CONSTEXPR inline constexpr
-#else  // __cplusplus >= 201703L
+#else // __cplusplus >= 201703L
 #define PB_INLINE_CONSTEXPR PB_CONSTEXPR
-#endif  // __cplusplus >= 201703L
+#endif // __cplusplus >= 201703L
 
-namespace nanopb {
+namespace nanopb
+{
 // Each type will be partially specialized by the generator.
 template <typename GenMessageT> struct MessageDescriptor;
-}  // namespace nanopb
-#endif  /* __cplusplus */
+} // namespace nanopb
+#endif /* __cplusplus */
 
 #endif
-

platformio.ini

@@ -13,6 +13,7 @@ default_envs = tbeam
 ;default_envs = tbeam0.7
 ;default_envs = heltec
 ;default_envs = tlora-v1
+;default_envs = tlora_v1_3
 ;default_envs = tlora-v2
 ;default_envs = lora-relay-v1 # nrf board
 ;default_envs = eink
@@ -39,7 +40,7 @@ extra_scripts = bin/platformio-custom.py
 ; FIXME: fix lib/BluetoothOTA dependency back on src/ so we can remove -Isrc
 build_flags = -Wno-missing-field-initializers
   -Wno-format 
-  -Isrc -Isrc/mesh -Isrc/gps -Ilib/nanopb/include -Wl,-Map,.pio/build/output.map 
+  -Isrc -Isrc/mesh -Isrc/gps -Isrc/buzz -Wl,-Map,.pio/build/output.map 
   -DHW_VERSION_${sysenv.COUNTRY}
   -DHW_VERSION=${sysenv.HW_VERSION}
   -DUSE_THREAD_NAMES
@@ -67,7 +68,7 @@ lib_deps =
   https://github.com/meshtastic/esp8266-oled-ssd1306.git#35d796226b853b0c0ff818b2f1aa3d35e7296a96 ; ESP8266_SSD1306 
   https://github.com/geeksville/OneButton.git ; OneButton library for non-blocking button debounce
   1202 ; CRC32, explicitly needed because dependency is missing in the ble ota update lib
-  https://github.com/meshtastic/arduino-fsm.git#55c47b6cded91645aff05a27b6e5821d8d0f64be
+  https://github.com/meshtastic/arduino-fsm.git#829e967b8a95c094f73c60ef8dacfe66eae38940
   https://github.com/meshtastic/SparkFun_Ublox_Arduino_Library.git#31015a55e630a2df77d9d714669c621a5bf355ad
   https://github.com/meshtastic/RadioLib.git#07de964e929238949035fb0d5887026a3058df1a
   https://github.com/meshtastic/TinyGPSPlus.git#f0f47067ef2f67c856475933188251c1ef615e79
@@ -75,6 +76,7 @@ lib_deps =
   Wire ; explicitly needed here because the AXP202 library forgets to add it
   SPI
   https://github.com/geeksville/ArduinoThread.git#72921ac222eed6f526ba1682023cee290d9aa1b3
+  PubSubClient
   
 ; Common settings for conventional (non Portduino) Ardino targets
 [arduino_base]
@@ -109,7 +111,7 @@ lib_deps =
 # board_build.ldscript = linker/esp32.extram.bss.ld
 lib_ignore = segger_rtt
 platform_packages =
-    framework-arduinoespressif32@https://github.com/meshtastic/arduino-esp32.git#352c8ea7cb73f10433ed139f34251979c470ad56
+    framework-arduinoespressif32@https://github.com/meshtastic/arduino-esp32.git#4cde0f5d412d2695184f32e8a47e9bea57b45276
 
 ; leave this commented out to avoid breaking Windows
 upload_port = /dev/ttyUSB0
@@ -158,6 +160,12 @@ build_flags =
   ${esp32_base.build_flags} -D TLORA_V1
 
 ; note: the platformio definition for lora32-v2 seems stale, it is missing a pins_arduino.h file, therefore I don't think it works
+[env:tlora_v1_3]
+extends = esp32_base
+board = ttgo-lora32-v1
+build_flags = 
+  ${esp32_base.build_flags} -D TLORA_V1_3
+
 [env:tlora-v2]
 extends = esp32_base
 board = ttgo-lora32-v1
@@ -195,7 +203,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/> -<plugins/esp32>
+  ${arduino_base.src_filter} -<esp32/> -<nimble/> -<mesh/wifi/> -<mesh/http/> -<plugins/esp32> -<mqtt/>
 lib_ignore =
   BluetoothOTA
 monitor_port = /dev/ttyACM1
@@ -232,6 +240,24 @@ debug_init_break =
 ;debug_init_break = tbreak loop
 ;debug_init_break = tbreak Reset_Handler
 
+[env:lora_isp4520]
+extends = nrf52_base
+board = lora_isp4520
+
+# add our variants files to the include and src paths
+build_flags = ${nrf52_base.build_flags} -Ivariants/lora_isp4520
+
+# No screen and GPS on the board. We still need RTC.cpp for the RTC clock.
+src_filter = ${nrf52_base.src_filter} +<../variants/lora_isp4520> -<graphics> -<gps> +<gps/GPS.cpp> +<gps/RTC.cpp>
+lib_ignore = ${nrf52_base.lib_ignore} 
+  ESP8266_SSD1306
+  SparkFun Ublox Arduino Library
+  AXP202X_Library
+  TinyGPSPlus
+
+upload_protocol = jlink
+monitor_port = /dev/ttyUSB0
+
 ; The NRF52840-dk development board
 ; Note: By default no lora device is created for this build - it uses a simulated interface
 [env:nrf52840dk]
@@ -371,4 +397,4 @@ lib_deps =
 ;extends = esp32_base
 ;board = genieblocks_lora
 ;build_flags = 
-;  ${esp32_base.build_flags} -D GENIEBLOCKS
+;  ${esp32_base.build_flags} -D GENIEBLOCKS

src/OSTimer.cpp

@@ -40,7 +40,7 @@ bool scheduleHWCallback(PendableFunction callback, void *param1, uint32_t param2
     tParam1 = param1;
     tParam2 = param2;
 
-    timerAlarmWrite(timer, delayMsec * 1000L, false); // Do not reload, we want it to be a single shot timer
+    timerAlarmWrite(timer, delayMsec * 1000UL, false); // Do not reload, we want it to be a single shot timer
     timerRestart(timer);
     timerAlarmEnable(timer);
     return true;

src/Power.cpp

@@ -5,12 +5,35 @@
 #include "sleep.h"
 #include "utils.h"
 
+#ifdef TBEAM_V10
 // FIXME. nasty hack cleanup how we load axp192
 #undef AXP192_SLAVE_ADDRESS
 #include "axp20x.h"
 
-#ifdef TBEAM_V10
 AXP20X_Class axp;
+#else
+// Copy of the base class defined in axp20x.h. 
+// I'd rather not inlude axp20x.h as it brings Wire dependency.
+class HasBatteryLevel {
+public:
+  /**
+   * Battery state of charge, from 0 to 100 or -1 for unknown
+   */
+  virtual int getBattPercentage() { return -1; }
+
+  /**
+   * The raw voltage of the battery or NAN if unknown
+   */
+  virtual float getBattVoltage() { return NAN; }
+
+  /**
+   * return true if there is a battery installed in this unit
+   */
+  virtual bool isBatteryConnect() { return false; }
+
+  virtual bool isVBUSPlug() { return false; }
+  virtual bool isChargeing() { return false; }
+};
 #endif
 
 bool pmu_irq = false;
@@ -51,7 +74,7 @@ class AnalogBatteryLevel : public HasBatteryLevel
      */
     virtual int getBattPercentage()
     {
-        float v = getBattVoltage() / 1000;
+        float v = getBattVoltage();
 
         if (v < noBatVolt)
             return -1; // If voltage is super low assume no battery installed
@@ -67,13 +90,26 @@ class AnalogBatteryLevel : public HasBatteryLevel
      */
     virtual float getBattVoltage()
     {
-        // Tested ttgo eink nrf52 board and the reported value is perfect
-        // DEBUG_MSG("raw val %u", raw);
-        return
+
+#ifndef ADC_MULTIPLIER
+#define ADC_MULTIPLIER 2.0
+#endif 
+
 #ifdef BATTERY_PIN
-            1000.0 * 2.0 * (AREF_VOLTAGE / 1024.0) * analogRead(BATTERY_PIN);
+        // Do not call analogRead() often. 
+        const uint32_t min_read_interval = 5000;
+        if (millis() - last_read_time_ms > min_read_interval) {
+            last_read_time_ms = millis();
+            uint32_t raw = analogRead(BATTERY_PIN);
+            float scaled = 1000.0 * ADC_MULTIPLIER * (AREF_VOLTAGE / 1024.0) * raw;
+            // DEBUG_MSG("raw val=%u scaled=%u\n", raw, (uint32_t)(scaled));
+            last_read_value = scaled;
+            return scaled;
+        } else {
+            return last_read_value;
+        }
 #else
-            NAN;
+        return NAN;
 #endif
     }
 
@@ -93,7 +129,9 @@ class AnalogBatteryLevel : public HasBatteryLevel
   private:
     /// If we see a battery voltage higher than physics allows - assume charger is pumping
     /// in power
-    const float fullVolt = 4.2, emptyVolt = 3.27, chargingVolt = 4.3, noBatVolt = 2.1;
+    const float fullVolt = 4200, emptyVolt = 3270, chargingVolt = 4210, noBatVolt = 2100;
+    float last_read_value = 0.0;
+    uint32_t last_read_time_ms = 0;
 } analogLevel;
 
 Power::Power() : OSThread("Power") {}
@@ -140,6 +178,8 @@ void Power::shutdown()
 #ifdef TBEAM_V10
     DEBUG_MSG("Shutting down\n");
     axp.shutdown();
+#elif NRF52_SERIES
+    doDeepSleep(DELAY_FOREVER);
 #endif
 }
 

src/PowerFSM.cpp

@@ -9,6 +9,23 @@
 #include "sleep.h"
 #include "target_specific.h"
 
+/// Should we behave as if we have AC power now?
+static bool isPowered()
+{
+    bool isRouter = radioConfig.preferences.is_router;
+
+    // If we are not a router and we already have AC power go to POWER state after init, otherwise go to ON
+    // We assume routers might be powered all the time, but from a low current (solar) source
+    bool isLowPower = radioConfig.preferences.is_low_power || isRouter;
+
+    /* To determine if we're externally powered, assumptions
+        1) If we're powered up and there's no battery, we must be getting power externally. (because we'd be dead otherwise)
+
+        2) If we detect USB power from the power management chip, we must be getting power externally.
+    */
+    return !isLowPower && powerStatus && (!powerStatus->getHasBattery() || powerStatus->getHasUSB());
+}
+
 static void sdsEnter()
 {
     // FIXME - make sure GPS and LORA radio are off first - because we want close to zero current draw
@@ -97,7 +114,8 @@ static void lsIdle()
 static void lsExit()
 {
     // setGPSPower(true); // restore GPS power
-    gps->forceWake(true);
+    if (gps)
+        gps->forceWake(true);
 }
 
 static void nbEnter()
@@ -118,14 +136,34 @@ static void serialEnter()
 {
     setBluetoothEnable(false);
     screen->setOn(true);
-    screen->print("Using API...\n");
+    screen->print("Serial connected\n");
+}
+
+static void serialExit()
+{
+    screen->print("Serial disconnected\n");
 }
 
 static void powerEnter()
 {
-    screen->setOn(true);
-    setBluetoothEnable(true);
-    screen->print("Powered...\n");
+    if (!isPowered()) {
+        // If we got here, we are in the wrong state - we should be in powered, let that state ahndle things
+        DEBUG_MSG("Loss of power in Powered\n");
+        powerFSM.trigger(EVENT_POWER_DISCONNECTED);
+    } else {
+        screen->setOn(true);
+        setBluetoothEnable(true);
+        screen->print("Powered...\n");
+    }
+}
+
+static void powerIdle()
+{
+    if (!isPowered()) {
+        // If we got here, we are in the wrong state
+        DEBUG_MSG("Loss of power in Powered\n");
+        powerFSM.trigger(EVENT_POWER_DISCONNECTED);
+    }
 }
 
 static void powerExit()
@@ -152,6 +190,14 @@ static void onEnter()
     }
 }
 
+static void onIdle()
+{
+    if (isPowered()) {
+        // If we got here, we are in the wrong state - we should be in powered, let that state ahndle things
+        powerFSM.trigger(EVENT_POWER_CONNECTED);
+    }
+}
+
 static void screenPress()
 {
     screen->onPress();
@@ -163,26 +209,16 @@ State stateSDS(sdsEnter, NULL, NULL, "SDS");
 State stateLS(lsEnter, lsIdle, lsExit, "LS");
 State stateNB(nbEnter, NULL, NULL, "NB");
 State stateDARK(darkEnter, NULL, NULL, "DARK");
-State stateSERIAL(serialEnter, NULL, NULL, "SERIAL");
+State stateSERIAL(serialEnter, NULL, serialExit, "SERIAL");
 State stateBOOT(bootEnter, NULL, NULL, "BOOT");
-State stateON(onEnter, NULL, NULL, "ON");
-State statePOWER(powerEnter, NULL, powerExit, "POWER");
+State stateON(onEnter, onIdle, NULL, "ON");
+State statePOWER(powerEnter, powerIdle, powerExit, "POWER");
 Fsm powerFSM(&stateBOOT);
 
 void PowerFSM_setup()
 {
     bool isRouter = radioConfig.preferences.is_router;
-        
-    // If we are not a router and we already have AC power go to POWER state after init, otherwise go to ON
-    // We assume routers might be powered all the time, but from a low current (solar) source
-    bool isLowPower = radioConfig.preferences.is_low_power || isRouter;
-
-    /* To determine if we're externally powered, assumptions
-        1) If we're powered up and there's no battery, we must be getting power externally. (because we'd be dead otherwise)
-
-        2) If we detect USB power from the power management chip, we must be getting power externally. 
-    */
-    bool hasPower = !isLowPower && powerStatus && (!powerStatus->getHasBattery() || powerStatus->getHasUSB());
+    bool hasPower = isPowered();
 
     DEBUG_MSG("PowerFSM init, USB power=%d\n", hasPower);
     powerFSM.add_timed_transition(&stateBOOT, hasPower ? &statePOWER : &stateON, 3 * 1000, NULL, "boot timeout");
@@ -230,25 +266,33 @@ void PowerFSM_setup()
         powerFSM.add_transition(&stateON, &stateON, EVENT_RECEIVED_TEXT_MSG, NULL, "Received text"); // restarts the sleep timer
     }
 
+    // If we are not in statePOWER but get a serial connection, suppress sleep (and keep the screen on) while connected
     powerFSM.add_transition(&stateLS, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
     powerFSM.add_transition(&stateNB, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
     powerFSM.add_transition(&stateDARK, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
     powerFSM.add_transition(&stateON, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
+    powerFSM.add_transition(&statePOWER, &stateSERIAL, EVENT_SERIAL_CONNECTED, NULL, "serial API");
 
-    if (!isLowPower) {
-        powerFSM.add_transition(&stateLS, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
-        powerFSM.add_transition(&stateNB, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
-        powerFSM.add_transition(&stateDARK, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
-        powerFSM.add_transition(&stateON, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
-    }
+    // If we get power connected, go to the power connect state
+    powerFSM.add_transition(&stateLS, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
+    powerFSM.add_transition(&stateNB, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
+    powerFSM.add_transition(&stateDARK, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
+    powerFSM.add_transition(&stateON, &statePOWER, EVENT_POWER_CONNECTED, NULL, "power connect");
 
     powerFSM.add_transition(&statePOWER, &stateON, EVENT_POWER_DISCONNECTED, NULL, "power disconnected");
-    powerFSM.add_transition(&stateSERIAL, &stateON, EVENT_POWER_DISCONNECTED, NULL, "power disconnected");
+    // powerFSM.add_transition(&stateSERIAL, &stateON, EVENT_POWER_DISCONNECTED, NULL, "power disconnected");
 
-    powerFSM.add_transition(&stateSERIAL, &stateNB, EVENT_SERIAL_DISCONNECTED, NULL, "serial disconnect");
+    // the only way to leave state serial is for the client to disconnect (or we timeout and force disconnect them)
+    // when we leave, go to ON (which might not be the correct state if we have power connected, we will fix that in onEnter)
+    powerFSM.add_transition(&stateSERIAL, &stateON, EVENT_SERIAL_DISCONNECTED, NULL, "serial disconnect");
 
     powerFSM.add_transition(&stateDARK, &stateDARK, EVENT_CONTACT_FROM_PHONE, NULL, "Contact from phone");
 
+    // each time we get a new update packet make sure we are staying in the ON state so the screen stays awake (also we don't
+    // shutdown bluetooth if is_router)
+    powerFSM.add_transition(&stateDARK, &stateON, EVENT_FIRMWARE_UPDATE, NULL, "Got firmware update");
+    powerFSM.add_transition(&stateON, &stateON, EVENT_FIRMWARE_UPDATE, NULL, "Got firmware update");
+
     powerFSM.add_transition(&stateNB, &stateDARK, EVENT_PACKET_FOR_PHONE, NULL, "Packet for phone");
 
     powerFSM.add_timed_transition(&stateON, &stateDARK, getPref_screen_on_secs() * 1000, NULL, "Screen-on timeout");
@@ -259,7 +303,9 @@ void PowerFSM_setup()
 #ifndef NRF52_SERIES
     // We never enter light-sleep or NB states on NRF52 (because the CPU uses so little power normally)
 
-    powerFSM.add_timed_transition(&stateDARK, &stateNB, getPref_phone_timeout_secs() * 1000, NULL, "Phone timeout");
+    // I don't think this transition is correct, turning off for now - @geeksville
+    // powerFSM.add_timed_transition(&stateDARK, &stateNB, getPref_phone_timeout_secs() * 1000, NULL, "Phone timeout");
+
     powerFSM.add_timed_transition(&stateNB, &stateLS, getPref_min_wake_secs() * 1000, NULL, "Min wake timeout");
     powerFSM.add_timed_transition(&stateDARK, &stateLS, getPref_wait_bluetooth_secs() * 1000, NULL, "Bluetooth timeout");
 #else

src/PowerFSM.h

@@ -18,6 +18,7 @@
 #define EVENT_SERIAL_DISCONNECTED 12
 #define EVENT_POWER_CONNECTED 13
 #define EVENT_POWER_DISCONNECTED 14
+#define EVENT_FIRMWARE_UPDATE 15 // We just received a new firmware update packet from the phone
 
 extern Fsm powerFSM;
 extern State statePOWER, stateSERIAL;

src/RedirectablePrint.cpp

@@ -1,4 +1,5 @@
 #include "RedirectablePrint.h"
+#include "RTC.h"
 #include "concurrency/OSThread.h"
 #include "configuration.h"
 #include <assert.h>
@@ -24,7 +25,8 @@ size_t RedirectablePrint::write(uint8_t c)
 #endif
 
     dest->write(c);
-    return 1; // We always claim one was written, rather than trusting what the serial port said (which could be zero)
+    return 1; // We always claim one was written, rather than trusting what the
+              // serial port said (which could be zero)
 }
 
 size_t RedirectablePrint::vprintf(const char *format, va_list arg)
@@ -49,10 +51,6 @@ size_t RedirectablePrint::vprintf(const char *format, va_list arg)
     return len;
 }
 
-#define SEC_PER_DAY 86400
-#define SEC_PER_HOUR 3600
-#define SEC_PER_MIN 60
-
 size_t RedirectablePrint::logDebug(const char *format, ...)
 {
     size_t r = 0;
@@ -68,9 +66,9 @@ size_t RedirectablePrint::logDebug(const char *format, ...)
 
         // If we are the first message on a report, include the header
         if (!isContinuationMessage) {
-            struct timeval tv;
-            if (!gettimeofday(&tv, NULL)) {
-                long hms = tv.tv_sec % SEC_PER_DAY;
+            uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityFromNet);
+            if (rtc_sec > 0) {
+                long hms = rtc_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)

src/SerialConsole.cpp

@@ -6,27 +6,29 @@
 
 #define Port Serial
 
-SerialConsole console;
+SerialConsole *console;
+
+void consoleInit()
+{
+    new SerialConsole(); // Must be dynamically allocated because we are now inheriting from thread
+}
 
 void consolePrintf(const char *format, ...)
 {
     va_list arg;
     va_start(arg, format);
-    console.vprintf(format, arg);
+    console->vprintf(format, arg);
     va_end(arg);
 }
 
 SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port)
 {
+    assert(!console);
+    console = this;
     canWrite = false; // We don't send packets to our port until it has talked to us first
-    // setDestination(&noopPrint); for testing, try turning off 'all' debug output and see what leaks
-}
+                      // setDestination(&noopPrint); for testing, try turning off 'all' debug output and see what leaks
 
-/// Do late init that can't happen at constructor time
-void SerialConsole::init()
-{
     Port.begin(SERIAL_BAUD);
-    StreamAPI::init();
     emitRebooted();
 }
 
@@ -34,14 +36,14 @@ void SerialConsole::init()
  * we override this to notice when we've received a protobuf over the serial
  * stream.  Then we shunt off debug serial output.
  */
-void SerialConsole::handleToRadio(const uint8_t *buf, size_t len)
+bool SerialConsole::handleToRadio(const uint8_t *buf, size_t len)
 {
     // Turn off debug serial printing once the API is activated, because other threads could print and corrupt packets
     if (!radioConfig.preferences.debug_log_enabled)
         setDestination(&noopPrint);
     canWrite = true;
 
-    StreamAPI::handleToRadio(buf, len);
+    return StreamAPI::handleToRadio(buf, len);
 }
 
 /// Hookable to find out when connection changes

src/SerialConsole.h

@@ -11,14 +11,11 @@ class SerialConsole : public StreamAPI, public RedirectablePrint
   public:
     SerialConsole();
 
-    /// Do late init that can't happen at constructor time
-    virtual void init();
-
     /**
      * we override this to notice when we've received a protobuf over the serial stream.  Then we shunt off
      * debug serial output.
      */
-    virtual void handleToRadio(const uint8_t *buf, size_t len);
+    virtual bool handleToRadio(const uint8_t *buf, size_t len);
 
     virtual size_t write(uint8_t c)
     {
@@ -34,5 +31,6 @@ class SerialConsole : public StreamAPI, public RedirectablePrint
 
 // A simple wrapper to allow non class aware code write to the console
 void consolePrintf(const char *format, ...);
+void consoleInit();
 
-extern SerialConsole console;
+extern SerialConsole *console;

src/airtime.h

@@ -47,8 +47,7 @@ class AirTime : private concurrency::OSThread
     void logAirtime(reportTypes reportType, uint32_t airtime_ms);
 
   protected:
-
-    virtual int32_t runOnce();
+    virtual int32_t runOnce() override;
 };
 
 extern AirTime *airTime;

src/buzz/buzz.cpp

@@ -0,0 +1,66 @@
+#include "buzz.h"
+#include "configuration.h"
+
+#ifdef NRF52_SERIES
+#include "variant.h"
+#endif
+
+#ifndef PIN_BUZZER
+
+// Noop methods for boards w/o buzzer
+void playBeep(){};
+void playStartMelody(){};
+void playShutdownMelody(){};
+
+#else
+#include "Tone.h"
+
+extern "C" void delay(uint32_t dwMs);
+
+struct ToneDuration {
+  int frequency_khz;
+  int duration_ms;
+};
+
+// Some common frequencies.
+#define NOTE_C3 131
+#define NOTE_CS3 139
+#define NOTE_D3 147
+#define NOTE_DS3 156
+#define NOTE_E3 165
+#define NOTE_F3 175
+#define NOTE_FS3 185
+#define NOTE_G3 196
+#define NOTE_GS3 208
+#define NOTE_A3 220
+#define NOTE_AS3 233
+#define NOTE_B3 247
+
+const int DURATION_1_8 = 125;  // 1/8 note
+const int DURATION_1_4 = 250;  // 1/4 note
+
+void playTones(const ToneDuration *tone_durations, int size) {
+  for (int i = 0; i < size; i++) {
+    const auto &tone_duration = tone_durations[i];
+    tone(PIN_BUZZER, tone_duration.frequency_khz, tone_duration.duration_ms);
+    // to distinguish the notes, set a minimum time between them.
+    delay(1.3 * tone_duration.duration_ms);
+  }
+}
+
+void playBeep() { tone(PIN_BUZZER, NOTE_B3, DURATION_1_4); }
+
+void playStartMelody() {
+  ToneDuration melody[] = {{NOTE_B3, DURATION_1_4},
+                           {NOTE_B3, DURATION_1_8},
+                           {NOTE_B3, DURATION_1_8}};
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+}
+
+void playShutdownMelody() {
+  ToneDuration melody[] = {{NOTE_B3, DURATION_1_4},
+                           {NOTE_G3, DURATION_1_8},
+                           {NOTE_D3, DURATION_1_8}};
+  playTones(melody, sizeof(melody) / sizeof(ToneDuration));
+}
+#endif

src/buzz/buzz.h

@@ -0,0 +1,5 @@
+#pragma once
+
+void playBeep();
+void playStartMelody();
+void playShutdownMelody();

src/concurrency/BinarySemaphoreFreeRTOS.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "configuration.h"
 #include "../freertosinc.h"
 
 namespace concurrency
@@ -28,4 +27,4 @@ class BinarySemaphoreFreeRTOS
 
 #endif
 
-} 
+} // namespace concurrency

src/concurrency/BinarySemaphorePosix.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "configuration.h"
 #include "../freertosinc.h"
 
 namespace concurrency
@@ -28,4 +27,4 @@ class BinarySemaphorePosix
 
 #endif
 
-} 
+} // namespace concurrency

src/concurrency/NotifiedWorkerThread.cpp

@@ -1,5 +1,6 @@
 #include "NotifiedWorkerThread.h"
 #include "configuration.h"
+#include "main.h"
 #include <assert.h>
 
 namespace concurrency
@@ -28,6 +29,7 @@ IRAM_ATTR bool NotifiedWorkerThread::notifyCommon(uint32_t v, bool overwrite)
     if (overwrite || notification == 0) {
         enabled = true;
         setInterval(0); // Run ASAP
+        runASAP = true;
 
         notification = v;
         if (debugNotification)

src/configuration.h

@@ -311,7 +311,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #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 HardwareModel_TLORA_V1p3
+#define HW_VENDOR HardwareModel_TLORA_V1_1p3
 
 #undef GPS_RX_PIN
 #undef GPS_TX_PIN
@@ -342,7 +342,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_RX_PIN 15 // per @der_bear on the forum, 36 is incorrect for this board type and 15 is a better pick
 #define GPS_TX_PIN 13
 
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
@@ -457,7 +457,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "SerialConsole.h"
 
-#define DEBUG_PORT console // Serial debug port
+#define DEBUG_PORT (*console) // Serial debug port
 
 // What platforms should use SEGGER?
 #ifdef NRF52_SERIES

src/esp32/BluetoothSoftwareUpdate.cpp

@@ -1,14 +1,14 @@
 #include <Arduino.h>
 
 #include "../concurrency/LockGuard.h"
+#include "../graphics/Screen.h"
+#include "../main.h"
 #include "BluetoothSoftwareUpdate.h"
+#include "NodeDB.h"
 #include "PowerFSM.h"
 #include "RadioLibInterface.h"
 #include "configuration.h"
 #include "nimble/BluetoothUtil.h"
-#include "NodeDB.h"
-#include "../graphics/Screen.h"
-#include "../main.h"
 
 #include <CRC32.h>
 #include <Update.h>
@@ -16,7 +16,6 @@
 int16_t updateResultHandle = -1;
 
 static CRC32 crc;
-static uint32_t rebootAtMsec = 0; // If not zero we will reboot at this time (used to reboot shortly after the update completes)
 
 static uint32_t updateExpectedSize, updateActualSize;
 static uint8_t update_result;
@@ -51,8 +50,8 @@ int update_size_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_
 
             screen->startFirmwareUpdateScreen();
             if (RadioLibInterface::instance)
-                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
+                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
         }
     }
 
@@ -78,7 +77,7 @@ int update_data_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble_
     crc.update(data, len);
     Update.write(data, len);
     updateActualSize += len;
-    powerFSM.trigger(EVENT_CONTACT_FROM_PHONE);
+    powerFSM.trigger(EVENT_FIRMWARE_UPDATE);
 
     return 0;
 }
@@ -107,8 +106,7 @@ int update_crc32_callback(uint16_t conn_handle, uint16_t attr_handle, struct ble
             if (update_region == U_SPIFFS) {
                 DEBUG_MSG("SPIFFS updated!\n");
                 nodeDB.saveToDisk(); // Since we just wiped spiffs, we need to save our current state
-            }
-            else {
+            } else {
                 DEBUG_MSG("Appload updated, rebooting in 5 seconds!\n");
                 rebootAtMsec = millis() + 5000;
             }
@@ -140,14 +138,6 @@ int update_region_callback(uint16_t conn_handle, uint16_t attr_handle, struct bl
     return chr_readwrite8(&update_region, sizeof(update_region), ctxt);
 }
 
-void bluetoothRebootCheck()
-{
-    if (rebootAtMsec && millis() > rebootAtMsec) {
-        DEBUG_MSG("Rebooting for update\n");
-        ESP.restart();
-    }
-}
-
 /*
 See bluetooth-api.md
 

src/esp32/BluetoothSoftwareUpdate.h

@@ -4,8 +4,6 @@
 
 void reinitUpdateService();
 
-void bluetoothRebootCheck();
-
 #ifdef __cplusplus
 extern "C" {
 #endif

src/esp32/main-esp32.cpp

@@ -7,9 +7,10 @@
 #include "sleep.h"
 #include "target_specific.h"
 #include "utils.h"
+#include <Preferences.h>
+#include <driver/rtc_io.h>
 #include <nvs.h>
 #include <nvs_flash.h>
-#include <driver/rtc_io.h>
 
 void getMacAddr(uint8_t *dmac)
 {
@@ -45,6 +46,18 @@ void esp32Setup()
     DEBUG_MSG("NVS: UsedEntries %d, FreeEntries %d, AllEntries %d\n", nvs_stats.used_entries, nvs_stats.free_entries,
               nvs_stats.total_entries);
 
+    DEBUG_MSG("Setup Preferences in Flash Storage\n");
+
+    // Create object to store our persistant data
+    Preferences preferences;
+    preferences.begin("meshtastic", false);
+
+    uint32_t rebootCounter = preferences.getUInt("rebootCounter", 0);
+    rebootCounter++;
+    preferences.putUInt("rebootCounter", rebootCounter);
+    preferences.end();
+    DEBUG_MSG("Number of Device Reboots: %d\n", rebootCounter);
+
     // enableModemSleep();
 
 // Since we are turning on watchdogs rather late in the release schedule, we really don't want to catch any
@@ -84,7 +97,6 @@ void esp32Loop()
 {
     esp_task_wdt_reset(); // service our app level watchdog
     loopBLE();
-    bluetoothRebootCheck();
 
     // for debug printing
     // radio.radioIf.canSleep();

src/gps/GPS.cpp

@@ -308,3 +308,49 @@ int GPS::prepareDeepSleep(void *unused)
 
     return 0;
 }
+
+#ifdef GPS_TX_PIN
+#include "UBloxGPS.h"
+#endif
+
+#ifdef HAS_AIR530_GPS
+#include "Air530GPS.h"
+#elif !defined(NO_GPS)
+#include "NMEAGPS.h"
+#endif
+
+
+GPS* createGps() {
+
+#ifdef NO_GPS
+    return nullptr;
+#else
+// If we don't have bidirectional comms, we can't even try talking to UBLOX
+#ifdef GPS_TX_PIN
+    // Init GPS - first try ublox
+    UBloxGPS *ublox = new UBloxGPS();
+    
+    if (!ublox->setup()) {
+        DEBUG_MSG("ERROR: No UBLOX GPS found\n");
+        delete ublox;
+        ublox = NULL;
+    } else {
+        return ublox;
+    }
+#endif
+
+    if (GPS::_serial_gps) {
+        // Some boards might have only the TX line from the GPS connected, in that case, we can't configure it at all.  Just
+        // assume NMEA at 9600 baud.
+        DEBUG_MSG("Hoping that NMEA might work\n");
+#ifdef HAS_AIR530_GPS
+        GPS* new_gps = new Air530GPS();
+#else
+        GPS* new_gps = new NMEAGPS();
+#endif
+        new_gps->setup();
+        return new_gps;
+    }
+    return nullptr;
+#endif
+}

src/gps/GPS.h

@@ -71,6 +71,9 @@ class GPS : private concurrency::OSThread
      * */
     void forceWake(bool on);
 
+    // Some GPS modules (ublock) require factory reset
+    virtual bool factoryReset() { return true; }
+
   protected:
     /// Do gps chipset specific init, return true for success
     virtual bool setupGPS();
@@ -145,4 +148,8 @@ class GPS : private concurrency::OSThread
     virtual int32_t runOnce();
 };
 
+// Creates an instance of the GPS class. 
+// Returns the new instance or null if the GPS is not present.
+GPS* createGps();
+
 extern GPS *gps;

src/gps/RTC.cpp

@@ -39,22 +39,23 @@ bool perhapsSetRTC(RTCQuality q, const struct timeval *tv)
         currentQuality = q;
         shouldSet = true;
         DEBUG_MSG("Upgrading time to RTC %ld secs (quality %d)\n", tv->tv_sec, q);
-    } else if(q == RTCQualityGPS && (now - lastSetMsec) > (12 * 60 * 60 * 1000L)) {
+    } else if(q == RTCQualityGPS && (now - lastSetMsec) > (12 * 60 * 60 * 1000UL)) {
         // Every 12 hrs we will slam in a new GPS time, to correct for local RTC clock drift
         shouldSet = true;
-        DEBUG_MSG("Reapplying GPS time to correct clock drift %ld secs\n", tv->tv_sec);
+        DEBUG_MSG("Reapplying external time to correct clock drift %ld secs\n", tv->tv_sec);
     }
     else
         shouldSet = false;
 
     if (shouldSet) {
-        lastSetMsec = now;
+        lastSetMsec = now;       
 #ifndef NO_ESP32
         settimeofday(tv, NULL);
-#else
-        DEBUG_MSG("ERROR TIME SETTING NOT IMPLEMENTED!\n");
-#endif
         readFromRTC();
+#else 
+        timeStartMsec = now;
+        zeroOffsetSecs = tv->tv_sec;
+#endif
         return true;
     } else {
         return false;

src/gps/RTC.h

@@ -27,4 +27,8 @@ uint32_t getTime();
 /// Return time since 1970 in secs.  If quality is RTCQualityNone return zero
 uint32_t getValidTime(RTCQuality minQuality);
 
-void readFromRTC();
+void readFromRTC();
+
+#define SEC_PER_DAY 86400
+#define SEC_PER_HOUR 3600
+#define SEC_PER_MIN 60

src/graphics/Screen.cpp

@@ -28,11 +28,12 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "Screen.h"
 #include "configuration.h"
 #include "fonts.h"
+#include "gps/RTC.h"
 #include "graphics/images.h"
 #include "main.h"
 #include "mesh-pb-constants.h"
-#include "plugins/TextMessagePlugin.h"
 #include "mesh/Channels.h"
+#include "plugins/TextMessagePlugin.h"
 #include "target_specific.h"
 #include "utils.h"
 
@@ -155,24 +156,22 @@ static void drawPluginFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int
 {
     uint8_t plugin_frame;
     // there's a little but in the UI transition code
-    // where it invokes the function at the correct offset 
+    // 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" 
+    // 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 
+        // 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 {
+    } 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("Screen is not in transition.  Frame: %d\n\n", plugin_frame);
     }
-    //DEBUG_MSG("Drawing Plugin 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);
-    
+    pi.drawFrame(display, state, x, y);
 }
 
 static void drawFrameBluetooth(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
@@ -204,11 +203,10 @@ static void drawFrameFirmware(OLEDDisplay *display, OLEDDisplayUiState *state, i
     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);
+    // 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)
 {
@@ -719,6 +717,7 @@ void Screen::handleSetOn(bool on)
             dispdev.displayOn();
             enabled = true;
             setInterval(0); // Draw ASAP
+            runASAP = true;
         } else {
             DEBUG_MSG("Turning off screen\n");
             dispdev.displayOff();
@@ -793,7 +792,7 @@ void Screen::setup()
     powerStatusObserver.observe(&powerStatus->onNewStatus);
     gpsStatusObserver.observe(&gpsStatus->onNewStatus);
     nodeStatusObserver.observe(&nodeStatus->onNewStatus);
-    if(textMessagePlugin)
+    if (textMessagePlugin)
         textMessageObserver.observe(textMessagePlugin);
 }
 
@@ -842,7 +841,7 @@ int32_t Screen::runOnce()
             break;
         case Cmd::START_FIRMWARE_UPDATE_SCREEN:
             handleStartFirmwareUpdateScreen();
-            break;            
+            break;
         case Cmd::STOP_BLUETOOTH_PIN_SCREEN:
         case Cmd::STOP_BOOT_SCREEN:
             setFrames();
@@ -936,7 +935,7 @@ void Screen::setFrames()
     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
@@ -1055,6 +1054,7 @@ void Screen::setFastFramerate()
     targetFramerate = SCREEN_TRANSITION_FRAMERATE;
     ui.setTargetFPS(targetFramerate);
     setInterval(0); // redraw ASAP
+    runASAP = true;
 }
 
 void DebugInfo::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y)
@@ -1286,14 +1286,41 @@ void DebugInfo::drawFrameSettings(OLEDDisplay *display, OLEDDisplayUiState *stat
     uint32_t minutes = seconds / 60;
     uint32_t hours = minutes / 60;
     uint32_t days = hours / 24;
-    currentMillis %= 1000;
-    seconds %= 60;
-    minutes %= 60;
-    hours %= 24;
+    // currentMillis %= 1000;
+    // seconds %= 60;
+    // minutes %= 60;
+    // hours %= 24;
 
-    display->drawString(x, y + FONT_HEIGHT_SMALL * 1,
-                        String(days) + "d " + (hours < 10 ? "0" : "") + String(hours) + ":" + (minutes < 10 ? "0" : "") +
-                            String(minutes) + ":" + (seconds < 10 ? "0" : "") + String(seconds));
+    // Show uptime as days, hours, minutes OR seconds
+    String uptime;
+    if (days >= 2)
+        uptime += String(days) + "d ";
+    else if (hours >= 2)
+        uptime += String(hours) + "h ";
+    else if (minutes >= 1)
+        uptime += String(minutes) + "m ";
+    else
+        uptime += String(seconds) + "s ";
+
+    uint32_t rtc_sec = getValidTime(RTCQuality::RTCQualityFromNet);
+    if (rtc_sec > 0) {
+        long hms = rtc_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
+
+        char timebuf[9];
+        snprintf(timebuf, sizeof(timebuf), "%02d:%02d:%02d", hour, min, sec);
+        uptime += timebuf;
+    }
+
+    display->drawString(x, y + FONT_HEIGHT_SMALL * 1, uptime);
 
 #ifndef NO_ESP32
     // Show CPU Frequency.

src/graphics/Screen.h

@@ -1,5 +1,23 @@
 #pragma once
 
+#ifdef NO_SCREEN
+namespace graphics
+{
+// Noop class for boards without screen.
+class Screen 
+{
+  public:
+    Screen(char){}
+    void onPress() {}
+    void setup() {}
+    void setOn(bool) {}
+    void print(const char*){}
+    void adjustBrightness(){}
+    void doDeepSleep() {}
+};
+}
+
+#else
 #include <cstring>
 
 #include <OLEDDisplayUi.h>
@@ -278,3 +296,4 @@ class Screen : public concurrency::OSThread
 };
 
 } // namespace graphics
+#endif

src/main.cpp

@@ -1,11 +1,11 @@
 
-#include "Air530GPS.h"
+#include "GPS.h"
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
-#include "UBloxGPS.h"
 #include "airtime.h"
+#include "buzz.h"
 #include "configuration.h"
 #include "error.h"
 #include "power.h"
@@ -32,8 +32,9 @@
 #include "nimble/BluetoothUtil.h"
 #endif
 
-#ifdef PORTDUINO
+#if defined(HAS_WIFI) || defined(PORTDUINO)
 #include "mesh/wifi/WiFiServerAPI.h"
+#include "mqtt/MQTT.h"
 #endif
 
 #include "RF95Interface.h"
@@ -67,7 +68,7 @@ Router *router = NULL; // Users of router don't care what sort of subclass imple
 // -----------------------------------------------------------------------------
 // Application
 // -----------------------------------------------------------------------------
-
+#ifndef NO_WIRE
 void scanI2Cdevice(void)
 {
     byte err, addr;
@@ -104,6 +105,9 @@ void scanI2Cdevice(void)
     else
         DEBUG_MSG("done\n");
 }
+#else
+void scanI2Cdevice(void) {}
+#endif
 
 const char *getDeviceName()
 {
@@ -173,6 +177,7 @@ class ButtonThread : public OSThread
 #ifdef BUTTON_PIN_ALT
     OneButton userButtonAlt;
 #endif
+    static bool shutdown_on_long_stop;
 
   public:
     static uint32_t longPressTime;
@@ -239,13 +244,23 @@ class ButtonThread : public OSThread
         // DEBUG_MSG("Long press!\n");
         screen->adjustBrightness();
 
-        // If user button is held down for 10 seconds, shutdown the device.
-        if (millis() - longPressTime > 10 * 1000) {
+        // If user button is held down for 5 seconds, shutdown the device.
+        if (millis() - longPressTime > 5 * 1000) {
 #ifdef TBEAM_V10
             if (axp192_found == true) {
                 setLed(false);
                 power->shutdown();
             }
+#elif NRF52_SERIES
+            // Do actual shutdown when button released, otherwise the button release
+            // may wake the board immediatedly.
+            if (!shutdown_on_long_stop) {
+                DEBUG_MSG("Shutdown from long press");
+                playBeep();
+                ledOff(PIN_LED1);
+                ledOff(PIN_LED2);
+                shutdown_on_long_stop = true;
+            }
 #endif
         } else {
             // DEBUG_MSG("Long press %u\n", (millis() - longPressTime));
@@ -269,9 +284,15 @@ class ButtonThread : public OSThread
     {
         DEBUG_MSG("Long press stop!\n");
         longPressTime = 0;
+        if (shutdown_on_long_stop) {
+            playShutdownMelody();
+            power->shutdown();
+        }
     }
 };
 
+bool ButtonThread::shutdown_on_long_stop = false;
+
 static Periodic *ledPeriodic;
 static OSThread *powerFSMthread, *buttonThread;
 uint32_t ButtonThread::longPressTime = 0;
@@ -296,9 +317,10 @@ void setup()
     SEGGER_RTT_ConfigUpBuffer(0, NULL, NULL, 0, SEGGER_RTT_MODE_NO_BLOCK_TRIM);
 #endif
 
-// Debug
 #ifdef DEBUG_PORT
-    DEBUG_PORT.init(); // Set serial baud rate and init our mesh console
+    if (!radioConfig.preferences.serial_disabled) {
+        consoleInit(); // Set serial baud rate and init our mesh console
+    }
 #endif
 
     initDeepSleep();
@@ -345,7 +367,7 @@ void setup()
 
 #ifdef I2C_SDA
     Wire.begin(I2C_SDA, I2C_SCL);
-#else
+#elif !defined(NO_WIRE)
     Wire.begin();
 #endif
 
@@ -382,7 +404,7 @@ void setup()
 #ifdef NRF52_SERIES
     nrf52Setup();
 #endif
-
+    playStartMelody();
     // We do this as early as possible because this loads preferences from flash
     // but we need to do this after main cpu iniot (esp32setup), because we need the random seed set
     nodeDB.init();
@@ -420,34 +442,7 @@ void setup()
     pinMode(BATTERY_EN_PIN, OUTPUT);
     digitalWrite(BATTERY_EN_PIN, LOW);
 #endif
-
-    // If we don't have bidirectional comms, we can't even try talking to UBLOX
-    UBloxGPS *ublox = NULL;
-#ifdef GPS_TX_PIN
-    // Init GPS - first try ublox
-    ublox = new UBloxGPS();
-    gps = ublox;
-    if (!gps->setup()) {
-        DEBUG_MSG("ERROR: No UBLOX GPS found\n");
-
-        delete ublox;
-        gps = ublox = NULL;
-    }
-#endif
-
-    if (!gps && GPS::_serial_gps) {
-        // Some boards might have only the TX line from the GPS connected, in that case, we can't configure it at all.  Just
-        // assume NMEA at 9600 baud.
-        // dumb NMEA access only work for serial GPSes)
-        DEBUG_MSG("Hoping that NMEA might work\n");
-
-#ifdef HAS_AIR530_GPS
-        gps = new Air530GPS();
-#else
-        gps = new NMEAGPS();
-#endif
-        gps->setup();
-    }
+    gps = createGps();
 
     if (gps)
         gpsStatus->observe(&gps->newStatus);
@@ -481,8 +476,8 @@ void setup()
     // We have now loaded our saved preferences from flash
 
     // ONCE we will factory reset the GPS for bug #327
-    if (ublox && !devicestate.did_gps_reset) {
-        if (ublox->factoryReset()) { // If we don't succeed try again next time
+    if (gps && !devicestate.did_gps_reset) {
+        if (gps->factoryReset()) { // If we don't succeed try again next time
             devicestate.did_gps_reset = true;
             nodeDB.saveToDisk();
         }
@@ -547,6 +542,10 @@ void setup()
     initApiServer();
 #endif
 
+#if defined(PORTDUINO) || defined(HAS_WIFI)
+    mqttInit();
+#endif
+
     // Start airtime logger thread.
     airTime = new AirTime();
 
@@ -584,13 +583,29 @@ Periodic axpDebugOutput(axpDebugRead);
 axpDebugOutput.setup();
 #endif
 
+uint32_t rebootAtMsec; // If not zero we will reboot at this time (used to reboot shortly after the update completes)
+
+void rebootCheck()
+{
+    if (rebootAtMsec && millis() > rebootAtMsec) {
+#ifndef NO_ESP32
+        DEBUG_MSG("Rebooting for update\n");
+        ESP.restart();
+#else
+        DEBUG_MSG("FIXME implement reboot for this platform");
+#endif
+    }
+}
+
+// If a thread does something that might need for it to be rescheduled ASAP it can set this flag
+// This will supress the current delay and instead try to run ASAP.
+bool runASAP;
+
 void loop()
 {
-    // axpDebugOutput.loop();
+    runASAP = false;
 
-#ifdef DEBUG_PORT
-    DEBUG_PORT.loop(); // Send/receive protobufs over the serial port
-#endif
+    // axpDebugOutput.loop();
 
     // heap_caps_check_integrity_all(true); // FIXME - disable this expensive check
 
@@ -600,6 +615,7 @@ void loop()
 #ifdef NRF52_SERIES
     nrf52Loop();
 #endif
+    rebootCheck();
 
     // For debugging
     // if (rIf) ((RadioLibInterface *)rIf)->isActivelyReceiving();
@@ -624,6 +640,7 @@ void loop()
                   mainController.nextThread->tillRun(millis())); */
 
     // We want to sleep as long as possible here - because it saves power
-    mainDelay.delay(delayMsec);
+    if (!runASAP)
+        mainDelay.delay(delayMsec);
     // if (didWake) DEBUG_MSG("wake!\n");
 }

src/main.h

@@ -20,4 +20,10 @@ extern graphics::Screen *screen;
 // Return a human readable string of the form "Meshtastic_ab13"
 const char *getDeviceName();
 
+extern uint32_t rebootAtMsec;
+
+// If a thread does something that might need for it to be rescheduled ASAP it can set this flag
+// This will supress the current delay and instead try to run ASAP.
+extern bool runASAP;
+
 void nrf52Setup(), esp32Setup(), nrf52Loop(), esp32Loop();

src/mesh/Channels.cpp

@@ -33,7 +33,7 @@ int16_t Channels::generateHash(ChannelIndex channelNum)
         return -1; // invalid
     else {
         const char *name = getName(channelNum);
-        uint8_t h = xorHash((const uint8_t *) name, strlen(name));
+        uint8_t h = xorHash((const uint8_t *)name, strlen(name));
 
         h ^= xorHash(k.bytes, k.length);
 
@@ -184,7 +184,7 @@ void Channels::onConfigChanged()
 
 Channel &Channels::getByIndex(ChannelIndex chIndex)
 {
-    assert(chIndex < channelFile.channels_count);
+    assert(chIndex < channelFile.channels_count); // This should be equal to MAX_NUM_CHANNELS
     Channel *ch = channelFile.channels + chIndex;
     return *ch;
 }
@@ -278,11 +278,11 @@ const char *Channels::getPrimaryName()
  */
 bool Channels::decryptForHash(ChannelIndex chIndex, ChannelHash channelHash)
 {
-    if(chIndex > getNumChannels() || getHash(chIndex) != channelHash) {
-        // DEBUG_MSG("Skipping channel %d (hash %x) due to invalid hash/index, want=%x\n", chIndex, getHash(chIndex), channelHash);
+    if (chIndex > getNumChannels() || getHash(chIndex) != channelHash) {
+        // DEBUG_MSG("Skipping channel %d (hash %x) due to invalid hash/index, want=%x\n", chIndex, getHash(chIndex),
+        // channelHash);
         return false;
-    }
-    else {
+    } else {
         DEBUG_MSG("Using channel %d (hash 0x%x)\n", chIndex, channelHash);
         setCrypto(chIndex);
         return true;

src/mesh/Channels.h

@@ -29,7 +29,6 @@ class Channels
     int16_t hashes[MAX_NUM_CHANNELS];
 
   public:
-
     /// Well known channel names
     static const char *adminChannel, *gpioChannel, *serialChannel;
 
@@ -43,8 +42,15 @@ class Channels
      */
     void setChannel(const Channel &c);
 
+    /** Return a human friendly name for this channel (and expand any short strings as needed)
+     */
     const char *getName(size_t chIndex);
 
+    /**
+     * Return a globally unique channel ID usable with MQTT.
+     */
+    const char *getGlobalId(size_t chIndex) { return getName(chIndex); } // FIXME, not correct
+
     /** The index of the primary channel */
     ChannelIndex getPrimaryIndex() const { return primaryIndex; }
 

src/mesh/MeshPlugin.cpp

@@ -31,12 +31,47 @@ MeshPlugin::~MeshPlugin()
     assert(0); // FIXME - remove from list of plugins once someone needs this feature
 }
 
+MeshPacket *MeshPlugin::allocAckNak(Routing_Error err, NodeNum to, PacketId idFrom, ChannelIndex chIndex)
+{
+    Routing c = Routing_init_default;
+
+    c.error_reason = err;
+    c.which_variant = Routing_error_reason_tag;
+
+    // Now that we have moded sendAckNak up one level into the class heirarchy we can no longer assume we are a RoutingPlugin
+    // So we manually call pb_encode_to_bytes and specify routing port number
+    // auto p = allocDataProtobuf(c);
+    MeshPacket *p = router->allocForSending();
+    p->decoded.portnum = PortNum_ROUTING_APP;
+    p->decoded.payload.size = pb_encode_to_bytes(p->decoded.payload.bytes, sizeof(p->decoded.payload.bytes), Routing_fields, &c);
+
+    p->priority = MeshPacket_Priority_ACK;
+
+    p->hop_limit = 0; // Assume just immediate neighbors for now
+    p->to = to;
+    p->decoded.request_id = idFrom;
+    p->channel = chIndex;
+    DEBUG_MSG("Alloc an err=%d,to=0x%x,idFrom=0x%x,id=0x%x\n", err, to, idFrom, p->id);
+
+    return p;
+}
+
+MeshPacket *MeshPlugin::allocErrorResponse(Routing_Error err, const MeshPacket *p)
+{
+    auto r = allocAckNak(err, getFrom(p), p->id, p->channel);
+
+    setReplyTo(r, *p);
+
+    return r;
+}
+
 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?
+    // We now allow **encrypted** packets to pass through the plugins
+    bool isDecoded = mp.which_payloadVariant == MeshPacket_decoded_tag;
 
     currentReply = NULL; // No reply yet
 
@@ -48,37 +83,61 @@ void MeshPlugin::callPlugins(const MeshPacket &mp)
 
         pi.currentRequest = ∓
 
-        /// received channel
-        auto ch = channels.getByIndex(mp.channel);
-        assert(ch.has_settings);
-
-        /// Is the channel this packet arrived on acceptable? (security check)
-        bool rxChannelOk = !pi.boundChannel || (mp.from == 0) || (strcmp(ch.settings.name, pi.boundChannel) == 0);
-
         /// We only call plugins that are interested in the packet (and the message is destined to us or we are promiscious)
-        bool wantsPacket = rxChannelOk && (pi.isPromiscuous || toUs) && pi.wantPacket(&mp);
-        // DEBUG_MSG("Plugin %s wantsPacket=%d\n", pi.name, wantsPacket);
+        bool wantsPacket = (isDecoded || pi.encryptedOk) && (pi.isPromiscuous || toUs) && pi.wantPacket(&mp);
+
+        DEBUG_MSG("Plugin %s wantsPacket=%d\n", pi.name, wantsPacket);
+        assert(!pi.myReply); // If it is !null it means we have a bug, because it should have been sent the previous time
+
         if (wantsPacket) {
             pluginFound = true;
 
-            bool handled = pi.handleReceived(mp);
+            /// received channel (or NULL if not decoded)
+            Channel *ch = isDecoded ? &channels.getByIndex(mp.channel) : NULL;
 
-            // 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
+            /// Is the channel this packet arrived on acceptable? (security check)
+            /// Note: we can't know channel names for encrypted packets, so those are NEVER sent to boundChannel plugins
+            bool rxChannelOk = !pi.boundChannel || (ch && ((mp.from == 0) || (strcmp(ch->settings.name, pi.boundChannel) == 0)));
 
-            // 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);
+            if (!rxChannelOk) {
+                // no one should have already replied!
+                assert(!currentReply);
+
+                if (mp.decoded.want_response) {
+                    DEBUG_MSG("packet on wrong channel, returning error\n");
+                    currentReply = pi.allocErrorResponse(Routing_Error_NOT_AUTHORIZED, &mp);
+                } else
+                    DEBUG_MSG("packet on wrong channel, but client didn't want response\n");
             } else {
-                DEBUG_MSG("Plugin %s considered\n", pi.name);
-            }
-            if (handled) {
-                DEBUG_MSG("Plugin %s handled and skipped other processing\n", pi.name);
-                break;
+
+                bool handled = pi.handleReceived(mp);
+
+                // Possibly send replies (but only if the message was directed to us specifically, i.e. not for promiscious
+                // sniffing) also: we only let the one plugin send a reply, once that happens, remaining plugins are not
+                // considered
+
+                // 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 the requester didn't ask for a response we might need to discard unused replies to prevent memory leaks
+                if (pi.myReply) {
+                    DEBUG_MSG("Discarding an unneeded response\n");
+                    packetPool.release(pi.myReply);
+                    pi.myReply = NULL;
+                }
+
+                if (handled) {
+                    DEBUG_MSG("Plugin %s handled and skipped other processing\n", pi.name);
+                    break;
+                }
             }
         }
 
@@ -87,13 +146,16 @@ void MeshPlugin::callPlugins(const MeshPacket &mp)
 
     if (mp.decoded.want_response && toUs) {
         if (currentReply) {
-            DEBUG_MSG("Sending response\n");
+            printPacket("Sending response", currentReply);
             service.sendToMesh(currentReply);
             currentReply = NULL;
-        }
-        else {
+        } else {
             // No one wanted to reply to this requst, tell the requster that happened
             DEBUG_MSG("No one responded, send a nak\n");
+
+            // SECURITY NOTE! I considered sending back a different error code if we didn't find the psk (i.e. !isDecoded)
+            // but opted NOT TO.  Because it is not a good idea to let remote nodes 'probe' to find out which PSKs were "good" vs
+            // bad.
             routingPlugin->sendAckNak(Routing_Error_NO_RESPONSE, getFrom(&mp), mp.id, mp.channel);
         }
     }
@@ -102,6 +164,13 @@ void MeshPlugin::callPlugins(const MeshPacket &mp)
         DEBUG_MSG("No plugins interested in portnum=%d\n", mp.decoded.portnum);
 }
 
+MeshPacket *MeshPlugin::allocReply()
+{
+    auto r = myReply;
+    myReply = NULL; // Only use each reply once
+    return r;
+}
+
 /** 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
@@ -124,7 +193,7 @@ void MeshPlugin::sendResponse(const MeshPacket &req)
 void setReplyTo(MeshPacket *p, const MeshPacket &to)
 {
     assert(p->which_payloadVariant == MeshPacket_decoded_tag); // Should already be set by now
-    p->to = getFrom(&to);
+    p->to = getFrom(&to);    // Make sure that if we are sending to the local node, we use our local node addr, not 0
     p->channel = to.channel; // Use the same channel that the request came in on
 
     // No need for an ack if we are just delivering locally (it just generates an ignored ack)

src/mesh/MeshPlugin.h

@@ -1,9 +1,14 @@
 #pragma once
 
+#include "mesh/Channels.h"
 #include "mesh/MeshTypes.h"
+#include <vector>
+
+#ifndef NO_SCREEN
 #include <OLEDDisplay.h>
 #include <OLEDDisplayUi.h>
-#include <vector>
+#endif
+
 /** A baseclass for any mesh "plugin".
  *
  * A plugin allows you to add new features to meshtastic device code, without needing to know messaging details.
@@ -31,18 +36,22 @@ class MeshPlugin
     static void callPlugins(const MeshPacket &mp);
 
     static std::vector<MeshPlugin *> GetMeshPluginsWithUIFrames();
-
+#ifndef NO_SCREEN
     virtual void drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) { return; }
-
+#endif
   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
+    /** 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;
 
+    /** Most plugins only understand decrypted packets.  For plugins that also want to see encrypted packets, they should set this
+     * flag */
+    bool encryptedOk = false;
+
     /** If a bound channel name is set, we will only accept received packets that come in on that channel.
      * A special exception (FIXME, not sure if this is a good idea) - packets that arrive on the local interface
      * are allowed on any channel (this lets the local user do anything).
@@ -60,6 +69,11 @@ class MeshPlugin
      */
     static const MeshPacket *currentRequest;
 
+    /**
+     * If your handler wants to send a response, simply set currentReply and it will be sent at the end of response handling.
+     */
+    MeshPacket *myReply = NULL;
+
     /**
      * Initialize your plugin.  This setup function is called once after all hardware and mesh protocol layers have
      * been initialized
@@ -78,20 +92,30 @@ class MeshPlugin
     virtual bool handleReceived(const MeshPacket &mp) { return false; }
 
     /** 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() { return NULL; }
+     * so that subclasses can (optionally) send a response back to the original sender.
+     *
+     * Note: most implementers don't need to override this, instead: If while handling a request you have a reply, just set
+     * the protected reply field in this instance.
+     * */
+    virtual MeshPacket *allocReply();
 
     /***
      * @return true if you want to be alloced a UI screen frame
      */
     virtual bool wantUIFrame() { return false; }
 
+    MeshPacket *allocAckNak(Routing_Error err, NodeNum to, PacketId idFrom, ChannelIndex chIndex);
+
+    /// Send an error response for the specified packet.
+    MeshPacket *allocErrorResponse(Routing_Error err, const MeshPacket *p);
+
   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

src/mesh/MeshService.cpp

@@ -114,7 +114,7 @@ bool MeshService::reloadConfig()
 void MeshService::reloadOwner()
 {
     assert(nodeInfoPlugin);
-    if(nodeInfoPlugin)
+    if (nodeInfoPlugin)
         nodeInfoPlugin->sendOurNodeInfo();
     nodeDB.saveToDisk();
 }
@@ -172,13 +172,12 @@ void MeshService::sendNetworkPing(NodeNum dest, bool wantReplies)
     assert(node);
 
     if (node->has_position) {
-        if(positionPlugin) {
+        if (positionPlugin) {
             DEBUG_MSG("Sending position ping to 0x%x, wantReplies=%d\n", dest, wantReplies);
             positionPlugin->sendOurPosition(dest, wantReplies);
         }
-    }
-    else {
-        if(nodeInfoPlugin) {
+    } else {
+        if (nodeInfoPlugin) {
             DEBUG_MSG("Sending nodeinfo ping to 0x%x, wantReplies=%d\n", dest, wantReplies);
             nodeInfoPlugin->sendOurNodeInfo(dest, wantReplies);
         }
@@ -198,10 +197,13 @@ NodeInfo *MeshService::refreshMyNodeInfo()
 
     Position &position = node->position;
 
-    // Update our local node info with our position (even if we don't decide to update anyone else)
-    position.time =
+    // Update our local node info with our time (even if we don't decide to update anyone else)
+    node->last_heard =
         getValidTime(RTCQualityFromNet); // This nodedb timestamp might be stale, so update it if our clock is kinda valid
 
+    // For the time in the position field, only set that if we have a real GPS clock
+    position.time = getValidTime(RTCQualityGPS);
+
     position.battery_level = powerStatus->getBatteryChargePercent();
     updateBatteryLevel(position.battery_level);
 

src/mesh/MeshService.h

@@ -84,13 +84,12 @@ class MeshService
     NodeInfo *refreshMyNodeInfo();
 
   private:
-
     /// Called when our gps position has changed - updates nodedb and sends Location message out into the mesh
     /// returns 0 to allow futher processing
     int onGPSChanged(const meshtastic::GPSStatus *arg);
 
-    /// 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
+    /// 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;
 };

src/mesh/MeshTypes.h

@@ -12,10 +12,8 @@ typedef uint32_t PacketId; // A packet sequence number
 #define NODENUM_BROADCAST UINT32_MAX
 #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_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.
@@ -35,7 +33,7 @@ typedef int ErrorCode;
 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
+ * 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

@@ -23,6 +23,8 @@
 
 #ifndef NO_ESP32
 #include "mesh/http/WiFiAPClient.h"
+#include "plugins/esp32/StoreForwardPlugin.h"
+#include <Preferences.h>
 #endif
 
 NodeDB nodeDB;
@@ -82,16 +84,17 @@ bool NodeDB::resetRadioConfig()
 
     radioGeneration++;
 
+    radioConfig.has_preferences = true;
     if (radioConfig.preferences.factory_reset) {
         DEBUG_MSG("Performing factory reset!\n");
         installDefaultDeviceState();
         didFactoryReset = true;
-    } else if (channelFile.channels_count == 0) {
+    }
+
+    if (channelFile.channels_count != MAX_NUM_CHANNELS) {
         DEBUG_MSG("Setting default channel and radio preferences!\n");
 
         channels.initDefaults();
-
-        radioConfig.has_preferences = true;
     }
 
     channels.onConfigChanged();
@@ -206,12 +209,13 @@ void NodeDB::init()
     // removed from 1.2 (though we do use old values if found)
     // We set these _after_ loading from disk - because they come from the build and are more trusted than
     // what is stored in flash
-    //if (xstr(HW_VERSION)[0])
+    // if (xstr(HW_VERSION)[0])
     //    strncpy(myNodeInfo.region, optstr(HW_VERSION), sizeof(myNodeInfo.region));
-    // else DEBUG_MSG("This build does not specify a HW_VERSION\n"); // Eventually new builds will no longer include this build flag
+    // else DEBUG_MSG("This build does not specify a HW_VERSION\n"); // Eventually new builds will no longer include this build
+    // flag
 
     // DEBUG_MSG("legacy region %d\n", devicestate.legacyRadio.preferences.region);
-    if(radioConfig.preferences.region == RegionCode_Unset)
+    if (radioConfig.preferences.region == RegionCode_Unset)
         radioConfig.preferences.region = devicestate.legacyRadio.preferences.region;
 
     // Check for the old style of region code strings, if found, convert to the new enum.
@@ -226,11 +230,20 @@ void NodeDB::init()
     }
 
     strncpy(myNodeInfo.firmware_version, optstr(APP_VERSION), sizeof(myNodeInfo.firmware_version));
-    
+
     // hw_model is no longer stored in myNodeInfo (as of 1.2.11) - we now store it as an enum in nodeinfo
     myNodeInfo.hw_model_deprecated[0] = '\0';
     // strncpy(myNodeInfo.hw_model, HW_VENDOR, sizeof(myNodeInfo.hw_model));
 
+#ifndef NO_ESP32
+    Preferences preferences;
+    preferences.begin("meshtastic", false);
+    myNodeInfo.reboot_count = preferences.getUInt("rebootCounter", 0);
+    preferences.end();
+    DEBUG_MSG("Number of Device Reboots: %d\n", myNodeInfo.reboot_count);
+
+#endif
+
     resetRadioConfig(); // If bogus settings got saved, then fix them
 
     DEBUG_MSG("region=%d, NODENUM=0x%x, dbsize=%d\n", radioConfig.preferences.region, myNodeInfo.my_node_num, *numNodes);
@@ -373,7 +386,7 @@ void NodeDB::saveChannelsToDisk()
         FS.mkdir("/prefs");
 #endif
         saveProto(channelfile, ChannelFile_size, sizeof(ChannelFile), ChannelFile_fields, &channelFile);
-    }  
+    }
 }
 
 void NodeDB::saveToDisk()
@@ -406,8 +419,7 @@ uint32_t sinceLastSeen(const NodeInfo *n)
 {
     uint32_t now = getTime();
 
-    uint32_t last_seen = n->position.time;
-    int delta = (int)(now - last_seen);
+    int delta = (int)(now - n->last_heard);
     if (delta < 0) // our clock must be slightly off still - not set from GPS yet
         delta = 0;
 
@@ -441,7 +453,7 @@ void NodeDB::updatePosition(uint32_t nodeId, const 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)
+    if (p.time)
         info->position.time = p.time;
     if (p.battery_level)
         info->position.battery_level = p.battery_level;
@@ -449,6 +461,8 @@ void NodeDB::updatePosition(uint32_t nodeId, const Position &p)
         info->position.latitude_i = p.latitude_i;
         info->position.longitude_i = p.longitude_i;
     }
+    if (p.altitude)
+        info->position.altitude = p.altitude;
     info->has_position = true;
     updateGUIforNode = info;
     notifyObservers(true); // Force an update whether or not our node counts have changed
@@ -484,17 +498,16 @@ void NodeDB::updateUser(uint32_t nodeId, const User &p)
 /// we updateGUI and updateGUIforNode if we think our this change is big enough for a redraw
 void NodeDB::updateFrom(const MeshPacket &mp)
 {
-    if (mp.which_payloadVariant == MeshPacket_decoded_tag) {
+    if (mp.which_payloadVariant == MeshPacket_decoded_tag && mp.from) {
         DEBUG_MSG("Update DB node 0x%x, rx_time=%u\n", mp.from, mp.rx_time);
 
         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
-            info->position.time = mp.rx_time;
-        }
+        if (mp.rx_time) // if the packet has a valid timestamp use it to update our last_heard
+            info->last_heard = mp.rx_time;
 
-        info->snr = mp.rx_snr; // keep the most recent SNR we received for this node.
+        if (mp.rx_snr)
+            info->snr = mp.rx_snr; // keep the most recent SNR we received for this node.
     }
 }
 

src/mesh/PhoneAPI.cpp

@@ -1,10 +1,10 @@
 #include "PhoneAPI.h"
+#include "Channels.h"
 #include "GPS.h"
 #include "MeshService.h"
 #include "NodeDB.h"
 #include "PowerFSM.h"
 #include "RadioInterface.h"
-#include "Channels.h"
 #include <assert.h>
 
 #if FromRadio_size > MAX_TO_FROM_RADIO_SIZE
@@ -15,33 +15,52 @@
 #error ToRadio is too big
 #endif
 
-PhoneAPI::PhoneAPI() {}
-
-void PhoneAPI::init()
+PhoneAPI::PhoneAPI()
 {
-    observe(&service.fromNumChanged);
+    lastContactMsec = millis();
 }
 
-PhoneAPI::~PhoneAPI() {
+PhoneAPI::~PhoneAPI()
+{
     close();
 }
 
-void PhoneAPI::close() {
-    unobserve();
-    state = STATE_SEND_NOTHING;
-    bool oldConnected = isConnected;
-    isConnected = false;
-    if(oldConnected != isConnected)
-        onConnectionChanged(isConnected);
+void PhoneAPI::handleStartConfig()
+{
+    if (!isConnected()) {
+        onConnectionChanged(true);
+        observe(&service.fromNumChanged);
+    }
+
+    // even if we were already connected - restart our state machine
+    state = STATE_SEND_MY_INFO;
+
+    DEBUG_MSG("Reset nodeinfo read pointer\n");
+    nodeInfoForPhone = NULL;   // Don't keep returning old nodeinfos
+    nodeDB.resetReadPointer(); // FIXME, this read pointer should be moved out of nodeDB and into this class - because
+                               // this will break once we have multiple instances of PhoneAPI running independently
+}
+
+void PhoneAPI::close()
+{
+    if (state != STATE_SEND_NOTHING) {
+        state = STATE_SEND_NOTHING;
+
+        unobserve();
+        releasePhonePacket(); // Don't leak phone packets on shutdown
+
+        onConnectionChanged(false);
+    }
 }
 
 void PhoneAPI::checkConnectionTimeout()
 {
-    if (isConnected) {
-        bool newConnected = (millis() - lastContactMsec < getPref_phone_timeout_secs() * 1000L);
-        if (!newConnected) {
-            isConnected = false;
-            onConnectionChanged(isConnected);
+    if (isConnected()) {
+        uint32_t now = millis();
+        bool newContact = (now - lastContactMsec) < getPref_phone_timeout_secs() * 1000UL;
+        if (!newContact) {
+            DEBUG_MSG("Timed out on phone contact, dropping phone connection\n");
+            close();
         }
     }
 }
@@ -49,34 +68,28 @@ void PhoneAPI::checkConnectionTimeout()
 /**
  * Handle a ToRadio protobuf
  */
-void PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
+bool PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
 {
     powerFSM.trigger(EVENT_CONTACT_FROM_PHONE); // As long as the phone keeps talking to us, don't let the radio go to sleep
     lastContactMsec = millis();
-    if (!isConnected) {
-        isConnected = true;
-        onConnectionChanged(isConnected);
-    }
+
     // 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: {
-            MeshPacket &p = toRadioScratch.packet;
-            printPacket("PACKET FROM PHONE", &p);
-            service.handleToRadio(p);
-            break;
-        }
+        case ToRadio_packet_tag:
+            return handleToRadioPacket(toRadioScratch.packet);
+
         case ToRadio_want_config_id_tag:
             config_nonce = toRadioScratch.want_config_id;
             DEBUG_MSG("Client wants config, nonce=%u\n", config_nonce);
-            state = STATE_SEND_MY_INFO;
 
-            DEBUG_MSG("Reset nodeinfo read pointer\n");
-            nodeInfoForPhone = NULL;   // Don't keep returning old nodeinfos
-            nodeDB.resetReadPointer(); // FIXME, this read pointer should be moved out of nodeDB and into this class - because
-                                       // this will break once we have multiple instances of PhoneAPI running independently
+            handleStartConfig();
+            break;
+
+        case ToRadio_disconnect_tag:
+            close();
             break;
 
         default:
@@ -86,6 +99,8 @@ void PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
     } else {
         DEBUG_MSG("Error: ignoring malformed toradio\n");
     }
+
+    return false;
 }
 
 /**
@@ -120,14 +135,12 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
     case STATE_SEND_MY_INFO:
         // If the user has specified they don't want our node to share its location, make sure to tell the phone
         // app not to send locations on our behalf.
-        myNodeInfo.has_gps = (radioConfig.preferences.location_share == LocationSharing_LocDisabled)
-                                 ? true
-                                 : (gps && gps->isConnected()); // Update with latest GPS connect info
+        myNodeInfo.has_gps = gps && gps->isConnected(); // Update with latest GPS connect info
         fromRadioScratch.which_payloadVariant = FromRadio_my_info_tag;
         fromRadioScratch.my_info = myNodeInfo;
         state = STATE_SEND_NODEINFO;
 
-        service.refreshMyNodeInfo();  // Update my NodeInfo because the client will be asking for it soon.
+        service.refreshMyNodeInfo(); // Update my NodeInfo because the client will be asking for it soon.
         break;
 
     case STATE_SEND_NODEINFO: {
@@ -135,7 +148,7 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
         nodeInfoForPhone = NULL; // We just consumed a nodeinfo, will need a new one next time
 
         if (info) {
-            DEBUG_MSG("Sending nodeinfo: num=0x%x, lastseen=%u, id=%s, name=%s\n", info->num, info->position.time, info->user.id,
+            DEBUG_MSG("Sending nodeinfo: num=0x%x, lastseen=%u, id=%s, name=%s\n", info->num, info->last_heard, info->user.id,
                       info->user.long_name);
             fromRadioScratch.which_payloadVariant = FromRadio_node_info_tag;
             fromRadioScratch.node_info = *info;
@@ -159,16 +172,13 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
     case STATE_SEND_PACKETS:
         // Do we have a message from the mesh?
         if (packetForPhone) {
-
             printPacket("phone downloaded packet", packetForPhone);
 
             // Encapsulate as a FromRadio packet
             fromRadioScratch.which_payloadVariant = FromRadio_packet_tag;
             fromRadioScratch.packet = *packetForPhone;
-
-            service.releaseToPool(packetForPhone); // we just copied the bytes, so don't need this buffer anymore
-            packetForPhone = NULL;
         }
+        releasePhonePacket();
         break;
 
     default:
@@ -187,6 +197,16 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
     return 0;
 }
 
+void PhoneAPI::handleDisconnect() {}
+
+void PhoneAPI::releasePhonePacket()
+{
+    if (packetForPhone) {
+        service.releaseToPool(packetForPhone); // we just copied the bytes, so don't need this buffer anymore
+        packetForPhone = NULL;
+    }
+}
+
 /**
  * Return true if we have data available to send to the phone
  */
@@ -226,7 +246,13 @@ bool PhoneAPI::available()
 /**
  * Handle a packet that the phone wants us to send.  It is our responsibility to free the packet to the pool
  */
-void PhoneAPI::handleToRadioPacket(MeshPacket *p) {}
+bool PhoneAPI::handleToRadioPacket(MeshPacket &p)
+{
+    printPacket("PACKET FROM PHONE", &p);
+    service.handleToRadio(p);
+
+    return true;
+}
 
 /// If the mesh service tells us fromNum has changed, tell the phone
 int PhoneAPI::onNotify(uint32_t newValue)

src/mesh/PhoneAPI.h

@@ -22,6 +22,7 @@ class PhoneAPI
     enum State {
         STATE_UNUSED,       // (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
+                            // (disconnected)
         STATE_SEND_MY_INFO, // send our my info record
         // 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
@@ -58,17 +59,15 @@ class PhoneAPI
     /// Destructor - calls close()
     virtual ~PhoneAPI();
 
-    /// Do late init that can't happen at constructor time
-    virtual void init();
-
     // Call this when the client drops the connection, resets the state to STATE_SEND_NOTHING
     // Unregisters our observer.  A closed connection **can** be reopened by calling init again.
     virtual void close();
 
     /**
      * Handle a ToRadio protobuf
+     * @return true true if a packet was queued for sending (so that caller can yield)
      */
-    virtual void handleToRadio(const uint8_t *buf, size_t len);
+    virtual bool handleToRadio(const uint8_t *buf, size_t len);
 
     /**
      * Get the next packet we want to send to the phone
@@ -83,17 +82,16 @@ class PhoneAPI
      */
     bool available();
 
-  protected:
-    /// Are we currently connected to a client?
-    bool isConnected = false;
+    bool isConnected() { return state != STATE_SEND_NOTHING; }
 
+  protected:
     /// Our fromradio packet while it is being assembled
     FromRadio fromRadioScratch;
 
     /// Hookable to find out when connection changes
     virtual void onConnectionChanged(bool connected) {}
 
-  /// If we haven't heard from the other side in a while then say not connected
+    /// If we haven't heard from the other side in a while then say not connected
     void checkConnectionTimeout();
 
     /**
@@ -101,11 +99,22 @@ class PhoneAPI
      */
     virtual void onNowHasData(uint32_t fromRadioNum) {}
 
-  private:
     /**
-     * Handle a packet that the phone wants us to send.  It is our responsibility to free the packet to the pool
+     * Subclasses can use this to find out when a client drops the link
      */
-    void handleToRadioPacket(MeshPacket *p);
+    virtual void handleDisconnect();
+
+  private:
+    void releasePhonePacket();
+
+    /// begin a new connection
+    void handleStartConfig();
+
+    /**
+     * Handle a packet that the phone wants us to send.  We can write to it but can not keep a reference to it
+     * @return true true if a packet was queued for sending
+     */
+    bool handleToRadioPacket(MeshPacket &p);
 
     /// If the mesh service tells us fromNum has changed, tell the phone
     virtual int onNotify(uint32_t newValue);

src/mesh/ProtobufPlugin.h

@@ -22,10 +22,9 @@ template <class T> class ProtobufPlugin : protected SinglePortPlugin
     }
 
   protected:
-
     /**
      * 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.
      */
@@ -58,11 +57,12 @@ template <class T> class ProtobufPlugin : protected SinglePortPlugin
         // it would be better to update even if the message was destined to others.
 
         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);
+        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;
-        T *decoded = NULL; 
-        if(mp.decoded.portnum == ourPortNum) {
+        T *decoded = NULL;
+        if (mp.which_payloadVariant == MeshPacket_decoded_tag && mp.decoded.portnum == ourPortNum) {
             memset(&scratch, 0, sizeof(scratch));
             if (pb_decode_from_bytes(p.payload.bytes, p.payload.size, fields, &scratch))
                 decoded = &scratch;

src/mesh/RF95Interface.cpp

@@ -36,8 +36,6 @@ bool RF95Interface::init()
 {
     RadioLibInterface::init();
 
-    applyModemConfig();
-
     if (power == 0)
         power = POWER_DEFAULT;
 
@@ -86,24 +84,25 @@ void INTERRUPT_ATTR RF95Interface::disableInterrupt()
     lora->clearDio0Action();
 }
 
-
-
 bool RF95Interface::reconfigure()
 {
-    applyModemConfig();
+    RadioLibInterface::reconfigure();
 
     // set mode to standby
     setStandby();
 
     // configure publicly accessible settings
     int err = lora->setSpreadingFactor(sf);
-    if(err != ERR_NONE) recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
+    if (err != ERR_NONE)
+        recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
 
     err = lora->setBandwidth(bw);
-    if(err != ERR_NONE) recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
+    if (err != ERR_NONE)
+        recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
 
     err = lora->setCodingRate(cr);
-    if(err != ERR_NONE) recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
+    if (err != ERR_NONE)
+        recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
 
     err = lora->setSyncWord(syncWord);
     assert(err == ERR_NONE);
@@ -115,12 +114,14 @@ bool RF95Interface::reconfigure()
     assert(err == ERR_NONE);
 
     err = lora->setFrequency(freq);
-    if(err != ERR_NONE) recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
+    if (err != ERR_NONE)
+        recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
 
     if (power > MAX_POWER) // This chip has lower power limits than some
         power = MAX_POWER;
     err = lora->setOutputPower(power);
-    if(err != ERR_NONE) recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
+    if (err != ERR_NONE)
+        recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
 
     startReceive(); // restart receiving
 

src/mesh/RadioInterface.cpp

@@ -1,12 +1,12 @@
 
-#include "configuration.h"
 #include "RadioInterface.h"
 #include "Channels.h"
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
-#include "assert.h"
 #include "Router.h"
+#include "assert.h"
+#include "configuration.h"
 #include "sleep.h"
 #include <assert.h>
 #include <pb_decode.h>
@@ -31,8 +31,8 @@ const RegionInfo regions[] = {
 
 /* Notes about the RU bandplan (from @denis-d in https://meshtastic.discourse.group/t/russian-band-plan-proposal/2786/2):
 
-According to Annex 12 to GKRCh (National Radio Frequency Commission) decision № 18-46-03-1 (September 11th 2018) https://digital.gov.ru/uploaded/files/prilozhenie-12-k-reshenyu-gkrch-18-46-03-1.pdf 1
-We have 3 options for 868 MHz:
+According to Annex 12 to GKRCh (National Radio Frequency Commission) decision № 18-46-03-1 (September 11th 2018)
+https://digital.gov.ru/uploaded/files/prilozhenie-12-k-reshenyu-gkrch-18-46-03-1.pdf 1 We have 3 options for 868 MHz:
 
 864,0 - 865,0 MHz ERP 25mW, Duty Cycle 0.1% (3.6 sec in hour) or LBT (Listen Before Talk), prohibited in airports.
 866,0 - 868,0 MHz ERP 25mW, Duty Cycle 1% or LBT, PSD (Power Spectrum Density) 1000mW/MHz, prohibited in airports
@@ -112,6 +112,8 @@ uint32_t RadioInterface::getPacketTime(MeshPacket *p)
 /** The delay to use for retransmitting dropped packets */
 uint32_t RadioInterface::getRetransmissionMsec(const MeshPacket *p)
 {
+    assert(shortPacketMsec); // Better be non zero
+
     // was 20 and 22 secs respectively, but now with shortPacketMsec as 2269, this should give the same range
     return random(9 * shortPacketMsec, 10 * shortPacketMsec);
 }
@@ -153,7 +155,7 @@ void printPacket(const char *prefix, const MeshPacket *p)
         if (s.dest != 0)
             DEBUG_MSG(" dest=%08x", s.dest);
 
-        if(s.request_id)
+        if (s.request_id)
             DEBUG_MSG(" requestId=%0x", s.request_id);
 
         /* now inside Data and therefore kinda opaque
@@ -185,6 +187,12 @@ RadioInterface::RadioInterface()
     // DEBUG_MSG("Set meshradio defaults name=%s\n", channelSettings.name);
 }
 
+bool RadioInterface::reconfigure()
+{
+    applyModemConfig();
+    return true;
+}
+
 bool RadioInterface::init()
 {
     DEBUG_MSG("Starting meshradio init...\n");
@@ -197,6 +205,8 @@ bool RadioInterface::init()
     // radioIf.setThisAddress(nodeDB.getNodeNum()); // Note: we must do this here, because the nodenum isn't inited at constructor
     // time.
 
+    applyModemConfig();
+
     return true;
 }
 
@@ -309,7 +319,7 @@ void RadioInterface::applyModemConfig()
     // If user has manually specified a channel num, then use that, otherwise generate one by hashing the name
     const char *channelName = channels.getName(channels.getPrimaryIndex());
     int channel_num = channelSettings.channel_num ? channelSettings.channel_num - 1 : hash(channelName) % myRegion->numChannels;
-    freq = myRegion->freq + myRegion->spacing * channel_num;
+    freq = myRegion->freq + radioConfig.preferences.frequency_offset + 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("Radio myRegion->freq: %f\n", myRegion->freq);
@@ -351,12 +361,8 @@ ErrorCode SimRadio::send(MeshPacket *p)
 
 void RadioInterface::deliverToReceiver(MeshPacket *p)
 {
-    assert(rxDest);
-    assert(rxDest->enqueue(p, 0)); // NOWAIT - fixme, if queue is full, delete older messages
-
-    // Nasty hack because our threading is primitive.  interfaces shouldn't need to know about routers FIXME
     if (router)
-        router->setReceivedMessage();
+        router->enqueueReceivedMessage(p);
 }
 
 /***

src/mesh/RadioInterface.h

@@ -42,7 +42,6 @@ typedef struct {
 class RadioInterface
 {
     friend class MeshRadio; // for debugging we let that class touch pool
-    PointerQueue<MeshPacket> *rxDest = NULL;
 
     CallbackObserver<RadioInterface, void *> configChangedObserver =
         CallbackObserver<RadioInterface, void *>(this, &RadioInterface::reloadConfig);
@@ -82,17 +81,11 @@ class RadioInterface
     float freq = 915.0;
 
     /** pool is the pool we will alloc our rx packets from
-     * rxDest is where we will send any rx packets, it becomes receivers responsibility to return packet to the pool
      */
     RadioInterface();
 
     virtual ~RadioInterface() {}
 
-    /**
-     * Set where to deliver received packets.  This method should only be used by the Router class
-     */
-    void setReceiver(PointerQueue<MeshPacket> *_rxDest) { rxDest = _rxDest; }
-
     /**
      * Return true if we think the board can go to sleep (i.e. our tx queue is empty, we are not sending or receiving)
      *
@@ -104,7 +97,11 @@ class RadioInterface
     virtual bool sleep() { return true; }
 
     /// Disable this interface (while disabled, no packets can be sent or received)
-    void disable() { disabled = true; sleep(); }
+    void disable()
+    {
+        disabled = true;
+        sleep();
+    }
 
     /**
      * Send a packet (possibly by enquing in a private fifo).  This routine will
@@ -126,7 +123,7 @@ class RadioInterface
     /// Apply any radio provisioning changes
     /// Make sure the Driver is properly configured before calling init().
     /// \return true if initialisation succeeded.
-    virtual bool reconfigure() = 0;
+    virtual bool reconfigure();
 
     /** The delay to use for retransmitting dropped packets */
     uint32_t getRetransmissionMsec(const MeshPacket *p);
@@ -174,13 +171,6 @@ class RadioInterface
      */
     void limitPower();
 
-    /**
-     * Convert our modemConfig enum into wf, sf, etc...
-     *
-     * These paramaters will be pull from the channelSettings global
-     */
-    virtual void applyModemConfig();
-
     /**
      * Save the frequency we selected for later reuse.
      */
@@ -192,6 +182,13 @@ class RadioInterface
     virtual void saveChannelNum(uint32_t savedChannelNum);
 
   private:
+    /**
+     * Convert our modemConfig enum into wf, sf, etc...
+     *
+     * These paramaters will be pull from the channelSettings global
+     */
+    void applyModemConfig();
+
     /// Return 0 if sleep is okay
     int preflightSleepCb(void *unused = NULL) { return canSleep() ? 0 : 1; }
 
@@ -208,18 +205,6 @@ class SimRadio : public RadioInterface
 {
   public:
     virtual ErrorCode send(MeshPacket *p);
-
-    // methods from radiohead
-
-    /// Initialise the Driver transport hardware and software.
-    /// Make sure the Driver is properly configured before calling init().
-    /// \return true if initialisation succeeded.
-    virtual bool init() { return true; }
-
-    /// Apply any radio provisioning changes
-    /// Make sure the Driver is properly configured before calling init().
-    /// \return true if initialisation succeeded.
-    virtual bool reconfigure() { return true; }
 };
 
 /// Debug printing for packets

src/mesh/ReliableRouter.h

@@ -79,9 +79,10 @@ class ReliableRouter : public FloodingRouter
     /** Do our retransmission handling */
     virtual int32_t runOnce()
     {
-        auto d = FloodingRouter::runOnce();
+        // Note: We must doRetransmissions FIRST, because it might queue up work for the base class runOnce implementation
+        auto d = doRetransmissions();
 
-        int32_t r = doRetransmissions();
+        int32_t r = FloodingRouter::runOnce();
 
         return min(d, r);
     }
@@ -109,7 +110,6 @@ class ReliableRouter : public FloodingRouter
     PendingPacket *startRetransmission(MeshPacket *p);
 
   private:
-
     /**
      * Stop any retransmissions we are doing of the specified node/packet ID pair
      *

src/mesh/Router.cpp

@@ -4,9 +4,14 @@
 #include "NodeDB.h"
 #include "RTC.h"
 #include "configuration.h"
+#include "main.h"
 #include "mesh-pb-constants.h"
 #include "plugins/RoutingPlugin.h"
 
+#if defined(HAS_WIFI) || defined(PORTDUINO)
+#include "mqtt/MQTT.h"
+#endif
+
 /**
  * Router todo
  *
@@ -55,12 +60,30 @@ int32_t Router::runOnce()
 {
     MeshPacket *mp;
     while ((mp = fromRadioQueue.dequeuePtr(0)) != NULL) {
+        // printPacket("handle fromRadioQ", mp);
         perhapsHandleReceived(mp);
     }
 
+    // DEBUG_MSG("sleeping forever!\n");
     return INT32_MAX; // Wait a long time - until we get woken for the message queue
 }
 
+/**
+ * RadioInterface calls this to queue up packets that have been received from the radio.  The router is now responsible for
+ * freeing the packet
+ */
+void Router::enqueueReceivedMessage(MeshPacket *p)
+{
+    if (fromRadioQueue.enqueue(p, 0)) { // NOWAIT - fixme, if queue is full, delete older messages
+
+        // Nasty hack because our threading is primitive.  interfaces shouldn't need to know about routers FIXME
+        setReceivedMessage();
+    } else {
+        printPacket("BUG! fromRadioQueue is full! Discarding!", p);
+        packetPool.release(p);
+    }
+}
+
 /// Generate a unique packet id
 // FIXME, move this someplace better
 PacketId generatePacketId()
@@ -115,17 +138,19 @@ void Router::abortSendAndNak(Routing_Error err, MeshPacket *p)
     packetPool.release(p);
 }
 
-void Router::setReceivedMessage() {
+void Router::setReceivedMessage()
+{
+    // DEBUG_MSG("set interval to ASAP\n");
     setInterval(0); // Run ASAP, so we can figure out our correct sleep time
+    runASAP = true;
 }
 
 ErrorCode Router::sendLocal(MeshPacket *p)
 {
     // No need to deliver externally if the destination is the local node
     if (p->to == nodeDB.getNodeNum()) {
-        printPacket("Enqueuing local", p);
-        fromRadioQueue.enqueue(p);
-        setReceivedMessage();
+        printPacket("Enqueued local", p);
+        enqueueReceivedMessage(p);
         return ERRNO_OK;
     } else if (!iface) {
         // We must be sending to remote nodes also, fail if no interface found
@@ -143,9 +168,10 @@ ErrorCode Router::sendLocal(MeshPacket *p)
     }
 }
 
-void printBytes(const char *label, const uint8_t *p, size_t numbytes) {
+void printBytes(const char *label, const uint8_t *p, size_t numbytes)
+{
     DEBUG_MSG("%s: ", label);
-    for(size_t i = 0; i < numbytes; i++)
+    for (size_t i = 0; i < numbytes; i++)
         DEBUG_MSG("%02x ", p[i]);
     DEBUG_MSG("\n");
 }
@@ -176,36 +202,20 @@ ErrorCode Router::send(MeshPacket *p)
     assert(p->which_payloadVariant == MeshPacket_encrypted_tag ||
            p->which_payloadVariant == MeshPacket_decoded_tag); // I _think_ all packets should have a payload by now
 
-    // First convert from protobufs to raw bytes
+    // If the packet is not yet encrypted, do so now
     if (p->which_payloadVariant == MeshPacket_decoded_tag) {
-        static uint8_t bytes[MAX_RHPACKETLEN]; // we have to use a scratch buffer because a union
+        ChannelIndex chIndex = p->channel; // keep as a local because we are about to change it
 
-        // printPacket("pre encrypt", p); // portnum valid here
-
-        size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), Data_fields, &p->decoded);
-
-        if (numbytes > MAX_RHPACKETLEN) {
-            abortSendAndNak(Routing_Error_TOO_LARGE, p);
-            return ERRNO_TOO_LARGE;
+        auto encodeResult = perhapsEncode(p);
+        if (encodeResult != Routing_Error_NONE) {
+            abortSendAndNak(encodeResult, p);
+            return encodeResult; // FIXME - this isn't a valid ErrorCode
         }
 
-        //printBytes("plaintext", bytes, numbytes);
-
-        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(getFrom(p), p->id, numbytes, bytes);
-
-        // Copy back into the packet and set the variant type
-        memcpy(p->encrypted.bytes, bytes, numbytes);
-        p->encrypted.size = numbytes;
-        p->which_payloadVariant = MeshPacket_encrypted_tag;
+#if defined(HAS_WIFI) || defined(PORTDUINO)
+        if (mqtt)
+            mqtt->onSend(*p, chIndex);
+#endif
     }
 
     assert(iface); // This should have been detected already in sendLocal (or we just received a packet from outside)
@@ -228,7 +238,7 @@ void Router::sniffReceived(const MeshPacket *p, const Routing *c)
     // FIXME, update nodedb here for any packet that passes through us
 }
 
-bool Router::perhapsDecode(MeshPacket *p)
+bool perhapsDecode(MeshPacket *p)
 {
     if (p->which_payloadVariant == MeshPacket_decoded_tag)
         return true; // If packet was already decoded just return
@@ -247,19 +257,18 @@ bool Router::perhapsDecode(MeshPacket *p)
                    rawSize); // we have to copy into a scratch buffer, because these bytes are a union with the decoded protobuf
             crypto->decrypt(p->from, p->id, rawSize, bytes);
 
-            //printBytes("plaintext", bytes, p->encrypted.size);            
+            // printBytes("plaintext", bytes, p->encrypted.size);
 
             // Take those raw bytes and convert them back into a well structured protobuf we can understand
-            memset(&p->decoded, 0, sizeof(p->decoded)); 
+            memset(&p->decoded, 0, sizeof(p->decoded));
             if (!pb_decode_from_bytes(bytes, rawSize, Data_fields, &p->decoded)) {
                 DEBUG_MSG("Invalid protobufs in received mesh packet (bad psk?)!\n");
-            } else if(p->decoded.portnum == PortNum_UNKNOWN_APP) {
+            } else if (p->decoded.portnum == PortNum_UNKNOWN_APP) {
                 DEBUG_MSG("Invalid portnum (bad psk?)!\n");
-            }
-            else {
+            } else {
                 // parsing was successful
                 p->which_payloadVariant = MeshPacket_decoded_tag; // change type to decoded
-                p->channel = chIndex; // change to store the index instead of the hash
+                p->channel = chIndex;                             // change to store the index instead of the hash
                 printPacket("decoded message", p);
                 return true;
             }
@@ -270,6 +279,42 @@ bool Router::perhapsDecode(MeshPacket *p)
     return false;
 }
 
+/** Return 0 for success or a Routing_Errror code for failure
+ */
+Routing_Error perhapsEncode(MeshPacket *p)
+{
+    // If the packet is not yet encrypted, do so now
+    if (p->which_payloadVariant == MeshPacket_decoded_tag) {
+        static uint8_t bytes[MAX_RHPACKETLEN]; // we have to use a scratch buffer because a union
+
+        // printPacket("pre encrypt", p); // portnum valid here
+
+        size_t numbytes = pb_encode_to_bytes(bytes, sizeof(bytes), Data_fields, &p->decoded);
+
+        if (numbytes > MAX_RHPACKETLEN)
+            return Routing_Error_TOO_LARGE;
+
+        // printBytes("plaintext", bytes, numbytes);
+
+        ChannelIndex chIndex = p->channel; // keep as a local because we are about to change it
+        auto hash = channels.setActiveByIndex(chIndex);
+        if (hash < 0)
+            // No suitable channel could be found for sending
+            return Routing_Error_NO_CHANNEL;
+
+        // Now that we are encrypting the packet channel should be the hash (no longer the index)
+        p->channel = hash;
+        crypto->encrypt(getFrom(p), p->id, numbytes, bytes);
+
+        // Copy back into the packet and set the variant type
+        memcpy(p->encrypted.bytes, bytes, numbytes);
+        p->encrypted.size = numbytes;
+        p->which_payloadVariant = MeshPacket_encrypted_tag;
+    }
+
+    return Routing_Error_NONE;
+}
+
 NodeNum Router::getNodeNum()
 {
     return nodeDB.getNodeNum();
@@ -285,26 +330,27 @@ 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
-    bool decoded = perhapsDecode(p); 
+    bool decoded = perhapsDecode(p);
     if (decoded) {
         // parsing was successful, queue for our recipient
         printPacket("handleReceived", p);
-
-        // call any promiscious plugins here, make a (non promisiocous) plugin for forwarding messages to phone api
-        // sniffReceived(p);
-        MeshPlugin::callPlugins(*p);
+    } else {
+        printPacket("packet decoding failed (no PSK?)", p);
     }
+
+    // call plugins here
+    MeshPlugin::callPlugins(*p);
 }
 
 void Router::perhapsHandleReceived(MeshPacket *p)
 {
     assert(radioConfig.has_preferences);
-    bool ignore = is_in_repeated(radioConfig.preferences.ignore_incoming, getFrom(p));
+    bool ignore = is_in_repeated(radioConfig.preferences.ignore_incoming, p->from);
 
     if (ignore)
         DEBUG_MSG("Ignoring incoming message, 0x%x is in our ignore list\n", p->from);
     else if (ignore |= shouldFilterReceived(p)) {
-        // DEBUG_MSG("Incoming message was filtered 0x%x\n", p->from);
+        DEBUG_MSG("Incoming message was filtered 0x%x\n", p->from);
     }
 
     // Note: we avoid calling shouldFilterReceived if we are supposed to ignore certain nodes - because some overrides might

src/mesh/Router.h

@@ -1,12 +1,12 @@
 #pragma once
 
+#include "Channels.h"
 #include "MemoryPool.h"
 #include "MeshTypes.h"
 #include "Observer.h"
 #include "PointerQueue.h"
 #include "RadioInterface.h"
 #include "concurrency/OSThread.h"
-#include "Channels.h"
 
 /**
  * A mesh aware router that supports multiple interfaces.
@@ -22,7 +22,6 @@ class Router : protected concurrency::OSThread
     RadioInterface *iface = NULL;
 
   public:
-
     /**
      * Constructor
      *
@@ -32,11 +31,7 @@ class Router : protected concurrency::OSThread
     /**
      * Currently we only allow one interface, that may change in the future
      */
-    void addInterface(RadioInterface *_iface)
-    {
-        iface = _iface;
-        iface->setReceiver(&fromRadioQueue);
-    }
+    void addInterface(RadioInterface *_iface) { iface = _iface; }
 
     /**
      * do idle processing
@@ -53,7 +48,7 @@ class Router : protected concurrency::OSThread
     ErrorCode sendLocal(MeshPacket *p);
 
     /** Attempt to cancel a previously sent packet.  Returns true if a packet was found we could cancel */
-    bool cancelSending(NodeNum from, PacketId id);    
+    bool cancelSending(NodeNum from, PacketId id);
 
     /** Allocate and return a meshpacket which defaults as send to broadcast from the current node.
      * The returned packet is guaranteed to have a unique packet ID already assigned
@@ -69,6 +64,12 @@ class Router : protected concurrency::OSThread
      */
     void setReceivedMessage();
 
+    /**
+     * RadioInterface calls this to queue up packets that have been received from the radio.  The router is now responsible for
+     * freeing the packet
+     */
+    void enqueueReceivedMessage(MeshPacket *p);
+
   protected:
     friend class RoutingPlugin;
 
@@ -83,7 +84,7 @@ 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.
@@ -97,18 +98,11 @@ class Router : protected concurrency::OSThread
      */
     virtual void sniffReceived(const MeshPacket *p, const Routing *c);
 
-    /**
-     * Remove any encryption and decode the protobufs inside this packet (if necessary).
-     *
-     * @return true for success, false for corrupt packet.
-     */
-    bool perhapsDecode(MeshPacket *p);
-
     /**
      * Send an ack or a nak packet back towards whoever sent idFrom
      */
     void sendAckNak(Routing_Error err, NodeNum to, PacketId idFrom, ChannelIndex chIndex);
-    
+
   private:
     /**
      * Called from loop()
@@ -134,6 +128,17 @@ class Router : protected concurrency::OSThread
     void abortSendAndNak(Routing_Error err, MeshPacket *p);
 };
 
+/** FIXME - move this into a mesh packet class
+ * Remove any encryption and decode the protobufs inside this packet (if necessary).
+ *
+ * @return true for success, false for corrupt packet.
+ */
+bool perhapsDecode(MeshPacket *p);
+
+/** Return 0 for success or a Routing_Errror code for failure
+ */
+Routing_Error perhapsEncode(MeshPacket *p);
+
 extern Router *router;
 
 /// Generate a unique packet id

src/mesh/SX1262Interface.cpp

@@ -23,8 +23,6 @@ bool SX1262Interface::init()
     pinMode(SX1262_POWER_EN, OUTPUT);
 #endif
 
-    RadioLibInterface::init();
-
 #ifdef SX1262_RXEN                  // set not rx or tx mode
     digitalWrite(SX1262_RXEN, LOW); // Set low before becoming an output
     pinMode(SX1262_RXEN, OUTPUT);
@@ -37,12 +35,12 @@ bool SX1262Interface::init()
 #ifndef SX1262_E22
     float tcxoVoltage = 0; // None - we use an XTAL
 #else
-    float tcxoVoltage =
-        1.8; // E22 uses DIO3 to power tcxo per https://github.com/jgromes/RadioLib/issues/12#issuecomment-520695575
+    // Use DIO3 to power tcxo per https://github.com/jgromes/RadioLib/issues/12#issuecomment-520695575
+    float tcxoVoltage = 1.8;
 #endif
     bool useRegulatorLDO = false; // Seems to depend on the connection to pin 9/DCC_SW - if an inductor DCDC?
 
-    applyModemConfig();
+    RadioLibInterface::init();
 
     if (power == 0)
         power = SX1262_MAX_POWER;
@@ -72,20 +70,23 @@ bool SX1262Interface::init()
 
 bool SX1262Interface::reconfigure()
 {
-    applyModemConfig();
+    RadioLibInterface::reconfigure();
 
     // set mode to standby
     setStandby();
 
     // configure publicly accessible settings
     int err = lora.setSpreadingFactor(sf);
-    if(err != ERR_NONE) recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
+    if (err != ERR_NONE)
+        recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
 
     err = lora.setBandwidth(bw);
-    if(err != ERR_NONE) recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
+    if (err != ERR_NONE)
+        recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
 
     err = lora.setCodingRate(cr);
-    if(err != ERR_NONE) recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
+    if (err != ERR_NONE)
+        recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
 
     // Hmm - seems to lower SNR when the signal levels are high.  Leaving off for now...
     err = lora.setRxGain(true);
@@ -101,7 +102,8 @@ bool SX1262Interface::reconfigure()
     assert(err == ERR_NONE);
 
     err = lora.setFrequency(freq);
-    if(err != ERR_NONE) recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
+    if (err != ERR_NONE)
+        recordCriticalError(CriticalErrorCode_InvalidRadioSetting);
 
     if (power > 22) // This chip has lower power limits than some
         power = 22;
@@ -142,6 +144,7 @@ void SX1262Interface::addReceiveMetadata(MeshPacket *mp)
 {
     // DEBUG_MSG("PacketStatus %x\n", lora.getPacketStatus());
     mp->rx_snr = lora.getSNR();
+    mp->rx_rssi = lround(lora.getRSSI());
 }
 
 /** We override to turn on transmitter power as needed.

src/mesh/StreamAPI.cpp

@@ -5,48 +5,62 @@
 #define START2 0xc3
 #define HEADER_LEN 4
 
-void StreamAPI::loop()
+int32_t StreamAPI::runOnce()
 {
+    auto result = readStream();
     writeStream();
-    readStream();
     checkConnectionTimeout();
+    return result;
 }
 
 /**
  * Read any rx chars from the link and call handleToRadio
  */
-void StreamAPI::readStream()
+int32_t StreamAPI::readStream()
 {
-    while (stream->available()) { // Currently we never want to block
-        uint8_t c = stream->read();
+    uint32_t now = millis();
+    if (!stream->available()) {
+        // Nothing available this time, if the computer has talked to us recently, poll often, otherwise let CPU sleep a long time
+        bool recentRx = (now - lastRxMsec) < 2000;
+        return recentRx ? 5 : 250;
+    } else {
+        while (stream->available()) { // Currently we never want to block
+            uint8_t c = stream->read();
 
-        // Use the read pointer for a little state machine, first look for framing, then length bytes, then payload
-        size_t ptr = rxPtr++; // assume we will probably advance the rxPtr
+            // Use the read pointer for a little state machine, first look for framing, then length bytes, then payload
+            size_t ptr = rxPtr++; // assume we will probably advance the rxPtr
 
-        rxBuf[ptr] = c; // store all bytes (including framing)
+            rxBuf[ptr] = c; // store all bytes (including framing)
 
-        if (ptr == 0) { // looking for START1
-            if (c != START1)
-                rxPtr = 0;     // failed to find framing
-        } else if (ptr == 1) { // looking for START2
-            if (c != START2)
-                rxPtr = 0;                             // failed to find framing
-        } else if (ptr >= HEADER_LEN) {                // we have at least read our 4 byte framing
-            uint32_t len = (rxBuf[2] << 8) + rxBuf[3]; // big endian 16 bit length follows framing
+            if (ptr == 0) { // looking for START1
+                if (c != START1)
+                    rxPtr = 0;     // failed to find framing
+            } else if (ptr == 1) { // looking for START2
+                if (c != START2)
+                    rxPtr = 0;                             // failed to find framing
+            } else if (ptr >= HEADER_LEN) {                // we have at least read our 4 byte framing
+                uint32_t len = (rxBuf[2] << 8) + rxBuf[3]; // big endian 16 bit length follows framing
 
-            if (ptr == HEADER_LEN) {
-                // we _just_ finished our 4 byte header, validate length now (note: a length of zero is a valid
-                // protobuf also)
-                if (len > MAX_TO_FROM_RADIO_SIZE)
-                    rxPtr = 0; // length is bogus, restart search for framing
-            }
+                if (ptr == HEADER_LEN) {
+                    // we _just_ finished our 4 byte header, validate length now (note: a length of zero is a valid
+                    // protobuf also)
+                    if (len > MAX_TO_FROM_RADIO_SIZE)
+                        rxPtr = 0; // length is bogus, restart search for framing
+                }
 
-            if (rxPtr != 0 && ptr + 1 == len + HEADER_LEN) {
-                // If we didn't just fail the packet and we now have the right # of bytes, parse it
-                handleToRadio(rxBuf + HEADER_LEN, len);
-                rxPtr = 0; // start over again
+                if (rxPtr != 0 && ptr + 1 == len + HEADER_LEN) {
+                    rxPtr = 0; // start over again on the next packet
+
+                    // If we didn't just fail the packet and we now have the right # of bytes, parse it
+                    if (handleToRadio(rxBuf + HEADER_LEN, len))
+                        return 0; // we want to be called again ASAP because we still have more work to do
+                }
             }
         }
+
+        // we had packets available this time, so assume we might have them next time also
+        lastRxMsec = now;
+        return 0;
     }
 }
 
@@ -71,7 +85,7 @@ void StreamAPI::writeStream()
 void StreamAPI::emitTxBuffer(size_t len)
 {
     if (len != 0) {
-        DEBUG_MSG("emit tx %d\n", len);
+        // DEBUG_MSG("emit tx %d\n", len);
         txBuf[0] = START1;
         txBuf[1] = START2;
         txBuf[2] = (len >> 8) & 0xff;
@@ -93,6 +107,6 @@ void StreamAPI::emitRebooted()
     fromRadioScratch.which_payloadVariant = FromRadio_rebooted_tag;
     fromRadioScratch.rebooted = true;
 
-    DEBUG_MSG("Emitting reboot packet for serial shell\n");
+    // DEBUG_MSG("Emitting reboot packet for serial shell\n");
     emitTxBuffer(pb_encode_to_bytes(txBuf + HEADER_LEN, FromRadio_size, FromRadio_fields, &fromRadioScratch));
 }

src/mesh/StreamAPI.h

@@ -2,6 +2,7 @@
 
 #include "PhoneAPI.h"
 #include "Stream.h"
+#include "concurrency/OSThread.h"
 
 // A To/FromRadio packet + our 32 bit header
 #define MAX_STREAM_BUF_SIZE (MAX_TO_FROM_RADIO_SIZE + sizeof(uint32_t))
@@ -27,7 +28,7 @@ valid utf8 encoding. This makes it a bit easier to start a device outputting reg
 after it has received a valid packet from the PC, turn off unencoded debug printing and switch to this packet encoding.
 
  */
-class StreamAPI : public PhoneAPI
+class StreamAPI : public PhoneAPI, protected concurrency::OSThread
 {
     /**
      * The stream we read/write from
@@ -37,21 +38,23 @@ class StreamAPI : public PhoneAPI
     uint8_t rxBuf[MAX_STREAM_BUF_SIZE];
     size_t rxPtr = 0;
 
+    /// time of last rx, used, to slow down our polling if we haven't heard from anyone
+    uint32_t lastRxMsec = 0;
+
   public:
-    StreamAPI(Stream *_stream) : stream(_stream) {}
+    StreamAPI(Stream *_stream) : concurrency::OSThread("StreamAPI"), stream(_stream) {}
 
     /**
      * Currently we require frequent invocation from loop() to check for arrived serial packets and to send new packets to the
      * phone.
-     * FIXME, to support better power behavior instead move to a thread and block on serial reads.
      */
-    void loop();
+    virtual int32_t runOnce();
 
   private:
     /**
      * Read any rx chars from the link and call handleToRadio
      */
-    void readStream();
+    int32_t readStream();
 
     /**
      * call getFromRadio() and deliver encapsulated packets to the Stream
@@ -63,7 +66,7 @@ class StreamAPI : public PhoneAPI
      * Send a FromRadio.rebooted = true packet to the phone
      */
     void emitRebooted();
-    
+
     /**
      * Send the current txBuffer over our stream
      */

src/mesh/TypedQueue.h

@@ -31,7 +31,9 @@ template <class T> class TypedQueue
 
     bool isEmpty() { return uxQueueMessagesWaiting(h) == 0; }
 
-    bool enqueue(T x, TickType_t maxWait = portMAX_DELAY)
+    /** euqueue a packet.  Also, maxWait used to default to portMAX_DELAY, but we now want to callers to THINK about what blocking
+     * they want */
+    bool enqueue(T x, TickType_t maxWait)
     {
         if (reader) {
             reader->setInterval(0);

src/mesh/generated/admin.pb.h

@@ -26,6 +26,7 @@ typedef struct _AdminMessage {
         bool confirm_set_channel;
         bool confirm_set_radio;
         bool exit_simulator;
+        int32_t reboot_seconds;
     };
 } AdminMessage;
 
@@ -49,6 +50,7 @@ extern "C" {
 #define AdminMessage_confirm_set_channel_tag     32
 #define AdminMessage_confirm_set_radio_tag       33
 #define AdminMessage_exit_simulator_tag          34
+#define AdminMessage_reboot_seconds_tag          35
 
 /* Struct field encoding specification for nanopb */
 #define AdminMessage_FIELDLIST(X, a) \
@@ -61,7 +63,8 @@ X(a, STATIC,   ONEOF,    UINT32,   (variant,get_channel_request,get_channel_requ
 X(a, STATIC,   ONEOF,    MESSAGE,  (variant,get_channel_response,get_channel_response),   7) \
 X(a, STATIC,   ONEOF,    BOOL,     (variant,confirm_set_channel,confirm_set_channel),  32) \
 X(a, STATIC,   ONEOF,    BOOL,     (variant,confirm_set_radio,confirm_set_radio),  33) \
-X(a, STATIC,   ONEOF,    BOOL,     (variant,exit_simulator,exit_simulator),  34)
+X(a, STATIC,   ONEOF,    BOOL,     (variant,exit_simulator,exit_simulator),  34) \
+X(a, STATIC,   ONEOF,    INT32,    (variant,reboot_seconds,reboot_seconds),  35)
 #define AdminMessage_CALLBACK NULL
 #define AdminMessage_DEFAULT NULL
 #define AdminMessage_variant_set_radio_MSGTYPE RadioConfig
@@ -76,7 +79,7 @@ extern const pb_msgdesc_t AdminMessage_msg;
 #define AdminMessage_fields &AdminMessage_msg
 
 /* Maximum encoded size of messages (where known) */
-#define AdminMessage_size                        351
+#define AdminMessage_size                        397
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/apponly.pb.c

@@ -6,9 +6,6 @@
 #error Regenerate this file with the current version of nanopb generator.
 #endif
 
-PB_BIND(ServiceEnvelope, ServiceEnvelope, 2)
-
-
 PB_BIND(ChannelSet, ChannelSet, AUTO)
 
 

src/mesh/generated/apponly.pb.h

@@ -4,7 +4,6 @@
 #ifndef PB_APPONLY_PB_H_INCLUDED
 #define PB_APPONLY_PB_H_INCLUDED
 #include <pb.h>
-#include "mesh.pb.h"
 #include "channel.pb.h"
 
 #if PB_PROTO_HEADER_VERSION != 40
@@ -16,54 +15,31 @@ typedef struct _ChannelSet {
     pb_callback_t settings;
 } ChannelSet;
 
-typedef struct _ServiceEnvelope {
-    bool has_packet;
-    MeshPacket packet;
-    pb_callback_t channel_id;
-    pb_callback_t gateway_id;
-} ServiceEnvelope;
-
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* 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
 
 /* Struct field encoding specification for nanopb */
-#define ServiceEnvelope_FIELDLIST(X, a) \
-X(a, STATIC,   OPTIONAL, MESSAGE,  packet,            1) \
-X(a, CALLBACK, SINGULAR, STRING,   channel_id,        2) \
-X(a, CALLBACK, SINGULAR, STRING,   gateway_id,        3)
-#define ServiceEnvelope_CALLBACK pb_default_field_callback
-#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

src/mesh/generated/deviceonly.pb.h

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

src/mesh/generated/mesh.pb.h

@@ -57,7 +57,9 @@ typedef enum _Routing_Error {
     Routing_Error_MAX_RETRANSMIT = 5,
     Routing_Error_NO_CHANNEL = 6,
     Routing_Error_TOO_LARGE = 7,
-    Routing_Error_NO_RESPONSE = 8
+    Routing_Error_NO_RESPONSE = 8,
+    Routing_Error_BAD_REQUEST = 32,
+    Routing_Error_NOT_AUTHORIZED = 33
 } Routing_Error;
 
 typedef enum _MeshPacket_Priority {
@@ -108,6 +110,7 @@ typedef struct _MyNodeInfo {
     CriticalErrorCode error_code;
     uint32_t error_address;
     uint32_t error_count;
+    uint32_t reboot_count;
     uint32_t message_timeout_msec;
     uint32_t min_app_version;
     uint32_t max_channels;
@@ -132,6 +135,7 @@ typedef struct _User {
     char short_name[5];
     pb_byte_t macaddr[6];
     HardwareModel hw_model;
+    bool is_licensed;
 } User;
 
 typedef PB_BYTES_ARRAY_T(256) MeshPacket_encrypted_t;
@@ -150,6 +154,7 @@ typedef struct _MeshPacket {
     uint8_t hop_limit;
     bool want_ack;
     MeshPacket_Priority priority;
+    int32_t rx_rssi;
 } MeshPacket;
 
 typedef struct _NodeInfo {
@@ -158,6 +163,7 @@ typedef struct _NodeInfo {
     User user;
     bool has_position;
     Position position;
+    uint32_t last_heard;
     float snr;
 } NodeInfo;
 
@@ -188,6 +194,7 @@ typedef struct _ToRadio {
     union {
         MeshPacket packet;
         uint32_t want_config_id;
+        bool disconnect;
     };
 } ToRadio;
 
@@ -206,8 +213,8 @@ typedef struct _ToRadio {
 #define _CriticalErrorCode_ARRAYSIZE ((CriticalErrorCode)(CriticalErrorCode_Brownout+1))
 
 #define _Routing_Error_MIN Routing_Error_NONE
-#define _Routing_Error_MAX Routing_Error_NO_RESPONSE
-#define _Routing_Error_ARRAYSIZE ((Routing_Error)(Routing_Error_NO_RESPONSE+1))
+#define _Routing_Error_MAX Routing_Error_NOT_AUTHORIZED
+#define _Routing_Error_ARRAYSIZE ((Routing_Error)(Routing_Error_NOT_AUTHORIZED+1))
 
 #define _MeshPacket_Priority_MIN MeshPacket_Priority_UNSET
 #define _MeshPacket_Priority_MAX MeshPacket_Priority_MAX
@@ -224,24 +231,24 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define Position_init_default                    {0, 0, 0, 0, 0}
-#define User_init_default                        {"", "", "", {0}, _HardwareModel_MIN}
+#define User_init_default                        {"", "", "", {0}, _HardwareModel_MIN, 0}
 #define RouteDiscovery_init_default              {0, {0, 0, 0, 0, 0, 0, 0, 0}}
 #define Routing_init_default                     {0, {RouteDiscovery_init_default}}
 #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}
-#define MyNodeInfo_init_default                  {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0}
+#define MeshPacket_init_default                  {0, 0, 0, 0, {Data_init_default}, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN, 0}
+#define NodeInfo_init_default                    {0, false, User_init_default, false, Position_init_default, 0, 0}
+#define MyNodeInfo_init_default                  {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0, 0}
 #define LogRecord_init_default                   {"", 0, "", _LogRecord_Level_MIN}
 #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 User_init_zero                           {"", "", "", {0}, _HardwareModel_MIN}
+#define User_init_zero                           {"", "", "", {0}, _HardwareModel_MIN, 0}
 #define RouteDiscovery_init_zero                 {0, {0, 0, 0, 0, 0, 0, 0, 0}}
 #define Routing_init_zero                        {0, {RouteDiscovery_init_zero}}
 #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}
-#define MyNodeInfo_init_zero                     {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0}
+#define MeshPacket_init_zero                     {0, 0, 0, 0, {Data_init_zero}, 0, 0, 0, 0, 0, _MeshPacket_Priority_MIN, 0}
+#define NodeInfo_init_zero                       {0, false, User_init_zero, false, Position_init_zero, 0, 0}
+#define MyNodeInfo_init_zero                     {0, 0, 0, "", "", "", _CriticalErrorCode_MIN, 0, 0, 0, 0, 0, 0}
 #define LogRecord_init_zero                      {"", 0, "", _LogRecord_Level_MIN}
 #define FromRadio_init_zero                      {0, 0, {MyNodeInfo_init_zero}}
 #define ToRadio_init_zero                        {0, {MeshPacket_init_zero}}
@@ -266,6 +273,7 @@ extern "C" {
 #define MyNodeInfo_error_code_tag                7
 #define MyNodeInfo_error_address_tag             8
 #define MyNodeInfo_error_count_tag               9
+#define MyNodeInfo_reboot_count_tag              10
 #define MyNodeInfo_message_timeout_msec_tag      13
 #define MyNodeInfo_min_app_version_tag           14
 #define MyNodeInfo_max_channels_tag              15
@@ -280,6 +288,7 @@ extern "C" {
 #define User_short_name_tag                      3
 #define User_macaddr_tag                         4
 #define User_hw_model_tag                        6
+#define User_is_licensed_tag                     7
 #define MeshPacket_from_tag                      1
 #define MeshPacket_to_tag                        2
 #define MeshPacket_channel_tag                   3
@@ -291,9 +300,11 @@ extern "C" {
 #define MeshPacket_hop_limit_tag                 10
 #define MeshPacket_want_ack_tag                  11
 #define MeshPacket_priority_tag                  12
+#define MeshPacket_rx_rssi_tag                   13
 #define NodeInfo_num_tag                         1
 #define NodeInfo_user_tag                        2
 #define NodeInfo_position_tag                    3
+#define NodeInfo_last_heard_tag                  4
 #define NodeInfo_snr_tag                         7
 #define Routing_route_request_tag                1
 #define Routing_route_reply_tag                  2
@@ -307,6 +318,7 @@ extern "C" {
 #define FromRadio_packet_tag                     11
 #define ToRadio_packet_tag                       2
 #define ToRadio_want_config_id_tag               100
+#define ToRadio_disconnect_tag                   104
 
 /* Struct field encoding specification for nanopb */
 #define Position_FIELDLIST(X, a) \
@@ -323,7 +335,8 @@ X(a, STATIC,   SINGULAR, STRING,   id,                1) \
 X(a, STATIC,   SINGULAR, STRING,   long_name,         2) \
 X(a, STATIC,   SINGULAR, STRING,   short_name,        3) \
 X(a, STATIC,   SINGULAR, FIXED_LENGTH_BYTES, macaddr,           4) \
-X(a, STATIC,   SINGULAR, UENUM,    hw_model,          6)
+X(a, STATIC,   SINGULAR, UENUM,    hw_model,          6) \
+X(a, STATIC,   SINGULAR, BOOL,     is_licensed,       7)
 #define User_CALLBACK NULL
 #define User_DEFAULT NULL
 
@@ -362,7 +375,8 @@ 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)
+X(a, STATIC,   SINGULAR, UENUM,    priority,         12) \
+X(a, STATIC,   SINGULAR, INT32,    rx_rssi,          13)
 #define MeshPacket_CALLBACK NULL
 #define MeshPacket_DEFAULT NULL
 #define MeshPacket_payloadVariant_decoded_MSGTYPE Data
@@ -371,6 +385,7 @@ X(a, STATIC,   SINGULAR, UENUM,    priority,         12)
 X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  user,              2) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  position,          3) \
+X(a, STATIC,   SINGULAR, FIXED32,  last_heard,        4) \
 X(a, STATIC,   SINGULAR, FLOAT,    snr,               7)
 #define NodeInfo_CALLBACK NULL
 #define NodeInfo_DEFAULT NULL
@@ -387,6 +402,7 @@ 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,   reboot_count,     10) \
 X(a, STATIC,   SINGULAR, UINT32,   message_timeout_msec,  13) \
 X(a, STATIC,   SINGULAR, UINT32,   min_app_version,  14) \
 X(a, STATIC,   SINGULAR, UINT32,   max_channels,     15)
@@ -418,7 +434,8 @@ X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,packet,packet),  11)
 
 #define ToRadio_FIELDLIST(X, a) \
 X(a, STATIC,   ONEOF,    MESSAGE,  (payloadVariant,packet,packet),   2) \
-X(a, STATIC,   ONEOF,    UINT32,   (payloadVariant,want_config_id,want_config_id), 100)
+X(a, STATIC,   ONEOF,    UINT32,   (payloadVariant,want_config_id,want_config_id), 100) \
+X(a, STATIC,   ONEOF,    BOOL,     (payloadVariant,disconnect,disconnect), 104)
 #define ToRadio_CALLBACK NULL
 #define ToRadio_DEFAULT NULL
 #define ToRadio_payloadVariant_packet_MSGTYPE MeshPacket
@@ -450,16 +467,16 @@ extern const pb_msgdesc_t ToRadio_msg;
 
 /* Maximum encoded size of messages (where known) */
 #define Position_size                            37
-#define User_size                                74
+#define User_size                                76
 #define RouteDiscovery_size                      40
 #define Routing_size                             42
 #define Data_size                                260
-#define MeshPacket_size                          298
-#define NodeInfo_size                            126
-#define MyNodeInfo_size                          89
+#define MeshPacket_size                          309
+#define NodeInfo_size                            133
+#define MyNodeInfo_size                          95
 #define LogRecord_size                           81
-#define FromRadio_size                           307
-#define ToRadio_size                             301
+#define FromRadio_size                           318
+#define ToRadio_size                             312
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/generated/mqtt.pb.c

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

src/mesh/generated/mqtt.pb.h

@@ -0,0 +1,55 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.4 */
+
+#ifndef PB_MQTT_PB_H_INCLUDED
+#define PB_MQTT_PB_H_INCLUDED
+#include <pb.h>
+#include "mesh.pb.h"
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+typedef struct _ServiceEnvelope {
+    struct _MeshPacket *packet;
+    char *channel_id;
+    char *gateway_id;
+} ServiceEnvelope;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define ServiceEnvelope_init_default             {NULL, NULL, NULL}
+#define ServiceEnvelope_init_zero                {NULL, NULL, NULL}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define ServiceEnvelope_packet_tag               1
+#define ServiceEnvelope_channel_id_tag           2
+#define ServiceEnvelope_gateway_id_tag           3
+
+/* Struct field encoding specification for nanopb */
+#define ServiceEnvelope_FIELDLIST(X, a) \
+X(a, POINTER,  OPTIONAL, MESSAGE,  packet,            1) \
+X(a, POINTER,  SINGULAR, STRING,   channel_id,        2) \
+X(a, POINTER,  SINGULAR, STRING,   gateway_id,        3)
+#define ServiceEnvelope_CALLBACK NULL
+#define ServiceEnvelope_DEFAULT NULL
+#define ServiceEnvelope_packet_MSGTYPE MeshPacket
+
+extern const pb_msgdesc_t ServiceEnvelope_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define ServiceEnvelope_fields &ServiceEnvelope_msg
+
+/* Maximum encoded size of messages (where known) */
+/* ServiceEnvelope_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

src/mesh/generated/radioconfig.pb.h

@@ -85,6 +85,10 @@ typedef struct _RadioConfig_UserPreferences {
     bool is_router;
     bool is_low_power;
     bool fixed_position;
+    bool serial_disabled;
+    float frequency_offset;
+    char mqtt_server[32];
+    bool mqtt_disabled;
     bool factory_reset;
     bool debug_log_enabled;
     pb_size_t ignore_incoming_count;
@@ -150,9 +154,9 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define RadioConfig_init_default                 {false, RadioConfig_UserPreferences_init_default}
-#define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0}
+#define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0}
 #define RadioConfig_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, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0}
+#define RadioConfig_UserPreferences_init_zero    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", "", 0, _RegionCode_MIN, _ChargeCurrent_MIN, _LocationSharing_MIN, _GpsOperation_MIN, 0, 0, 0, 0, 0, 0, 0, "", 0, 0, 0, 0, {0, 0, 0}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, _RadioConfig_UserPreferences_EnvironmentalMeasurementSensorType_MIN, 0, 0}
 
 /* Field tags (for use in manual encoding/decoding) */
 #define RadioConfig_UserPreferences_position_broadcast_secs_tag 1
@@ -177,6 +181,10 @@ extern "C" {
 #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_serial_disabled_tag 40
+#define RadioConfig_UserPreferences_frequency_offset_tag 41
+#define RadioConfig_UserPreferences_mqtt_server_tag 42
+#define RadioConfig_UserPreferences_mqtt_disabled_tag 43
 #define RadioConfig_UserPreferences_factory_reset_tag 100
 #define RadioConfig_UserPreferences_debug_log_enabled_tag 101
 #define RadioConfig_UserPreferences_ignore_incoming_tag 103
@@ -237,6 +245,10 @@ 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,     serial_disabled,  40) \
+X(a, STATIC,   SINGULAR, FLOAT,    frequency_offset,  41) \
+X(a, STATIC,   SINGULAR, STRING,   mqtt_server,      42) \
+X(a, STATIC,   SINGULAR, BOOL,     mqtt_disabled,    43) \
 X(a, STATIC,   SINGULAR, BOOL,     factory_reset,   100) \
 X(a, STATIC,   SINGULAR, BOOL,     debug_log_enabled, 101) \
 X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103) \
@@ -276,8 +288,8 @@ extern const pb_msgdesc_t RadioConfig_UserPreferences_msg;
 #define RadioConfig_UserPreferences_fields &RadioConfig_UserPreferences_msg
 
 /* Maximum encoded size of messages (where known) */
-#define RadioConfig_size                         348
-#define RadioConfig_UserPreferences_size         345
+#define RadioConfig_size                         394
+#define RadioConfig_UserPreferences_size         391
 
 #ifdef __cplusplus
 } /* extern "C" */

src/mesh/http/ContentHandler.cpp

@@ -1,5 +1,6 @@
 #include "NodeDB.h"
 #include "PowerFSM.h"
+#include "RadioLibInterface.h"
 #include "airtime.h"
 #include "main.h"
 #include "mesh/http/ContentHelper.h"
@@ -11,7 +12,6 @@
 #include <HTTPMultipartBodyParser.hpp>
 #include <HTTPURLEncodedBodyParser.hpp>
 #include <SPIFFS.h>
-#include "RadioLibInterface.h"
 
 #ifndef NO_ESP32
 #include "esp_task_wdt.h"
@@ -77,7 +77,8 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     ResourceNode *nodeAPIv1ToRadio = new ResourceNode("/api/v1/toradio", "PUT", &handleAPIv1ToRadio);
     ResourceNode *nodeAPIv1FromRadio = new ResourceNode("/api/v1/fromradio", "GET", &handleAPIv1FromRadio);
 
-    ResourceNode *nodeHotspot = new ResourceNode("/hotspot-detect.html", "GET", &handleHotspot);
+    ResourceNode *nodeHotspotApple = new ResourceNode("/hotspot-detect.html", "GET", &handleHotspot);
+    ResourceNode *nodeHotspotAndroid = new ResourceNode("/generate_204", "GET", &handleHotspot);
     ResourceNode *nodeFavicon = new ResourceNode("/favicon.ico", "GET", &handleFavicon);
     ResourceNode *nodeRoot = new ResourceNode("/", "GET", &handleRoot);
     ResourceNode *nodeStaticBrowse = new ResourceNode("/static", "GET", &handleStaticBrowse);
@@ -96,7 +97,8 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     secureServer->registerNode(nodeAPIv1ToRadioOptions);
     secureServer->registerNode(nodeAPIv1ToRadio);
     secureServer->registerNode(nodeAPIv1FromRadio);
-    secureServer->registerNode(nodeHotspot);
+    secureServer->registerNode(nodeHotspotApple);
+    secureServer->registerNode(nodeHotspotAndroid);
     secureServer->registerNode(nodeFavicon);
     secureServer->registerNode(nodeRoot);
     secureServer->registerNode(nodeStaticBrowse);
@@ -117,7 +119,8 @@ void registerHandlers(HTTPServer *insecureServer, HTTPSServer *secureServer)
     insecureServer->registerNode(nodeAPIv1ToRadioOptions);
     insecureServer->registerNode(nodeAPIv1ToRadio);
     insecureServer->registerNode(nodeAPIv1FromRadio);
-    insecureServer->registerNode(nodeHotspot);
+    insecureServer->registerNode(nodeHotspotApple);
+    insecureServer->registerNode(nodeHotspotAndroid);
     insecureServer->registerNode(nodeFavicon);
     insecureServer->registerNode(nodeRoot);
     insecureServer->registerNode(nodeStaticBrowse);
@@ -931,6 +934,10 @@ void handleReport(HTTPRequest *req, HTTPResponse *res)
     res->printf("\"is_charging\": %s\n", BoolToString(powerStatus->getIsCharging()));
     res->println("},");
 
+    res->println("\"device\": {");
+    res->printf("\"reboot_counter\": %d\n", myNodeInfo.reboot_count);
+    res->println("},");
+
     res->println("\"radio\": {");
     res->printf("\"frequecy\": %f,\n", RadioLibInterface::instance->getFreq());
     res->printf("\"lora_channel\": %d\n", RadioLibInterface::instance->getChannelNum());
@@ -938,8 +945,6 @@ void handleReport(HTTPRequest *req, HTTPResponse *res)
 
     res->println("},");
 
-
-
     res->println("\"status\": \"ok\"");
     res->println("}");
 }

src/mesh/wifi/WiFiServerAPI.cpp

@@ -40,18 +40,20 @@ void WiFiServerAPI::onConnectionChanged(bool connected)
 }
 
 /// override close to also shutdown the TCP link
-void WiFiServerAPI::close() {
+void WiFiServerAPI::close()
+{
     client.stop(); // drop tcp connection
     StreamAPI::close();
 }
 
-bool WiFiServerAPI::loop()
+int32_t WiFiServerAPI::runOnce()
 {
     if (client.connected()) {
-        StreamAPI::loop();
-        return true;
+        return StreamAPI::runOnce();
     } else {
-        return false;       
+        DEBUG_MSG("Client dropped connection, suspending API service\n");
+        enabled = false; // we no longer need to run
+        return 0;
     }
 }
 
@@ -78,18 +80,5 @@ int32_t WiFiServerPort::runOnce()
         openAPI = new WiFiServerAPI(client);
     }
 
-    if (openAPI) {
-        // Allow idle processing so the API can read from its incoming stream
-        if(!openAPI->loop()) {
-            // If our API link was up, shut it down
-
-            DEBUG_MSG("Client dropped connection, closing API client\n");
-            // Note: we can't call delete here because this object includes other state
-            // besides the stream API.  Instead kill it later when we start a new instance
-            delete openAPI;
-            openAPI = NULL;
-        }
-        return 0; // run fast while our API server is running
-    } else
-        return 100; // only check occasionally for incoming connections
+    return 100; // only check occasionally for incoming connections
 }

src/mesh/wifi/WiFiServerAPI.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "StreamAPI.h"
-#include "concurrency/OSThread.h"
 #include <WiFi.h>
 
 /**
@@ -18,15 +17,14 @@ class WiFiServerAPI : public StreamAPI
 
     virtual ~WiFiServerAPI();
 
-    /// @return true if we want to keep running, or false if we are ready to be destroyed
-    virtual bool loop(); // Check for dropped client connections
-
     /// override close to also shutdown the TCP link
     virtual void close();
 
   protected:
     /// Hookable to find out when connection changes
     virtual void onConnectionChanged(bool connected);
+
+    virtual int32_t runOnce(); // Check for dropped client connections
 };
 
 /**

src/mqtt/MQTT.cpp

@@ -0,0 +1,166 @@
+#include "MQTT.h"
+#include "NodeDB.h"
+#include "main.h"
+#include "mesh/Channels.h"
+#include "mesh/Router.h"
+#include "mesh/generated/mqtt.pb.h"
+#include <WiFi.h>
+#include <assert.h>
+
+MQTT *mqtt;
+
+String statusTopic = "msh/1/stat/";
+String cryptTopic = "msh/1/c/"; // msh/1/c/CHANNELID/NODEID
+
+void MQTT::mqttCallback(char *topic, byte *payload, unsigned int length)
+{
+    mqtt->onPublish(topic, payload, length);
+}
+
+void MQTT::onPublish(char *topic, byte *payload, unsigned int length)
+{
+    // parsing ServiceEnvelope
+    ServiceEnvelope e = ServiceEnvelope_init_default;
+    if (!pb_decode_from_bytes(payload, length, ServiceEnvelope_fields, &e)) {
+        DEBUG_MSG("Invalid MQTT service envelope, topic %s, len %u!\n", topic, length);
+    } else {
+        DEBUG_MSG("Received MQTT topic %s, len=%u\n", topic, length);
+
+        if (e.packet) {
+            MeshPacket *p = packetPool.allocCopy(*e.packet);
+
+            // ignore messages sent by us or if we don't have the channel key
+            if (router && p->from != nodeDB.getNodeNum() && perhapsDecode(p))
+                router->enqueueReceivedMessage(p);
+            else
+                packetPool.release(p);
+        }
+
+        // make sure to free both strings and the MeshPacket (passing in NULL is acceptable)
+        free(e.channel_id);
+        free(e.gateway_id);
+        free(e.packet);
+    }
+}
+
+void mqttInit()
+{
+    new MQTT();
+}
+
+MQTT::MQTT() : concurrency::OSThread("mqtt"), pubSub(mqttClient)
+{
+    assert(!mqtt);
+    mqtt = this;
+
+    pubSub.setCallback(mqttCallback);
+}
+
+void MQTT::reconnect()
+{
+    // pubSub.setServer("devsrv.ezdevice.net", 1883); or 192.168.10.188
+    const char *serverAddr = "mqtt.meshtastic.org"; // default hostname
+
+    if (*radioConfig.preferences.mqtt_server)
+        serverAddr = radioConfig.preferences.mqtt_server; // Override the default
+
+    pubSub.setServer(serverAddr, 1883);
+
+    DEBUG_MSG("Connecting to MQTT server\n", serverAddr);
+    auto myStatus = (statusTopic + owner.id);
+    bool connected = pubSub.connect(owner.id, "meshdev", "large4cats", myStatus.c_str(), 1, true, "offline");
+    if (connected) {
+        DEBUG_MSG("MQTT connected\n");
+        enabled = true; // Start running background process again
+        runASAP = true;
+
+        /// FIXME, include more information in the status text
+        bool ok = pubSub.publish(myStatus.c_str(), "online", true);
+        DEBUG_MSG("published %d\n", ok);
+
+        sendSubscriptions();
+    } else
+        DEBUG_MSG("Failed to contact MQTT server...\n");
+}
+
+void MQTT::sendSubscriptions()
+{
+    size_t numChan = channels.getNumChannels();
+    for (size_t i = 0; i < numChan; i++) {
+        auto &ch = channels.getByIndex(i);
+        if (ch.settings.downlink_enabled) {
+            String topic = cryptTopic + channels.getGlobalId(i) + "/#";
+            DEBUG_MSG("Subscribing to %s\n", topic.c_str());
+            pubSub.subscribe(topic.c_str(), 1); // FIXME, is QOS 1 right?
+        }
+    }
+}
+
+bool MQTT::wantsLink() const
+{
+    bool hasChannel = false;
+
+    if (radioConfig.preferences.mqtt_disabled) {
+        // DEBUG_MSG("MQTT disabled...\n");
+    } else {
+        // No need for link if no channel needed it
+        size_t numChan = channels.getNumChannels();
+        for (size_t i = 0; i < numChan; i++) {
+            auto &ch = channels.getByIndex(i);
+            if (ch.settings.uplink_enabled || ch.settings.downlink_enabled) {
+                hasChannel = true;
+                break;
+            }
+        }
+    }
+
+    return hasChannel && WiFi.isConnected();
+}
+
+int32_t MQTT::runOnce()
+{
+    bool wantConnection = wantsLink();
+
+    // If connected poll rapidly, otherwise only occasionally check for a wifi connection change and ability to contact server
+    if (!pubSub.loop()) {
+        if (wantConnection) {
+            reconnect();
+
+            // If we succeeded, start reading rapidly, else try again in 30 seconds (TCP connections are EXPENSIVE so try rarely)
+            return pubSub.connected() ? 20 : 30000;
+        } else
+            return 5000; // If we don't want connection now, check again in 5 secs
+    } else {
+        // we are connected to server, check often for new requests on the TCP port
+        if (!wantConnection) {
+            DEBUG_MSG("MQTT link not needed, dropping\n");
+            pubSub.disconnect();
+        }
+
+        return 20;
+    }
+}
+
+void MQTT::onSend(const MeshPacket &mp, ChannelIndex chIndex)
+{
+    auto &ch = channels.getByIndex(chIndex);
+
+    // don't bother sending if not connected...
+    if (pubSub.connected() && ch.settings.uplink_enabled) {
+        const char *channelId = channels.getGlobalId(chIndex); // FIXME, for now we just use the human name for the channel
+
+        ServiceEnvelope env = ServiceEnvelope_init_default;
+        env.channel_id = (char *)channelId;
+        env.gateway_id = owner.id;
+        env.packet = (MeshPacket *)&mp;
+
+        // FIXME - this size calculation is super sloppy, but it will go away once we dynamically alloc meshpackets
+        static uint8_t bytes[MeshPacket_size + 64];
+        size_t numBytes = pb_encode_to_bytes(bytes, sizeof(bytes), ServiceEnvelope_fields, &env);
+
+        String topic = cryptTopic + channelId + "/" + owner.id;
+        DEBUG_MSG("publish %s, %u bytes\n", topic.c_str(), numBytes);
+
+        pubSub.publish(topic.c_str(), bytes, numBytes, false);
+    }
+}

src/mqtt/MQTT.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include "configuration.h"
+
+#include "concurrency/OSThread.h"
+#include "mesh/Channels.h"
+#include <PubSubClient.h>
+#include <WiFiClient.h>
+
+/**
+ * Our wrapper/singleton for sending/receiving MQTT "udp" packets.  This object isolates the MQTT protocol implementation from
+ * the two components that use it: MQTTPlugin and MQTTSimInterface.
+ */
+class MQTT : private concurrency::OSThread
+{
+    // supposedly the current version is busted:
+    // http://www.iotsharing.com/2017/08/how-to-use-esp32-mqtts-with-mqtts-mosquitto-broker-tls-ssl.html
+    // WiFiClientSecure wifiClient;
+    WiFiClient mqttClient;
+    PubSubClient pubSub;
+
+  public:
+    MQTT();
+
+    /**
+     * Publish a packet on the glboal MQTT server.
+     * This hook must be called **after** the packet is encrypted (including the channel being changed to a hash).
+     * @param chIndex the index of the channel for this message
+     *
+     * Note: for messages we are forwarding on the mesh that we can't find the channel for (because we don't have the keys), we
+     * can not forward those messages to the cloud - becuase no way to find a global channel ID.
+     */
+    void onSend(const MeshPacket &mp, ChannelIndex chIndex);
+
+  protected:
+    virtual int32_t runOnce();
+
+  private:
+    /** return true if we have a channel that wants uplink/downlink
+     */
+    bool wantsLink() const;
+
+    /** Attempt to connect to server if necessary
+     */
+    void reconnect();
+
+    /** Tell the server what subscriptions we want (based on channels.downlink_enabled)
+     */
+    void sendSubscriptions();
+
+    /// Just C glue to call onPublish
+    static void mqttCallback(char *topic, byte *payload, unsigned int length);
+
+    /// Called when a new publish arrives from the MQTT server
+    void onPublish(char *topic, byte *payload, unsigned int length);
+};
+
+void mqttInit();
+
+extern MQTT *mqtt;

src/nimble/BluetoothUtil.cpp

@@ -487,7 +487,6 @@ void reinitBluetooth()
     DEBUG_MSG("Starting bluetooth\n");
     if (isFirstTime) {
         bluetoothPhoneAPI = new BluetoothPhoneAPI();
-        bluetoothPhoneAPI->init();
     }
 
     // FIXME - if waking from light sleep, only esp_nimble_hci_init?

src/nrf52/NRF52Bluetooth.cpp

@@ -2,10 +2,10 @@
 #include "BluetoothCommon.h"
 #include "configuration.h"
 #include "main.h"
+#include "mesh/PhoneAPI.h"
+#include "mesh/mesh-pb-constants.h"
 #include <bluefruit.h>
 
-
-
 static BLEService meshBleService = BLEService(BLEUuid(MESH_SERVICE_UUID_16));
 static BLECharacteristic fromNum = BLECharacteristic(BLEUuid(FROMNUM_UUID_16));
 static BLECharacteristic fromRadio = BLECharacteristic(BLEUuid(FROMRADIO_UUID_16));
@@ -155,7 +155,6 @@ void fromNumAuthorizeCb(uint16_t conn_hdl, BLECharacteristic *chr, ble_gatts_evt
 void setupMeshService(void)
 {
     bluetoothPhoneAPI = new BluetoothPhoneAPI();
-    bluetoothPhoneAPI->init();
 
     meshBleService.begin();
 
@@ -213,6 +212,7 @@ void NRF52Bluetooth::setup()
 {
     // Initialise the Bluefruit module
     DEBUG_MSG("Initialise the Bluefruit nRF52 module\n");
+    Bluefruit.autoConnLed(false);
     Bluefruit.begin();
 
     // Set the advertised device name (keep it short!)

src/nrf52/main-nrf52.cpp

@@ -1,7 +1,3 @@
-#include "NRF52Bluetooth.h"
-#include "configuration.h"
-#include "error.h"
-#include "graphics/TFTDisplay.h"
 #include <SPI.h>
 #include <Wire.h>
 #include <assert.h>
@@ -9,179 +5,182 @@
 #include <memory.h>
 #include <stdio.h>
 
-#ifdef NRF52840_XXAA
-// #include <nrf52840.h>
+#include "NRF52Bluetooth.h"
+#include "configuration.h"
+#include "error.h"
+
+#ifdef BQ25703A_ADDR
+#include "BQ25713.h"
 #endif
 
-// #define USE_SOFTDEVICE
 
-static inline void debugger_break(void)
-{
-    __asm volatile("bkpt #0x01\n\t"
-                   "mov pc, lr\n\t");
+static inline void debugger_break(void) {
+  __asm volatile(
+      "bkpt #0x01\n\t"
+      "mov pc, lr\n\t");
 }
 
 // handle standard gcc assert failures
-void __attribute__((noreturn)) __assert_func(const char *file, int line, const char *func, const char *failedexpr)
-{
-    DEBUG_MSG("assert failed %s: %d, %s, test=%s\n", file, line, func, failedexpr);
-    // debugger_break(); FIXME doesn't work, possibly not for segger
-    while (1)
-        ; // FIXME, reboot!
+void __attribute__((noreturn))
+__assert_func(const char *file, int line, const char *func,
+              const char *failedexpr) {
+  DEBUG_MSG("assert failed %s: %d, %s, test=%s\n", file, line, func,
+            failedexpr);
+  // debugger_break(); FIXME doesn't work, possibly not for segger
+  while (1)
+    ;  // FIXME, reboot!
 }
 
-void getMacAddr(uint8_t *dmac)
-{
-    ble_gap_addr_t addr;
-
-#ifdef USE_SOFTDEVICE
-    uint32_t res = sd_ble_gap_addr_get(&addr);
-    assert(res == NRF_SUCCESS);
+void getMacAddr(uint8_t *dmac) {
+  ble_gap_addr_t addr;
+  if (sd_ble_gap_addr_get(&addr) == NRF_SUCCESS) {
     memcpy(dmac, addr.addr, 6);
-#else
+  } else {
     const uint8_t *src = (const uint8_t *)NRF_FICR->DEVICEADDR;
     dmac[5] = src[0];
     dmac[4] = src[1];
     dmac[3] = src[2];
     dmac[2] = src[3];
     dmac[1] = src[4];
-    dmac[0] = src[5] | 0xc0; // MSB high two bits get set elsewhere in the bluetooth stack
-#endif
+    dmac[0] = src[5] |
+            0xc0;  // MSB high two bits get set elsewhere in the bluetooth stack
+  }
 }
 
 NRF52Bluetooth *nrf52Bluetooth;
 
 static bool bleOn = false;
-static const bool useSoftDevice = false; // Set to false for easier debugging
+static const bool useSoftDevice = true;  // Set to false for easier debugging
 
-void setBluetoothEnable(bool on)
-{
-    if (on != bleOn) {
-        if (on) {
-            if (!nrf52Bluetooth) {
-                if (!useSoftDevice)
-                    DEBUG_MSG("DISABLING NRF52 BLUETOOTH WHILE DEBUGGING\n");
-                else {
-                    nrf52Bluetooth = new NRF52Bluetooth();
-                    nrf52Bluetooth->setup();
-                }
-            }
-        } else {
-            if (nrf52Bluetooth)
-                nrf52Bluetooth->shutdown();
+void setBluetoothEnable(bool on) {
+  if (on != bleOn) {
+    if (on) {
+      if (!nrf52Bluetooth) {
+        if (!useSoftDevice)
+          DEBUG_MSG("DISABLING NRF52 BLUETOOTH WHILE DEBUGGING\n");
+        else {
+          nrf52Bluetooth = new NRF52Bluetooth();
+          nrf52Bluetooth->setup();
         }
-        bleOn = on;
+      }
+    } else {
+      if (nrf52Bluetooth) nrf52Bluetooth->shutdown();
     }
+    bleOn = on;
+  }
 }
 
 /**
  * Override printf to use the SEGGER output library
  */
-int printf(const char *fmt, ...)
-{
-    va_list args;
-    va_start(args, fmt);
-    auto res = SEGGER_RTT_vprintf(0, fmt, &args);
-    va_end(args);
-    return res;
+int printf(const char *fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  auto res = SEGGER_RTT_vprintf(0, fmt, &args);
+  va_end(args);
+  return res;
 }
 
-#include "BQ25713.h"
+void initBrownout() {
+  auto vccthresh = POWER_POFCON_THRESHOLD_V28;
 
-void initBrownout()
-{
-    auto vccthresh = POWER_POFCON_THRESHOLD_V28;
+  if (useSoftDevice) {
+    auto err_code = sd_power_pof_enable(POWER_POFCON_POF_Enabled);
+    assert(err_code == NRF_SUCCESS);
+
+    err_code = sd_power_pof_threshold_set(vccthresh);
+    assert(err_code == NRF_SUCCESS);
+  } else {
+    uint32_t pof_flags = POWER_POFCON_POF_Enabled | (vccthresh << POWER_POFCON_THRESHOLD_Pos);
+    
+    #ifdef POWER_POFCON_THRESHOLDVDDH_Msk 
     auto vcchthresh = POWER_POFCON_THRESHOLDVDDH_V27;
-
-    if (useSoftDevice) {
-        auto err_code = sd_power_pof_enable(POWER_POFCON_POF_Enabled);
-        assert(err_code == NRF_SUCCESS);
-
-        err_code = sd_power_pof_threshold_set(vccthresh);
-        assert(err_code == NRF_SUCCESS);
-    }
-    else {
-        NRF_POWER->POFCON = POWER_POFCON_POF_Msk | (vccthresh << POWER_POFCON_THRESHOLD_Pos) | (vcchthresh << POWER_POFCON_THRESHOLDVDDH_Pos);
-    }
+    pof_flags |= (vcchthresh << POWER_POFCON_THRESHOLDVDDH_Pos);
+    #endif
+    
+    NRF_POWER->POFCON =  pof_flags;
+  }
 }
 
-void checkSDEvents()
-{
-    if (useSoftDevice) {
-        uint32_t evt;
-        while (NRF_ERROR_NOT_FOUND == sd_evt_get(&evt)) {
-            switch (evt) {
-            case NRF_EVT_POWER_FAILURE_WARNING:
-                recordCriticalError(CriticalErrorCode_Brownout);
-                break;
+void checkSDEvents() {
+  if (useSoftDevice) {
+    uint32_t evt;
+    while (NRF_SUCCESS == sd_evt_get(&evt)) {
+      switch (evt) {
+        case NRF_EVT_POWER_FAILURE_WARNING:
+          recordCriticalError(CriticalErrorCode_Brownout);
+          break;
 
-            default:
-                DEBUG_MSG("Unexpected SDevt %d\n", evt);
-                break;
-            }
-        }
-    } else {
-        if(NRF_POWER->EVENTS_POFWARN)
-            recordCriticalError(CriticalErrorCode_Brownout);
+        default:
+          DEBUG_MSG("Unexpected SDevt %d\n", evt);
+          break;
+      }
     }
+  } else {
+    if (NRF_POWER->EVENTS_POFWARN)
+      recordCriticalError(CriticalErrorCode_Brownout);
+  }
 }
 
-void nrf52Loop()
-{
-    checkSDEvents();
-}
+void nrf52Loop() { checkSDEvents(); }
 
-void nrf52Setup()
-{
+void nrf52Setup() {
+  auto why = NRF_POWER->RESETREAS;
+  // per
+  // https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.nrf52832.ps.v1.1%2Fpower.html
+  DEBUG_MSG("Reset reason: 0x%x\n", why);
 
-    auto why = NRF_POWER->RESETREAS;
-    // per https://infocenter.nordicsemi.com/index.jsp?topic=%2Fcom.nordic.infocenter.nrf52832.ps.v1.1%2Fpower.html
-    DEBUG_MSG("Reset reason: 0x%x\n", why);
-
-    // Per https://devzone.nordicsemi.com/nordic/nordic-blog/b/blog/posts/monitor-mode-debugging-with-j-link-and-gdbeclipse
-    // This is the recommended setting for Monitor Mode Debugging
-    NVIC_SetPriority(DebugMonitor_IRQn, 6UL);
+  // Per
+  // https://devzone.nordicsemi.com/nordic/nordic-blog/b/blog/posts/monitor-mode-debugging-with-j-link-and-gdbeclipse
+  // This is the recommended setting for Monitor Mode Debugging
+  NVIC_SetPriority(DebugMonitor_IRQn, 6UL);
 
 #ifdef BQ25703A_ADDR
-    auto *bq = new BQ25713();
-    if (!bq->setup())
-        DEBUG_MSG("ERROR! Charge controller init failed\n");
+  auto *bq = new BQ25713();
+  if (!bq->setup()) DEBUG_MSG("ERROR! Charge controller init failed\n");
 #endif
 
-    // Init random seed
-    // FIXME - use this to get random numbers
-    // #include "nrf_rng.h"
-    // uint32_t r;
-    // ble_controller_rand_vector_get_blocking(&r, sizeof(r));
-    // randomSeed(r);
-    DEBUG_MSG("FIXME, call randomSeed\n");
-    // ::printf("TESTING PRINTF\n");
+  // Init random seed
+  // FIXME - use this to get random numbers
+  // #include "nrf_rng.h"
+  // uint32_t r;
+  // ble_controller_rand_vector_get_blocking(&r, sizeof(r));
+  // randomSeed(r);
+  DEBUG_MSG("FIXME, call randomSeed\n");
+  // ::printf("TESTING PRINTF\n");
 
-    initBrownout();
+  initBrownout();
 }
 
-void cpuDeepSleep(uint64_t msecToWake)
-{
-    // FIXME, configure RTC or button press to wake us
-    // FIXME, power down SPI, I2C, RAMs
-    Wire.end();
-    SPI.end();
-    Serial.end();
-    Serial1.end();
+void cpuDeepSleep(uint64_t msecToWake) {
+  // FIXME, configure RTC or button press to wake us
+  // FIXME, power down SPI, I2C, RAMs
+#ifndef NO_WIRE
+  Wire.end();
+#endif
+  SPI.end();
+  // This may cause crashes as debug messages continue to flow.
+  Serial.end();
 
-    // FIXME, use system off mode with ram retention for key state?
-    // FIXME, use non-init RAM per
-    // https://devzone.nordicsemi.com/f/nordic-q-a/48919/ram-retention-settings-with-softdevice-enabled
+#ifdef PIN_SERIAL_RX1
+  Serial1.end();
+#endif
+  setBluetoothEnable(false);
+  // FIXME, use system off mode with ram retention for key state?
+  // FIXME, use non-init RAM per
+  // https://devzone.nordicsemi.com/f/nordic-q-a/48919/ram-retention-settings-with-softdevice-enabled
 
-    auto ok = sd_power_system_off();
-    if (ok != NRF_SUCCESS) {
-        DEBUG_MSG("FIXME: Ignoring soft device (EasyDMA pending?) and forcing system-off!\n");
-        NRF_POWER->SYSTEMOFF = 1;
-    }
+  auto ok = sd_power_system_off();
+  if (ok != NRF_SUCCESS) {
+    DEBUG_MSG(
+        "FIXME: Ignoring soft device (EasyDMA pending?) and forcing "
+        "system-off!\n");
+    NRF_POWER->SYSTEMOFF = 1;
+  }
 
-    // The following code should not be run, because we are off
-    while (1) {
-        delay(5000);
-        DEBUG_MSG(".");
-    }
+  // The following code should not be run, because we are off
+  while (1) {
+    delay(5000);
+    DEBUG_MSG(".");
+  }
 }

src/plugins/AdminPlugin.cpp

@@ -19,7 +19,7 @@ void AdminPlugin::handleGetChannel(const MeshPacket &req, uint32_t channelIndex)
         AdminMessage r = AdminMessage_init_default;
         r.get_channel_response = channels.getByIndex(channelIndex);
         r.which_variant = AdminMessage_get_channel_response_tag;
-        reply = allocDataProtobuf(r);
+        myReply = allocDataProtobuf(r);
     }
 }
 
@@ -36,7 +36,7 @@ void AdminPlugin::handleGetRadio(const MeshPacket &req)
         r.get_radio_response.preferences.ls_secs = getPref_ls_secs();
 
         r.which_variant = AdminMessage_get_radio_response_tag;
-        reply = allocDataProtobuf(r);
+        myReply = allocDataProtobuf(r);
     }
 }
 
@@ -56,19 +56,34 @@ bool AdminPlugin::handleReceivedProtobuf(const MeshPacket &mp, const AdminMessag
 
     case AdminMessage_set_channel_tag:
         DEBUG_MSG("Client is setting channel %d\n", r->set_channel.index);
-        handleSetChannel(r->set_channel);
+        if (r->set_channel.index < 0 || r->set_channel.index >= (int)MAX_NUM_CHANNELS)
+            myReply = allocErrorResponse(Routing_Error_BAD_REQUEST, &mp);
+        else
+            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);
+    case AdminMessage_get_channel_request_tag: {
+        uint32_t i = r->get_channel_request - 1;
+        DEBUG_MSG("Client is getting channel %u\n", i);
+        if (i >= MAX_NUM_CHANNELS)
+            myReply = allocErrorResponse(Routing_Error_BAD_REQUEST, &mp);
+        else
+            handleGetChannel(mp, i);
         break;
+    }
 
     case AdminMessage_get_radio_request_tag:
         DEBUG_MSG("Client is getting radio\n");
         handleGetRadio(mp);
         break;
 
+    case AdminMessage_reboot_seconds_tag: {
+        int32_t s = r->reboot_seconds;
+        DEBUG_MSG("Rebooting in %d seconds\n", s);
+        rebootAtMsec = (s < 0) ? 0 : (millis() + s * 1000);
+        break;
+    }
+
 #ifdef PORTDUINO
     case AdminMessage_exit_simulator_tag:
         DEBUG_MSG("Exiting simulator\n");
@@ -100,6 +115,10 @@ void AdminPlugin::handleSetOwner(const User &o)
         changed |= strcmp(owner.id, o.id);
         strcpy(owner.id, o.id);
     }
+    if (owner.is_licensed != o.is_licensed) {
+        changed = true;
+        owner.is_licensed = o.is_licensed;
+    }
 
     if (changed) // If nothing really changed, don't broadcast on the network or write to flash
         service.reloadOwner();
@@ -126,13 +145,6 @@ void AdminPlugin::handleSetRadio(const RadioConfig &r)
     service.reloadConfig();
 }
 
-MeshPacket *AdminPlugin::allocReply()
-{
-    auto r = reply;
-    reply = NULL; // Only use each reply once
-    return r;
-}
-
 AdminPlugin::AdminPlugin() : ProtobufPlugin("Admin", PortNum_ADMIN_APP, AdminMessage_fields)
 {
     // restrict to the admin channel for rx

src/plugins/AdminPlugin.h

@@ -6,8 +6,6 @@
  */
 class AdminPlugin : public ProtobufPlugin<AdminMessage>
 {
-  MeshPacket *reply = NULL;
-  
   public:
     /** Constructor
      * name is for debugging output
@@ -21,10 +19,6 @@ class AdminPlugin : public ProtobufPlugin<AdminMessage>
     */
     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);

src/plugins/PluginDev.h

@@ -0,0 +1,10 @@
+#pragma once
+
+/*
+ * To developers:
+ *   Use this to enable / disable features in your plugin that you don't want to risk checking into GitHub.
+ *
+ */
+
+// Enable development more for StoreForwardPlugin
+bool StoreForward_Dev = false;

src/plugins/PositionPlugin.cpp

@@ -10,10 +10,8 @@ PositionPlugin *positionPlugin;
 PositionPlugin::PositionPlugin()
     : ProtobufPlugin("position", PortNum_POSITION_APP, Position_fields), concurrency::OSThread("PositionPlugin")
 {
-    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)
-
+    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)

src/plugins/RemoteHardwarePlugin.cpp

@@ -10,12 +10,13 @@
 
 // Because (FIXME) we currently don't tell API clients status on sent messages
 // we need to throttle our sending, so that if a gpio is bouncing up and down we
-// don't generate more messages than the net can send. So we limit watch messages to 
+// don't generate more messages than the net can send. So we limit watch messages to
 // a max of one change per 30 seconds
 #define WATCH_INTERVAL_MSEC (30 * 1000)
 
 /// Set pin modes for every set bit in a mask
-static void pinModes(uint64_t mask, uint8_t mode) {
+static void pinModes(uint64_t mask, uint8_t mode)
+{
     for (uint8_t i = 0; i < NUM_GPIOS; i++) {
         if (mask & (1 << i)) {
             pinMode(i, mode);
@@ -24,7 +25,8 @@ static void pinModes(uint64_t mask, uint8_t mode) {
 }
 
 /// Read all the pins mentioned in a mask
-static uint64_t digitalReads(uint64_t mask) {
+static uint64_t digitalReads(uint64_t mask)
+{
     uint64_t res = 0;
 
     pinModes(mask, INPUT_PULLUP);
@@ -40,10 +42,9 @@ static uint64_t digitalReads(uint64_t mask) {
     return res;
 }
 
-
 RemoteHardwarePlugin::RemoteHardwarePlugin()
-    : ProtobufPlugin("remotehardware", PortNum_REMOTE_HARDWARE_APP, HardwareMessage_fields),
-    concurrency::OSThread("remotehardware")
+    : ProtobufPlugin("remotehardware", PortNum_REMOTE_HARDWARE_APP, HardwareMessage_fields), concurrency::OSThread(
+                                                                                                 "remotehardware")
 {
 }
 
@@ -69,26 +70,26 @@ bool RemoteHardwarePlugin::handleReceivedProtobuf(const MeshPacket &req, const H
 
     case HardwareMessage_Type_READ_GPIOS: {
         // Print notification to LCD screen
-        if(screen)
+        if (screen)
             screen->print("Read GPIOs\n");
 
         uint64_t res = digitalReads(p.gpio_mask);
 
         // Send the reply
-        HardwareMessage reply = HardwareMessage_init_default;
-        reply.typ = HardwareMessage_Type_READ_GPIOS_REPLY;
-        reply.gpio_value = res;
-        MeshPacket *p = allocDataProtobuf(reply);
+        HardwareMessage r = HardwareMessage_init_default;
+        r.typ = HardwareMessage_Type_READ_GPIOS_REPLY;
+        r.gpio_value = res;
+        MeshPacket *p = allocDataProtobuf(r);
         setReplyTo(p, req);
-        service.sendToMesh(p);
+        myReply = p;
         break;
     }
 
     case HardwareMessage_Type_WATCH_GPIOS: {
         watchGpios = p.gpio_mask;
-        lastWatchMsec = 0; // Force a new publish soon
+        lastWatchMsec = 0;           // Force a new publish soon
         previousWatch = ~watchGpios; // generate a 'previous' value which is guaranteed to not match (to force an initial publish)
-        enabled = true; // Let our thread run at least once
+        enabled = true;              // Let our thread run at least once
         DEBUG_MSG("Now watching GPIOs 0x%llx\n", watchGpios);
         break;
     }
@@ -101,31 +102,31 @@ bool RemoteHardwarePlugin::handleReceivedProtobuf(const MeshPacket &req, const H
         DEBUG_MSG("Hardware operation %d not yet implemented! FIXME\n", p.typ);
         break;
     }
-    
-    return true; // handled
+
+    return false;
 }
 
-int32_t RemoteHardwarePlugin::runOnce() {
-    if(watchGpios) {
+int32_t RemoteHardwarePlugin::runOnce()
+{
+    if (watchGpios) {
         uint32_t now = millis();
 
-        if(now - lastWatchMsec >= WATCH_INTERVAL_MSEC) {
+        if (now - lastWatchMsec >= WATCH_INTERVAL_MSEC) {
             uint64_t curVal = digitalReads(watchGpios);
 
-            if(curVal != previousWatch) {
+            if (curVal != previousWatch) {
                 previousWatch = curVal;
                 DEBUG_MSG("Broadcasting GPIOS 0x%llx changed!\n", curVal);
 
                 // Something changed!  Tell the world with a broadcast message
-                HardwareMessage reply = HardwareMessage_init_default;
-                reply.typ = HardwareMessage_Type_GPIOS_CHANGED;
-                reply.gpio_value = curVal;
-                MeshPacket *p = allocDataProtobuf(reply);
+                HardwareMessage r = HardwareMessage_init_default;
+                r.typ = HardwareMessage_Type_GPIOS_CHANGED;
+                r.gpio_value = curVal;
+                MeshPacket *p = allocDataProtobuf(r);
                 service.sendToMesh(p);
             }
         }
-    }
-    else {
+    } else {
         // No longer watching anything - stop using CPU
         enabled = false;
     }

src/plugins/RoutingPlugin.cpp

@@ -18,17 +18,16 @@ bool RoutingPlugin::handleReceivedProtobuf(const MeshPacket &mp, const Routing *
         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) {
+    if (currentRequest->decoded.portnum == PortNum_ROUTING_APP) {
         assert(0); // 1.2 refactoring fixme, Not sure if anything needs this yet?
         // return allocDataProtobuf(u);
     }
@@ -37,26 +36,12 @@ MeshPacket *RoutingPlugin::allocReply()
 
 void RoutingPlugin::sendAckNak(Routing_Error err, NodeNum to, PacketId idFrom, ChannelIndex chIndex)
 {
-    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;
-    p->channel = chIndex;
-    DEBUG_MSG("Sending an err=%d,to=0x%x,idFrom=0x%x,id=0x%x\n", err, to, idFrom, p->id);
+    auto p = allocAckNak(err, to, idFrom, chIndex);
 
     router->sendLocal(p); // we sometimes send directly to the local node
 }
 
-RoutingPlugin::RoutingPlugin()
-    : ProtobufPlugin("routing", PortNum_ROUTING_APP, Routing_fields)
+RoutingPlugin::RoutingPlugin() : ProtobufPlugin("routing", PortNum_ROUTING_APP, Routing_fields)
 {
     isPromiscuous = true;
 }
-
-

src/plugins/SerialPlugin.cpp

@@ -186,9 +186,19 @@ bool SerialPluginRadio::handleReceived(const MeshPacket &mp)
             }
 
         } else {
-            // DEBUG_MSG("* * Message came from the mesh\n");
-            // Serial2.println("* * Message came from the mesh");
-            Serial2.printf("%s", p.payload.bytes);
+
+            if (radioConfig.preferences.serialplugin_mode == 0 || radioConfig.preferences.serialplugin_mode == 1) {
+                // DEBUG_MSG("* * Message came from the mesh\n");
+                // Serial2.println("* * Message came from the mesh");
+                Serial2.printf("%s", p.payload.bytes);
+
+            } else if (radioConfig.preferences.serialplugin_mode == 10) {
+                /*
+                 @jobionekabnoi
+                    Add code here to handle what gets sent out to the serial interface.
+                    Format it the way you want.
+                 */
+            }
         }
 
     } else {

src/plugins/esp32/RangeTestPlugin.cpp

@@ -35,9 +35,9 @@ int32_t RangeTestPlugin::runOnce()
         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;
+    // 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;
@@ -112,7 +112,7 @@ void RangeTestPluginRadio::sendPayload(NodeNum dest, bool wantReplies)
     packetSequence++;
 
     static char heartbeatString[20];
-    snprintf(heartbeatString, sizeof(heartbeatString), "seq %d", packetSequence);
+    snprintf(heartbeatString, sizeof(heartbeatString), "seq %u", 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);
@@ -255,7 +255,9 @@ bool RangeTestPluginRadio::appendFile(const MeshPacket &mp)
             return 0;
         }
 
-        if (fileToWrite.println("time,from,sender name,sender lat,sender long,rx lat,rx long,rx snr,distance,payload")) {
+        // Print the CSV header
+        if (fileToWrite.println(
+                "time,from,sender name,sender lat,sender long,rx lat,rx long,rx snr,rx elevation,distance,payload")) {
             DEBUG_MSG("File was written\n");
         } else {
             DEBUG_MSG("File write failed\n");
@@ -290,13 +292,15 @@ bool RangeTestPluginRadio::appendFile(const MeshPacket &mp)
         fileToAppend.printf("??:??:??,"); // Time
     }
 
-    fileToAppend.printf("%d,", getFrom(&mp));                          // From
+    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
+    fileToAppend.printf("%d,", gpsStatus->getAltitude());         // RX Altitude
+
+    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,

src/plugins/esp32/StoreForwardPlugin.cpp

@@ -5,11 +5,13 @@
 #include "Router.h"
 #include "configuration.h"
 #include "mesh-pb-constants.h"
+#include "plugins/PluginDev.h"
 #include <Arduino.h>
 #include <map>
 
 #define STOREFORWARD_MAX_PACKETS 0
-#define STOREFORWARD_SEND_HISTORY_SHORT 600
+#define STOREFORWARD_SEND_HISTORY_PERIOD 10 * 60
+#define STOREFORWARD_SEND_HISTORY_MAX 0
 
 StoreForwardPlugin *storeForwardPlugin;
 
@@ -22,9 +24,8 @@ int32_t StoreForwardPlugin::runOnce()
 
         if (radioConfig.preferences.is_router) {
             // Maybe some cleanup functions?
-            this->sawNodeReport();
             this->historyReport();
-            return (10 * 1000);
+            return (60 * 1000);
         } else {
             /*
              * If the plugin is turned on and is_router is not enabled, then we'll send a heartbeat every
@@ -64,14 +65,12 @@ void StoreForwardPlugin::populatePSRAM()
     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));
-
     // Use a maximum of half the available PSRAM unless otherwise specified.
     uint32_t numberOfPackets =
         STOREFORWARD_MAX_PACKETS ? STOREFORWARD_MAX_PACKETS : ((ESP.getPsramSize() / 2) / sizeof(PacketHistoryStruct));
 
-    this->packetHistory = (PacketHistoryStruct *)ps_calloc(numberOfPackets, sizeof(PacketHistoryStruct));
+    // this->packetHistory = (PacketHistoryStruct *)ps_calloc(numberOfPackets, sizeof(PacketHistoryStruct));
+    this->packetHistory = static_cast<PacketHistoryStruct *>(ps_calloc(numberOfPackets, sizeof(PacketHistoryStruct)));
     DEBUG_MSG("After PSRAM initilization:\n");
 
     DEBUG_MSG("  Total heap: %d\n", ESP.getHeapSize());
@@ -83,41 +82,17 @@ void StoreForwardPlugin::populatePSRAM()
 }
 
 // We saw a node.
-uint32_t StoreForwardPlugin::sawNode(uint32_t node)
+void StoreForwardPlugin::sawNode(uint32_t whoWeSaw, uint32_t sawSecAgo)
 {
+    if (radioConfig.preferences.is_router) {
 
-    /*
-    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;
+        // If node has been away for more than 10 minutes, send the node the last 10 minutes of
+        //   messages
+        if (sawSecAgo > STOREFORWARD_SEND_HISTORY_PERIOD) {
+            // Node has been away for a while.
+            storeForwardPlugin->historySend(STOREFORWARD_SEND_HISTORY_PERIOD, whoWeSaw);
         }
     }
-
-    return 0;
 }
 
 void StoreForwardPlugin::historyReport()
@@ -132,8 +107,15 @@ void StoreForwardPlugin::historyReport()
     }
     DEBUG_MSG("StoreForwardPlugin::historyReport runtime - %u ms\n", millis() - startTimer);
 }
+
+/*
+ *
+ */
 void StoreForwardPlugin::historySend(uint32_t msAgo, uint32_t to)
 {
+    // Send "Welcome back"
+    this->sendPayloadWelcome(to, false);
+
     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);
@@ -159,27 +141,6 @@ void StoreForwardPlugin::historyAdd(const MeshPacket *mp)
     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 *StoreForwardPlugin::allocReply()
 {
     auto reply = allocDataPacket(); // Allocate a packet for sending
@@ -194,8 +155,7 @@ void StoreForwardPlugin::sendPayload(NodeNum dest, bool wantReplies)
     p->decoded.want_response = wantReplies;
 
     p->want_ack = true;
-    /*
-     */
+
     static char heartbeatString[20];
     snprintf(heartbeatString, sizeof(heartbeatString), "1");
 
@@ -205,56 +165,50 @@ void StoreForwardPlugin::sendPayload(NodeNum dest, bool wantReplies)
     service.sendToMesh(p);
 }
 
+void StoreForwardPlugin::sendPayloadWelcome(NodeNum dest, bool wantReplies)
+{
+    DEBUG_MSG("*********************************\n");
+    DEBUG_MSG("*********************************\n");
+    DEBUG_MSG("*********************************\n");
+    DEBUG_MSG("Sending S&F Welcome Message\n");
+    DEBUG_MSG("*********************************\n");
+    DEBUG_MSG("*********************************\n");
+    DEBUG_MSG("*********************************\n");
+    MeshPacket *p = allocReply();
+    p->to = dest;
+    p->decoded.want_response = wantReplies;
+
+    p->want_ack = true;
+
+    p->decoded.portnum = PortNum_TEXT_MESSAGE_APP;
+
+    static char heartbeatString[80];
+    snprintf(heartbeatString, sizeof(heartbeatString), "Welcome back to the mesh. We have not seen you in x minutes!");
+
+    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);
+}
+
 bool StoreForwardPlugin::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);
+            // 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);
             DEBUG_MSG("    --------------   ");
-            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) {
+            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, mp.from);
-            }
         }
 
     } else {
@@ -272,44 +226,42 @@ StoreForwardPlugin::StoreForwardPlugin()
 
 #ifndef NO_ESP32
 
+    isPromiscuous = true; // Brown chicken brown cow
+
     /*
         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 (StoreForward_Dev) {
+        radioConfig.preferences.store_forward_plugin_enabled = 1;
+        radioConfig.preferences.is_router = 1;
+    }
+
     if (radioConfig.preferences.store_forward_plugin_enabled) {
+
+        // Router
         if (radioConfig.preferences.is_router) {
             DEBUG_MSG("Initializing Store & Forward Plugin - Enabled as Router\n");
-            // Router
             if (ESP.getPsramSize()) {
-                if (ESP.getFreePsram() >= 2048 * 1024) {
+                if (ESP.getFreePsram() >= 1024 * 1024) {
+
                     // Do the startup here
 
                     this->populatePSRAM();
-
-                    // packetHistory[0].bytes;
-                    // return (10 * 1000);
-
                 } else {
-                    DEBUG_MSG("Device has less than 2M of PSRAM free. Aborting startup.\n");
+                    DEBUG_MSG("Device has less than 1M 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);
             }
 
+            // Client
         } else {
             DEBUG_MSG("Initializing Store & Forward Plugin - Enabled as Client\n");
-            // return (5 * 1000);
         }
     }
 #endif

src/plugins/esp32/StoreForwardPlugin.h

@@ -29,8 +29,7 @@ class StoreForwardPlugin : public SinglePortPlugin, private concurrency::OSThrea
      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 sawNode(uint32_t whoWeSaw, uint32_t sawSecAgo);
     void historyAdd(const MeshPacket *mp);
     void historyReport();
     void historySend(uint32_t msAgo, uint32_t to);
@@ -40,6 +39,7 @@ class StoreForwardPlugin : public SinglePortPlugin, private concurrency::OSThrea
      * Send our payload into the mesh
      */
     void sendPayload(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
+    void sendPayloadWelcome(NodeNum dest = NODENUM_BROADCAST, bool wantReplies = false);
     virtual MeshPacket *allocReply();
     virtual bool wantPortnum(PortNum p) { return true; };
 
@@ -80,4 +80,3 @@ class StoreForwardPluginRadio : public SinglePortPlugin
 
 extern StoreForwardPluginRadio *storeForwardPluginRadio;
 */
-

src/portduino/PortduinoGlue.cpp

@@ -1,76 +1,61 @@
 #include "CryptoEngine.h"
-#include "target_specific.h"
 #include "PortduinoGPIO.h"
 #include "mesh/RF95Interface.h"
 #include "sleep.h"
+#include "target_specific.h"
 
 #include <Utility.h>
 #include <assert.h>
 
-// FIXME - move getMacAddr/setBluetoothEnable into a HALPlatform class
-
-uint32_t hwId; // fixme move into portduino
-
-void getMacAddr(uint8_t *dmac)
-{
-    if (!hwId) {
-        notImplemented("getMacAddr");
-        hwId = random();
-    }
-
-    dmac[0] = 0x80;
-    dmac[1] = 0;
-    dmac[2] = 0;
-    dmac[3] = hwId >> 16;
-    dmac[4] = hwId >> 8;
-    dmac[5] = hwId & 0xff;
-}
+// FIXME - move setBluetoothEnable into a HALPlatform class
 
 void setBluetoothEnable(bool on)
 {
     // not needed
 }
 
-void cpuDeepSleep(uint64_t msecs) {
+void cpuDeepSleep(uint64_t msecs)
+{
     notImplemented("cpuDeepSleep");
 }
 
 void updateBatteryLevel(uint8_t level) NOT_IMPLEMENTED("updateBatteryLevel");
 
 /** Dear pinetab hardware geeks!
- * 
+ *
  * The current pinetab lora module has a slight bug.  The ch341 part only provides ISR assertions on edges.
  * This makes sense because USB interrupts happen through fast/repeated special irq urbs that are constantly
  * chattering on the USB bus.
- * 
+ *
  * But this isn't sufficient for level triggered ISR sources like the sx127x radios.  The common way that seems to
  * be addressed by cs341 users is to **always** connect the INT# (pin 26 on the ch341f) signal to one of the GPIO signals
  * on the part.  I'd recommend connecting that LORA_DIO0/INT# line to pin 19 (data 4) on the pinetab board.  This would
  * provide an efficent mechanism so that the (kernel) code in the cs341 driver that I've slightly hacked up to see the
  * current state of LORA_DIO0.  Without that access, I can't know if the interrupt is still pending - which would create
- * race conditions in packet handling.  
- * 
+ * race conditions in packet handling.
+ *
  * My workaround is to poll the status register internally to the sx127x.  Which is expensive because it involves a number of
  * i2c transactions and many trips back and forth between kernel and my userspace app.  I think shipping the current version
  * of the pinetab lora device would be fine because I can poll slowly (because lora is slow).  But if you ever have cause to
  * rev this board.  I highly encourage this small change.
- * 
+ *
  * Btw - your little "USB lora dongle" is really neat.  I encourage you to sell it, because even non pinetab customers could
  * use it to easily add lora to rasberry pi, desktop pcs etc...
- * 
+ *
  * Porduino helper class to do this i2c based polling:
  */
-class R595PolledIrqPin : public GPIOPin {
-public:
+class R595PolledIrqPin : public GPIOPin
+{
+  public:
     R595PolledIrqPin() : GPIOPin(LORA_DIO0, "LORA_DIO0") {}
 
     /// Read the low level hardware for this pin
     virtual PinStatus readPinHardware()
     {
-        if(isrPinStatus < 0)
+        if (isrPinStatus < 0)
             return LOW; // No interrupt handler attached, don't bother polling i2c right now
         else {
-            extern RadioInterface *rIf; // FIXME, temporary hack until we know if we need to keep this 
+            extern RadioInterface *rIf; // FIXME, temporary hack until we know if we need to keep this
 
             assert(rIf);
             RF95Interface *rIf95 = static_cast<RF95Interface *>(rIf);
@@ -81,17 +66,17 @@ public:
     }
 };
 
-
-/** apps run under portduino can optionally define a portduinoSetup() to 
+/** apps run under portduino can optionally define a portduinoSetup() to
  * use portduino specific init code (such as gpioBind) to setup portduino on their host machine,
  * before running 'arduino' code.
  */
-void  portduinoSetup() {
-  printf("Setting up Meshtastic on Porduino...\n");
+void portduinoSetup()
+{
+    printf("Setting up Meshtastic on Porduino...\n");
 
-  // FIXME: disable while not testing with real hardware
-  // gpioBind(new R595PolledIrqPin());
+    // FIXME: disable while not testing with real hardware
+    // gpioBind(new R595PolledIrqPin());
 
-  // gpioBind((new SimGPIOPin(LORA_RESET, "LORA_RESET")));
-  // gpioBind((new SimGPIOPin(RF95_NSS, "RF95_NSS"))->setSilent());
+    // gpioBind((new SimGPIOPin(LORA_RESET, "LORA_RESET")));
+    // gpioBind((new SimGPIOPin(RF95_NSS, "RF95_NSS"))->setSilent());
 }