Merge pull request #127 from geeksville/nema-124

0.6.3 - fix the problem of BLE message receiption being busted in 0.6.2

.gitignore

@@ -6,6 +6,5 @@ main/credentials.h
 .vscode/*
 !.vscode/settings.json
 !.vscode/tasks.json
-!.vscode/launch.json
 !.vscode/extensions.json
 *.code-workspace

.vscode/launch.json

@@ -1,32 +0,0 @@
-// AUTOMATICALLY GENERATED FILE. PLEASE DO NOT MODIFY IT MANUALLY
-
-// PIO Unified Debugger
-//
-// Documentation: https://docs.platformio.org/page/plus/debugging.html
-// Configuration: https://docs.platformio.org/page/projectconf/section_env_debug.html
-
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "platformio-debug",
-            "request": "launch",
-            "name": "PIO Debug",
-            "executable": "/home/kevinh/development/meshtastic/meshtastic-esp32/.pio/build/tbeam/firmware.elf",
-            "toolchainBinDir": "/home/kevinh/.platformio/packages/toolchain-xtensa32/bin",
-            "preLaunchTask": {
-                "type": "PlatformIO",
-                "task": "Pre-Debug"
-            },
-            "internalConsoleOptions": "openOnSessionStart"
-        },
-        {
-            "type": "platformio-debug",
-            "request": "launch",
-            "name": "PIO Debug (skip Pre-Debug)",
-            "executable": "/home/kevinh/development/meshtastic/meshtastic-esp32/.pio/build/tbeam/firmware.elf",
-            "toolchainBinDir": "/home/kevinh/.platformio/packages/toolchain-xtensa32/bin",
-            "internalConsoleOptions": "openOnSessionStart"
-        }
-    ]
-}

.vscode/settings.json

@@ -50,7 +50,10 @@
         "cassert": "cpp"
     },
     "cSpell.words": [
+        "Blox",
         "Meshtastic",
+        "NEMAGPS",
+        "Ublox",
         "descs",
         "protobufs"
     ]

README.md

@@ -1,4 +1,4 @@
-# Meshtastic-esp32
+# Meshtastic-device
 
 This is the device side code for the [meshtastic.org](https://www.meshtastic.org) project.
 
@@ -143,15 +143,19 @@ Hard resetting via RTS pin...
 7. The board will boot and show the Meshtastic logo.
 8. Please post a comment on our chat so we know if these instructions worked for you ;-). If you find bugs/have-questions post there also - we will be rapidly iterating over the next few weeks.
 
-## Meshtastic Android app
+# Meshtastic Android app
 
 The source code for the (optional) Meshtastic Android app is [here](https://github.com/meshtastic/Meshtastic-Android).
 
-Alpha test builds are current available by opting into our alpha test group. See (www.meshtastic.org) for instructions.
+Alpha test builds available by opting into our alpha test group. See (www.meshtastic.org) for instructions.
 
-After our rate of change slows a bit, we will make beta builds available here (without needing to join the alphatest group):
+If you don't want to live on the 'bleeding edge' you can opt-in to the beta-test or use the released version:
 [![Download at https://play.google.com/store/apps/details?id=com.geeksville.mesh](https://play.google.com/intl/en_us/badges/static/images/badges/en_badge_web_generic.png)](https://play.google.com/store/apps/details?id=com.geeksville.mesh&referrer=utm_source%3Dgithub%26utm_medium%3Desp32-readme%26utm_campaign%3Dmeshtastic-esp32%2520readme%26anid%3Dadmob&pcampaignid=pcampaignidMKT-Other-global-all-co-prtnr-py-PartBadge-Mar2515-1)
 
+# Python API
+
+We offer a [python API](https://github.com/meshtastic/Meshtastic-python) that makes it easy to use these devices to provide mesh networking for your custom projects.
+
 # Development
 
 We'd love to have you join us on this merry little project. Please see our [development documents](./docs/software/sw-design.md) and [join us in our discussion forum](https://meshtastic.discourse.group/).

bin/build-all.sh

@@ -6,6 +6,10 @@ source bin/version.sh
 
 COUNTRIES="US EU433 EU865 CN JP"
 #COUNTRIES=US
+#COUNTRIES=CN
+
+BOARDS="ttgo-lora32-v2 ttgo-lora32-v1 tbeam heltec"
+#BOARDS=tbeam
 
 OUTDIR=release/latest
 
@@ -24,23 +28,24 @@ function do_build {
     SRCBIN=.pio/build/$ENV_NAME/firmware.bin
     SRCELF=.pio/build/$ENV_NAME/firmware.elf
     rm -f $SRCBIN 
-    pio run --environment $ENV_NAME # -v
+
+    # The shell vars the build tool expects to find
+    export HW_VERSION="1.0-$COUNTRY"
+    export APP_VERSION=$VERSION
+    export COUNTRY
+
+    pio run --jobs 4 --environment $ENV_NAME # -v
     cp $SRCBIN $OUTDIR/bins/firmware-$ENV_NAME-$COUNTRY-$VERSION.bin
     cp $SRCELF $OUTDIR/elfs/firmware-$ENV_NAME-$COUNTRY-$VERSION.elf
 }
 
+# Important to pull latest version of libs into all device flavors, otherwise some devices might be stale
+platformio lib update 
+
 for COUNTRY in $COUNTRIES; do 
-
-    HWVERSTR="1.0-$COUNTRY"
-    COMMONOPTS="-DAPP_VERSION=$VERSION -DHW_VERSION_$COUNTRY -DHW_VERSION=$HWVERSTR -Wall -Wextra -Wno-missing-field-initializers -Isrc -Os -DAXP_DEBUG_PORT=Serial"
-
-    export PLATFORMIO_BUILD_FLAGS="$COMMONOPTS"
-
-    #do_build "tbeam0.7"
-    do_build "ttgo-lora32-v2"
-    do_build "ttgo-lora32-v1"
-    do_build "tbeam"
-    do_build "heltec"
+    for BOARD in $BOARDS; do
+        do_build $BOARD
+    done
 done
 
 # keep the bins in archive also

bin/nrf52-console.sh

@@ -0,0 +1 @@
+JLinkRTTViewer

bin/regen-protos.sh

@@ -3,4 +3,4 @@
 echo "This script requires https://jpa.kapsi.fi/nanopb/download/ version 0.4.1"
 # the nanopb tool seems to require that the .options file be in the current directory!
 cd proto
-../../nanopb-0.4.1-linux-x86/generator-bin/protoc --nanopb_out=-v:../src -I=../proto mesh.proto
+../../nanopb-0.4.1-linux-x86/generator-bin/protoc --nanopb_out=-v:../src/mesh -I=../proto mesh.proto

bin/start-terminal0.sh

@@ -1 +1 @@
-pio device monitor -b 115200
+pio device monitor -b 921600

bin/start-terminal1.sh

@@ -1 +1 @@
-pio device monitor -p /dev/ttyUSB1 -b 115200
+pio device monitor -p /dev/ttyUSB1 -b 921600

bin/version.sh

@@ -1,3 +1,3 @@
 
 
-export VERSION=0.4.1
+export VERSION=0.6.3

boards/ppr.json

@@ -0,0 +1,46 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_PPR -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [["0x239A", "0x4403"]],
+    "usb_product": "PPR",
+    "mcu": "nrf52840",
+    "variant": "pca10056-rc-clock",
+    "variants_dir": "variants",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "onboard_tools": ["jlink"],
+    "svd_path": "nrf52840.svd"
+  },
+  "frameworks": ["arduino"],
+  "name": "Meshtastic PPR (Adafruit BSP)",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "jlink",
+    "protocols": ["jlink", "nrfjprog", "stlink"]
+  },
+  "url": "https://meshtastic.org/",
+  "vendor": "Othernet"
+}

docs/README.md

@@ -13,6 +13,7 @@ Note: Questions after reading this? See our new [forum](https://meshtastic.disco
 - Applications where closed source GPS communicators just won't cut it (it is easy to add features for glider pilots etc...)
 - Secure long-range communication within groups without depending on cellular providers
 - Finding your lost kids ;-)
+- Through our [python API](https://pypi.org/project/meshtastic/) use these inexpensive radios to easily add mesh networking to your own projects.
 
 [![Youtube video demo](desk-video-screenshot.png)](https://www.youtube.com/watch?v=WlNbMbVZlHI "Meshtastic early demo")
 
@@ -36,8 +37,10 @@ This software is 100% open source and developed by a group of hobbyist experimen
 
 # Updates
 
-Note: Updates are happening almost daily, only major updates are listed below. For more details see our chat, github releases or the Android alpha tester emails.
+Note: Updates are happening almost daily, only major updates are listed below. For more details see our forum.
 
+- 04/28/2020 - 0.6.0 [Python API](https://pypi.org/project/meshtastic/) released. Makes it easy to use meshtastic devices as "zero config / just works" mesh transport adapters for other projects.
+- 04/20/2020 - 0.4.3 Pretty solid now both for the android app and the device code. Many people have donated translations and code. Probably going to call it a beta soon.
 - 03/03/2020 - 0.0.9 of the Android app and device code is released. Still an alpha but fairly functional.
 - 02/25/2020 - 0.0.4 of the Android app is released. This is a very early alpha, see below to join the alpha-testers group.
 - 02/23/2020 - 0.0.4 release. Still very bleeding edge but much closer to the final power management, a charged T-BEAM should run for many days with this load. If you'd like to try it, we'd love your feedback. Click [here](https://github.com/meshtastic/Meshtastic-esp32/blob/master/README.md) for instructions.
@@ -45,11 +48,11 @@ Note: Updates are happening almost daily, only major updates are listed below. F
 
 ## Meshtastic Android app
 
-Once out of alpha the companion Android application will be released here:
+Our Android application is available here:
 
 [![Download at https://play.google.com/store/apps/details?id=com.geeksville.mesh](https://play.google.com/intl/en_us/badges/static/images/badges/en_badge_web_generic.png)](https://play.google.com/store/apps/details?id=com.geeksville.mesh&referrer=utm_source%3Dhomepage%26anid%3Dadmob)
 
-But if you want the bleeding edge app now, we'd love to have your help testing. Three steps to opt-in to the alpha- test:
+The link above will return older more stable releases. We would prefer if you join our alpha-test group, because the application is rapidly improving. Three steps to opt-in to the alpha- test:
 
 1. Join [this Google group](https://groups.google.com/forum/#!forum/meshtastic-alpha-testers) with the account you use in Google Play.
 2. Go to this [URL](https://play.google.com/apps/testing/com.geeksville.mesh) to opt-in to the alpha test.

docs/software/bluetooth-api.md

@@ -1,30 +1,30 @@
 # Bluetooth API
 
-The Bluetooth API is design to have only a few characteristics and most polymorphism comes from the flexible set of Google Protocol Buffers which are sent over the wire.  We use protocol buffers extensively both for the bluetooth API and for packets inside the mesh or when providing packets to other applications on the phone.
+The Bluetooth API is design to have only a few characteristics and most polymorphism comes from the flexible set of Google Protocol Buffers which are sent over the wire. We use protocol buffers extensively both for the bluetooth API and for packets inside the mesh or when providing packets to other applications on the phone.
 
 ## A note on MTU sizes
 
-This device will work with any MTU size, but it is highly recommended that you call your phone's "setMTU function to increase MTU to 512 bytes" as soon as you connect to a service.  This will dramatically improve performance when reading/writing packets.
+This device will work with any MTU size, but it is highly recommended that you call your phone's "setMTU function to increase MTU to 512 bytes" as soon as you connect to a service. This will dramatically improve performance when reading/writing packets.
 
 ## MeshBluetoothService
 
 This is the main bluetooth service for the device and provides the API your app should use to get information about the mesh, send packets or provision the radio.
 
-For a reference implementation of a client that uses this service see [RadioInterfaceService](https://github.com/meshtastic/Meshtastic-Android/blob/master/app/src/main/java/com/geeksville/mesh/service/RadioInterfaceService.kt).  Typical flow when 
+For a reference implementation of a client that uses this service see [RadioInterfaceService](https://github.com/meshtastic/Meshtastic-Android/blob/master/app/src/main/java/com/geeksville/mesh/service/RadioInterfaceService.kt). Typical flow when
 a phone connects to the device should be the following:
 
-* SetMTU size to 512
-* Read a RadioConfig from "radio" - used to get the channel and radio settings
-* Read (and write if incorrect) a User from "user" - to get the username for this node
-* Read a MyNodeInfo from "mynode" to get information about this local device
-* Write an empty record to "nodeinfo" to restart the nodeinfo reading state machine
-* Read from "nodeinfo" until it returns empty to build the phone's copy of the current NodeDB for the mesh
-* Read from "fromradio" until it returns empty to get any messages that arrived for this node while the phone was away
-* Subscribe to notify on "fromnum" to get notified whenever the device has a new received packet
-* Read that new packet from "fromradio"
-* Whenever the phone has a packet to send write to "toradio"
+- SetMTU size to 512
+- Read a RadioConfig from "radio" - used to get the channel and radio settings
+- Read (and write if incorrect) a User from "user" - to get the username for this node
+- Read a MyNodeInfo from "mynode" to get information about this local device
+- Write an empty record to "nodeinfo" to restart the nodeinfo reading state machine
+- Read from "nodeinfo" until it returns empty to build the phone's copy of the current NodeDB for the mesh
+- Read from "fromradio" until it returns empty to get any messages that arrived for this node while the phone was away
+- Subscribe to notify on "fromnum" to get notified whenever the device has a new received packet
+- Read that new packet from "fromradio"
+- Whenever the phone has a packet to send write to "toradio"
 
-For definitions (and documentation) on FromRadio, ToRadio, MyNodeInfo, NodeInfo and User  protocol buffers see [mesh.proto](https://github.com/meshtastic/Meshtastic-protobufs/blob/master/mesh.proto)
+For definitions (and documentation) on FromRadio, ToRadio, MyNodeInfo, NodeInfo and User protocol buffers see [mesh.proto](https://github.com/meshtastic/Meshtastic-protobufs/blob/master/mesh.proto)
 
 UUID for the service: 6ba1b218-15a8-461f-9fa8-5dcae273eafd
 
@@ -37,7 +37,7 @@ Description (including human readable name)
 8ba2bcc2-ee02-4a55-a531-c525c5e454d5
 read
 fromradio - contains a newly received FromRadio packet destined towards the phone (up to MAXPACKET bytes per packet).
-After reading the esp32 will put the next packet in this mailbox.  If the FIFO is empty it will put an empty packet in this
+After reading the esp32 will put the next packet in this mailbox. If the FIFO is empty it will put an empty packet in this
 mailbox.
 
 f75c76d2-129e-4dad-a1dd-7866124401e7
@@ -49,34 +49,22 @@ read,notify,write
 fromnum - the current packet # in the message waiting inside fromradio, if the phone sees this notify it should read messages
 until it catches up with this number.
 
-The phone can write to this register to go backwards up to FIXME packets, to handle the rare case of a fromradio packet was dropped after the esp32 callback was called, but before it arrives at the phone.  If the phone writes to this register the esp32 will discard older packets and put the next packet >= fromnum in fromradio.
+The phone can write to this register to go backwards up to FIXME packets, to handle the rare case of a fromradio packet was dropped after the esp32 callback was called, but before it arrives at the phone. If the phone writes to this register the esp32 will discard older packets and put the next packet >= fromnum in fromradio.
 When the esp32 advances fromnum, it will delay doing the notify by 100ms, in the hopes that the notify will never actally need to be sent if the phone is already pulling from fromradio.
 
 Note: that if the phone ever sees this number decrease, it means the esp32 has rebooted.
 
-ea9f3f82-8dc4-4733-9452-1f6da28892a2
-read
-mynode - read this to access a MyNodeInfo protobuf
-
-d31e02e0-c8ab-4d3f-9cc9-0b8466bdabe8
-read, write
-nodeinfo - read this to get a series of NodeInfos (ending with a null empty record), write to this to restart the read statemachine that returns all the node infos
-
-b56786c8-839a-44a1-b98e-a1724c4a0262
-read,write
-radio - read/write this to access a RadioConfig protobuf
-
-6ff1d8b6-e2de-41e3-8c0b-8fa384f64eb6
-read,write
-owner - read/write this to access a User protobuf
-
 Re: queue management
 Not all messages are kept in the fromradio queue (filtered based on SubPacket):
-* only the most recent Position and User messages for a particular node are kept
-* all Data SubPackets are kept
-* No WantNodeNum / DenyNodeNum messages are kept
-A variable keepAllPackets, if set to true will suppress this behavior and instead keep everything for forwarding to the phone (for debugging)
 
+- only the most recent Position and User messages for a particular node are kept
+- all Data SubPackets are kept
+- No WantNodeNum / DenyNodeNum messages are kept
+  A variable keepAllPackets, if set to true will suppress this behavior and instead keep everything for forwarding to the phone (for debugging)
+
+## Protobuf API
+
+On connect, you should send a want_config_id protobuf to the device. This will cause the device to send its node DB and radio config via the fromradio endpoint. After sending the full DB, the radio will send a want_config_id to indicate it is done sending the configuration.
 
 ## Other bluetooth services
 
@@ -85,21 +73,21 @@ provided by the device.
 
 ### BluetoothSoftwareUpdate
 
-The software update service.  For a sample function that performs a software update using this API see [startUpdate](https://github.com/meshtastic/Meshtastic-Android/blob/master/app/src/main/java/com/geeksville/mesh/service/SoftwareUpdateService.kt).
+The software update service. For a sample function that performs a software update using this API see [startUpdate](https://github.com/meshtastic/Meshtastic-Android/blob/master/app/src/main/java/com/geeksville/mesh/service/SoftwareUpdateService.kt).
 
 SoftwareUpdateService UUID cb0b9a0b-a84c-4c0d-bdbb-442e3144ee30
 
 Characteristics
 
-| UUID                                 | properties       | description|
-|--------------------------------------|------------------|------------|
-| e74dd9c0-a301-4a6f-95a1-f0e1dbea8e1e | write,read       | total image size, 32 bit, write this first, then read read back to see if it was acceptable (0 mean not accepted) |
-| e272ebac-d463-4b98-bc84-5cc1a39ee517 | write            | data, variable sized, recommended 512 bytes, write one for each block of file |
-| 4826129c-c22a-43a3-b066-ce8f0d5bacc6 | write            | crc32, write last - writing this will complete the OTA operation, now you can read result |
-| 5e134862-7411-4424-ac4a-210937432c77 | read,notify      | result code, readable but will notify when the OTA operation completes |
-| GATT_UUID_SW_VERSION_STR/0x2a28 | read | We also implement these standard GATT entries because SW update probably needs them: |
-| GATT_UUID_MANU_NAME/0x2a29 | read | |
-| GATT_UUID_HW_VERSION_STR/0x2a27 | read | |
+| UUID                                 | properties  | description                                                                                                       |
+| ------------------------------------ | ----------- | ----------------------------------------------------------------------------------------------------------------- |
+| e74dd9c0-a301-4a6f-95a1-f0e1dbea8e1e | write,read  | total image size, 32 bit, write this first, then read read back to see if it was acceptable (0 mean not accepted) |
+| e272ebac-d463-4b98-bc84-5cc1a39ee517 | write       | data, variable sized, recommended 512 bytes, write one for each block of file                                     |
+| 4826129c-c22a-43a3-b066-ce8f0d5bacc6 | write       | crc32, write last - writing this will complete the OTA operation, now you can read result                         |
+| 5e134862-7411-4424-ac4a-210937432c77 | read,notify | result code, readable but will notify when the OTA operation completes                                            |
+| GATT_UUID_SW_VERSION_STR/0x2a28      | read        | We also implement these standard GATT entries because SW update probably needs them:                              |
+| GATT_UUID_MANU_NAME/0x2a29           | read        |                                                                                                                   |
+| GATT_UUID_HW_VERSION_STR/0x2a27      | read        |                                                                                                                   |
 
 ### DeviceInformationService
 

docs/software/nrf52-TODO.md

@@ -0,0 +1,157 @@
+# NRF52 TODO
+
+## Initial work items
+
+Minimum items needed to make sure hardware is good.
+
+- add a hard fault handler
+- use "variants" to get all gpio bindings
+- plug in correct variants for the real board
+- Use the PMU driver on real hardware
+- Use new radio driver on real hardware
+- Use UC1701 LCD driver on real hardware. Still need to create at startup and probe on SPI
+- test the LEDs
+- test the buttons
+- make a new boarddef with a variant.h file. Fix pins in that file. In particular (at least):
+  #define PIN_SPI_MISO (46)
+  #define PIN_SPI_MOSI (45)
+  #define PIN_SPI_SCK (47)
+  #define PIN_WIRE_SDA (26)
+  #define PIN_WIRE_SCL (27)
+
+## Secondary work items
+
+Needed to be fully functional at least at the same level of the ESP32 boards. At this point users would probably want them.
+
+- stop polling for GPS characters, instead stay blocked on read in a thread
+- increase preamble length? - will break other clients? so all devices must update
+- enable BLE DFU somehow
+- set appversion/hwversion
+- report appversion/hwversion in BLE
+- use new LCD driver from screen.cpp. Still need to hook it to a subclass of (poorly named) OLEDDisplay, and override display() to stream bytes out to the screen.
+- get full BLE api working
+- we need to enable the external xtal for the sx1262 (on dio3)
+- figure out which regulator mode the sx1262 is operating in
+- turn on security for BLE, make pairing work
+- make power management/sleep work properly
+- make a settimeofday implementation
+- make a file system implementation (preferably one that can see the files the bootloader also sees) - use https://infocenter.nordicsemi.com/topic/com.nordic.infocenter.sdk5.v15.3.0/lib_fds_usage.html?cp=7_5_0_3_55_3
+- make ble endpoints not require "start config", just have them start in config mode
+- measure power management and confirm battery life
+- use new PMU to provide battery voltage/% full to app (both bluetooth and screen)
+- do initial power measurements
+
+## Items to be 'feature complete'
+
+- use SX126x::startReceiveDutyCycleAuto to save power by sleeping and briefly waking to check for preamble bits. Change xmit rules to have more preamble bits.
+- turn back on in-radio destaddr checking for RF95
+- remove the MeshRadio wrapper - we don't need it anymore, just do everythin in RadioInterface subclasses.
+- figure out what the correct current limit should be for the sx1262, currently we just use the default 100
+- put sx1262 in sleepmode when processor gets shutdown (or rebooted), ideally even for critical faults (to keep power draw low). repurpose deepsleep state for this.
+- good power management tips: https://devzone.nordicsemi.com/nordic/nordic-blog/b/blog/posts/optimizing-power-on-nrf52-designs
+- call PMU set_ADC_CONV(0) during sleep, to stop reading PMU adcs and decrease current draw
+- do final power measurements
+- backport the common PMU API between AXP192 and PmuBQ25703A
+- use the new buttons in the UX
+- currently using soft device SD140, is that ideal?
+- turn on the watchdog timer, require servicing from key application threads
+- install a hardfault handler for null ptrs (if one isn't already installed)
+- nrf52setup should call randomSeed(tbd)
+
+## Things to do 'someday'
+
+Nice ideas worth considering someday...
+
+- make/find a multithread safe debug logging class (include remote logging and timestamps and levels). make each log event atomic.
+- turn on freertos stack size checking
+- Currently we use Nordic's vendor ID, which is apparently okay: https://devzone.nordicsemi.com/f/nordic-q-a/44014/using-nordic-vid-and-pid-for-nrf52840 and I just picked a PID of 0x4403
+- Use NRF logger module (includes flash logging etc...) instead of DEBUG_MSG
+- Use "LED softblink" library on NRF52 to do nice pretty "breathing" LEDs. Don't whack LED from main thread anymore.
+- decrease BLE xmit power "At 0dBm with the DC/DC on, the nRF52832 transmitter draws 5.3mA. Increasing the TX power to +4dBm adds only 2.2mA. Decreasing it to -40 dBm saves only 2.6mA."
+- in addition to the main CPU watchdog, use the PMU watchdog as a really big emergency hammer
+- turn on 'shipping mode' in the PMU when device is 'off' - to cut battery draw to essentially zero
+- make Lorro_BQ25703A read/write operations atomic, current version could let other threads sneak in (once we start using threads)
+- turn on DFU assistance in the appload using the nordic DFU helper lib call
+- make the segger logbuffer larger, move it to RAM that is preserved across reboots and support reading it out at runtime (to allow full log messages to be included in crash reports). Share this code with ESP32 (use gcc noinit attribute)
+- convert hardfaults/panics/asserts/wd exceptions into fault codes sent to phone
+- stop enumerating all i2c devices at boot, it wastes power & time
+- consider using "SYSTEMOFF" deep sleep mode, without RAM retension. Only useful for 'truly off - wake only by button press' only saves 1.5uA vs SYSTEMON. (SYSTEMON only costs 1.5uA). Possibly put PMU into shipping mode?
+
+## Old unorganized notes
+
+## Notes on PCA10059 Dongle
+
+- docs: https://infocenter.nordicsemi.com/pdf/nRF52840_Dongle_User_Guide_v1.0.pdf
+
+- Currently using Nordic PCA10059 Dongle hardware
+- https://community.platformio.org/t/same-bootloader-same-softdevice-different-board-different-pins/11411/9
+
+## Done
+
+- DONE add "DFU trigger library" to application load
+- DONE: using this: Possibly use this bootloader? https://github.com/adafruit/Adafruit_nRF52_Bootloader
+- DONE select and install a bootloader (adafruit)
+- DONE get old radio driver working on NRF52
+- DONE basic test of BLE
+- DONE get a debug 'serial' console working via the ICE passthrough feature
+- DONE switch to RadioLab? test it with current radio. https://github.com/jgromes/RadioLib
+- DONE change rx95 to radiolib
+- DONE track rxbad, rxgood, txgood
+- DONE neg 7 error code from receive
+- DONE remove unused sx1262 lib from github
+- at boot we are starting our message IDs at 1, rather we should start them at a random number. also, seed random based on timer. this could be the cause of our first message not seen bug.
+- add a NEMA based GPS driver to test GPS
+
+```
+
+/*
+per
+https://docs.platformio.org/en/latest/tutorials/nordicnrf52/arduino_debugging_unit_testing.html
+
+ardunino github is here https://github.com/sandeepmistry/arduino-nRF5
+devboard hw docs here:
+https://infocenter.nordicsemi.com/topic/ug_nrf52840_dk/UG/nrf52840_DK/hw_buttons_leds.html?cp=4_0_4_7_6
+
+https://docs.platformio.org/en/latest/boards/nordicnrf52/nrf52840_dk_adafruit.html
+
+must install adafruit bootloader first!
+https://learn.adafruit.com/circuitpython-on-the-nrf52/nrf52840-bootloader
+see link above and turn off jlink filesystem if we see unreliable serial comms
+over USBCDC
+
+adafruit bootloader install commands (from their readme)
+kevinh@kevin-server:~/.platformio/packages/framework-arduinoadafruitnrf52/bootloader$
+nrfjprog -e -f nrf52 Erasing user available code and UICR flash areas. Applying
+system reset.
+kevinh@kevin-server:~/.platformio/packages/framework-arduinoadafruitnrf52/bootloader$
+nrfjprog --program pca10056/pca10056_bootloader-0.3.2_s140_6.1.1.hex -f nrf52
+Parsing hex file.
+Reading flash area to program to guarantee it is erased.
+Checking that the area to write is not protected.
+Programming device.
+kevinh@kevin-server:~/.platformio/packages/framework-arduinoadafruitnrf52/bootloader$
+nrfjprog --reset -f nrf52 Applying system reset. Run.
+
+install jlink tools from here:
+https://www.segger.com/downloads/jlink#J-LinkSoftwareAndDocumentationPack
+
+install nrf tools from here:
+https://www.nordicsemi.com/Software-and-tools/Development-Tools/nRF-Command-Line-Tools/Download#infotabs
+
+examples of turning off the loop call to save power:
+https://learn.adafruit.com/bluefruit-nrf52-feather-learning-guide/advertising-beacon
+
+example of a more complex BLE service:
+https://learn.adafruit.com/bluefruit-nrf52-feather-learning-guide/custom-hrm
+*/
+
+// See g_ADigitalPinMap to see how arduino maps to the real gpio#s - and all in
+// P0
+#define LED1 14
+#define LED2 13
+
+/*
+good led ble demo:
+https://github.com/adafruit/Adafruit_nRF52_Arduino/blob/master/libraries/Bluefruit52Lib/examples/Peripheral/nrf_blinky/nrf_blinky.ino
+*/
+```

docs/software/power.md

@@ -4,34 +4,35 @@ i.e. sleep behavior
 
 ## Power measurements
 
-Since one of the main goals of this project is long battery life, it is important to consider that in our software/protocol design.  Based on initial measurements it seems that the current code should run about three days between charging, and with a bit more software work (see the [TODO list](TODO.md)) a battery life of eight days should be quite doable.  Our current power measurements/model is in [this spreadsheet](https://docs.google.com/spreadsheets/d/1ft1bS3iXqFKU8SApU8ZLTq9r7QQEGESYnVgdtvdT67k/edit?usp=sharing).
+Since one of the main goals of this project is long battery life, it is important to consider that in our software/protocol design. Based on initial measurements it seems that the current code should run about three days between charging, and with a bit more software work (see the [TODO list](TODO.md)) a battery life of eight days should be quite doable. Our current power measurements/model is in [this spreadsheet](https://docs.google.com/spreadsheets/d/1ft1bS3iXqFKU8SApU8ZLTq9r7QQEGESYnVgdtvdT67k/edit?usp=sharing).
 
 ## States
 
 From lower to higher power consumption.
 
-* Super-deep-sleep (SDS) - everything is off, CPU, radio, bluetooth, GPS.  Only wakes due to timer or button press.  We enter this mode only after no radio comms for a few hours, used to put the device into what is effectively "off" mode.
+- Super-deep-sleep (SDS) - everything is off, CPU, radio, bluetooth, GPS. Only wakes due to timer or button press. We enter this mode only after no radio comms for a few hours, used to put the device into what is effectively "off" mode.
   onEntry: setBluetoothOn(false), call doDeepSleep
   onExit: (standard bootup code, starts in DARK)
 
-* deep-sleep (DS) - CPU is off, radio is on, bluetooth and GPS is off.  Note: This mode is never used currently, because it only saves 1.5mA vs light-sleep
+- deep-sleep (DS) - CPU is off, radio is on, bluetooth and GPS is off. Note: This mode is never used currently, because it only saves 1.5mA vs light-sleep
   (Not currently used)
 
-* light-sleep (LS) - CPU is suspended (RAM stays alive), radio is on, bluetooth is off, GPS is off.  Note: currently GPS is not turned 
-off during light sleep, but there is a TODO item to fix this.
-  onEntry: setBluetoothOn(false), setGPSPower(false), doLightSleep()
+- light-sleep (LS) - CPU is suspended (RAM stays alive), radio is on, bluetooth is off, GPS is off. Note: currently GPS is not turned
+  off during light sleep, but there is a TODO item to fix this.
+  NOTE: On NRF52 platforms (because CPU current draw is so low), light-sleep state is never used.  
+   onEntry: setBluetoothOn(false), setGPSPower(false), doLightSleep()
   onIdle: (if we wake because our led blink timer has expired) blink the led then go back to sleep until we sleep for ls_secs
   onExit: setGPSPower(true), start trying to get gps lock: gps.startLock(), once lock arrives service.sendPosition(BROADCAST)
 
-* No bluetooth (NB) - CPU is running, radio is on, GPS is on but bluetooth is off, screen is off.
+- No bluetooth (NB) - CPU is running, radio is on, GPS is on but bluetooth is off, screen is off.
   onEntry: setBluetoothOn(false)
   onExit:
 
-* running dark (DARK) - Everything is on except screen
+- running dark (DARK) - Everything is on except screen
   onEntry: setBluetoothOn(true)
   onExit:
 
-* full on (ON) - Everything is on
+- full on (ON) - Everything is on
   onEntry: setBluetoothOn(true), screen.setOn(true)
   onExit: screen.setOn(false)
 
@@ -39,47 +40,47 @@ off during light sleep, but there is a TODO item to fix this.
 
 ### events that increase CPU activity
 
-* At cold boot: The initial state (after setup() has run) is DARK
-* While in DARK: if we receive EVENT_BOOT, transition to ON (and show the bootscreen).  This event will be sent if we detect we woke due to reset (as opposed to deep sleep)
-* While in LS: Once every position_broadcast_secs (default 15 mins) - the unit will wake into DARK mode and broadcast a "networkPing" (our position) and stay alive for wait_bluetooth_secs (default 30 seconds).  This allows other nodes to have a record of our last known position if we go away and allows a paired phone to hear from us and download messages.
-* While in LS: Every send_owner_interval (defaults to 4, i.e. one hour), when we wake to send our position we _also_ broadcast our owner.  This lets new nodes on the network find out about us or correct duplicate node number assignments.
-* While in LS/NB/DARK: If the user presses a button (EVENT_PRESS) we go to full ON mode for screen_on_secs (default 30 seconds).  Multiple presses keeps resetting this timeout
-* While in LS/NB/DARK: If we receive new text messages (EVENT_RECEIVED_TEXT_MSG), we go to full ON mode for screen_on_secs (same as if user pressed a button)
-* While in LS: while we receive packets on the radio (EVENT_RECEIVED_PACKET) we will wake and handle them and stay awake in NB mode for min_wake_secs (default 10 seconds) 
-* While in NB: If we do have packets the phone (EVENT_PACKETS_FOR_PHONE) would want we transition to DARK mode for wait_bluetooth secs.
-* While in DARK/ON: If we receive EVENT_BLUETOOTH_PAIR we transition to ON and start our screen_on_secs timeout
-* While in NB/DARK/ON: If we receive EVENT_NODEDB_UPDATED we transition to ON (so the new screen can be shown)
-* While in DARK: While the phone talks to us over BLE (EVENT_CONTACT_FROM_PHONE) reset any sleep timers and stay in DARK (needed for bluetooth sw update and nice user experience if the user is reading/replying to texts)
+- At cold boot: The initial state (after setup() has run) is DARK
+- While in DARK: if we receive EVENT_BOOT, transition to ON (and show the bootscreen). This event will be sent if we detect we woke due to reset (as opposed to deep sleep)
+- While in LS: Once every position_broadcast_secs (default 15 mins) - the unit will wake into DARK mode and broadcast a "networkPing" (our position) and stay alive for wait_bluetooth_secs (default 30 seconds). This allows other nodes to have a record of our last known position if we go away and allows a paired phone to hear from us and download messages.
+- While in LS: Every send*owner_interval (defaults to 4, i.e. one hour), when we wake to send our position we \_also* broadcast our owner. This lets new nodes on the network find out about us or correct duplicate node number assignments.
+- While in LS/NB/DARK: If the user presses a button (EVENT_PRESS) we go to full ON mode for screen_on_secs (default 30 seconds). Multiple presses keeps resetting this timeout
+- While in LS/NB/DARK: If we receive new text messages (EVENT_RECEIVED_TEXT_MSG), we go to full ON mode for screen_on_secs (same as if user pressed a button)
+- While in LS: while we receive packets on the radio (EVENT_RECEIVED_PACKET) we will wake and handle them and stay awake in NB mode for min_wake_secs (default 10 seconds)
+- While in NB: If we do have packets the phone (EVENT_PACKETS_FOR_PHONE) would want we transition to DARK mode for wait_bluetooth secs.
+- While in DARK/ON: If we receive EVENT_BLUETOOTH_PAIR we transition to ON and start our screen_on_secs timeout
+- While in NB/DARK/ON: If we receive EVENT_NODEDB_UPDATED we transition to ON (so the new screen can be shown)
+- While in DARK: While the phone talks to us over BLE (EVENT_CONTACT_FROM_PHONE) reset any sleep timers and stay in DARK (needed for bluetooth sw update and nice user experience if the user is reading/replying to texts)
 
 ### events that decrease cpu activity
 
-* While in ON: If PRESS event occurs, reset screen_on_secs timer and tell the screen to handle the pess
-* While in ON: If it has been more than screen_on_secs since a press, lower to DARK
-* While in DARK: If time since last contact by our phone exceeds phone_timeout_secs (15 minutes), we transition down into NB mode
-* While in DARK or NB: If nothing above is forcing us to stay in a higher mode (wait_bluetooth_secs, min_wake_secs) we will lower down to LS state
-* While in LS: If either phone_sds_timeout_secs (default 2 hr) or mesh_sds_timeout_secs (default 2 hr) are exceeded we will lower into SDS mode for sds_secs (default 1 yr) (or a button press).  (Note: phone_sds_timeout_secs is currently disabled for now, because most users 
-are using without a phone)
-* Any time we enter LS mode: We stay in that until an interrupt, button press or other state transition.  Every ls_secs (default 1 hr) and let the arduino loop() run one iteration (FIXME, not sure if we need this at all), and then immediately reenter lightsleep mode on the CPU.
+- While in ON: If PRESS event occurs, reset screen_on_secs timer and tell the screen to handle the pess
+- While in ON: If it has been more than screen_on_secs since a press, lower to DARK
+- While in DARK: If time since last contact by our phone exceeds phone_timeout_secs (15 minutes), we transition down into NB mode
+- While in DARK or NB: If nothing above is forcing us to stay in a higher mode (wait_bluetooth_secs, min_wake_secs) we will lower down to LS state
+- While in LS: If either phone_sds_timeout_secs (default 2 hr) or mesh_sds_timeout_secs (default 2 hr) are exceeded we will lower into SDS mode for sds_secs (default 1 yr) (or a button press). (Note: phone_sds_timeout_secs is currently disabled for now, because most users
+  are using without a phone)
+- Any time we enter LS mode: We stay in that until an interrupt, button press or other state transition. Every ls_secs (default 1 hr) and let the arduino loop() run one iteration (FIXME, not sure if we need this at all), and then immediately reenter lightsleep mode on the CPU.
 
 TODO: Eventually these scheduled intervals should be synchronized to the GPS clock, so that we can consider leaving the lora receiver off to save even more power.
 TODO: In NB mode we should put cpu into light sleep any time we really aren't that busy (without declaring LS state) - i.e. we should leave GPS on etc...
 
 # Low power consumption tasks
 
-General ideas to hit the power draws our spreadsheet predicts.  Do the easy ones before beta, the last 15% can be done after 1.0.
+General ideas to hit the power draws our spreadsheet predicts. Do the easy ones before beta, the last 15% can be done after 1.0.
 
-* don't even power on the gps until someone else wants our position, just stay in lora deep sleep until press or rxpacket (except for once an hour updates)
-* (possibly bad idea - better to have lora radio always listen - check spreadsheet) have every node wake at the same tick and do their position syncs then go back to deep sleep
-* lower BT announce interval to save battery
-* change to use RXcontinuous mode and config to drop packets with bad CRC (see section 6.4 of datasheet) - I think this is already the case
-* have mesh service run in a thread that stays blocked until a packet arrives from the RF95
-* platformio sdkconfig CONFIG_PM and turn on modem sleep mode
-* keep cpu 100% in deepsleep until irq from radio wakes it.  Then stay awake for 30 secs to attempt delivery to phone.  
-* use https://lastminuteengineers.com/esp32-sleep-modes-power-consumption/ association sleep pattern to save power - but see https://github.com/espressif/esp-idf/issues/2070 and https://esp32.com/viewtopic.php?f=13&t=12182 it seems with BLE on the 'easy' draw people are getting is 80mA
-* stop using loop() instead use a job queue and let cpu sleep
-* measure power consumption and calculate battery life assuming no deep sleep
-* do lowest sleep level possible where BT still works during normal sleeping, make sure cpu stays in that mode unless lora rx packet happens, bt rx packet happens or button press happens
-* optionally do lora messaging only during special scheduled intervals (unless nodes are told to go to low latency mode), then deep sleep except during those intervals - before implementing calculate what battery life would be with  this feature
-* see section 7.3 of https://cdn.sparkfun.com/assets/learn_tutorials/8/0/4/RFM95_96_97_98W.pdf and have hope radio wake only when a valid packet is received.  Possibly even wake the ESP32 from deep sleep via GPIO.
-* never enter deep sleep while connected to USB power (but still go to other low power modes)
-* when main cpu is idle (in loop), turn cpu clock rate down and/or activate special sleep modes.  We want almost everything shutdown until it gets an interrupt.
+- don't even power on the gps until someone else wants our position, just stay in lora deep sleep until press or rxpacket (except for once an hour updates)
+- (possibly bad idea - better to have lora radio always listen - check spreadsheet) have every node wake at the same tick and do their position syncs then go back to deep sleep
+- lower BT announce interval to save battery
+- change to use RXcontinuous mode and config to drop packets with bad CRC (see section 6.4 of datasheet) - I think this is already the case
+- have mesh service run in a thread that stays blocked until a packet arrives from the RF95
+- platformio sdkconfig CONFIG_PM and turn on modem sleep mode
+- keep cpu 100% in deepsleep until irq from radio wakes it. Then stay awake for 30 secs to attempt delivery to phone.
+- use https://lastminuteengineers.com/esp32-sleep-modes-power-consumption/ association sleep pattern to save power - but see https://github.com/espressif/esp-idf/issues/2070 and https://esp32.com/viewtopic.php?f=13&t=12182 it seems with BLE on the 'easy' draw people are getting is 80mA
+- stop using loop() instead use a job queue and let cpu sleep
+- measure power consumption and calculate battery life assuming no deep sleep
+- do lowest sleep level possible where BT still works during normal sleeping, make sure cpu stays in that mode unless lora rx packet happens, bt rx packet happens or button press happens
+- optionally do lora messaging only during special scheduled intervals (unless nodes are told to go to low latency mode), then deep sleep except during those intervals - before implementing calculate what battery life would be with this feature
+- see section 7.3 of https://cdn.sparkfun.com/assets/learn_tutorials/8/0/4/RFM95_96_97_98W.pdf and have hope radio wake only when a valid packet is received. Possibly even wake the ESP32 from deep sleep via GPIO.
+- never enter deep sleep while connected to USB power (but still go to other low power modes)
+- when main cpu is idle (in loop), turn cpu clock rate down and/or activate special sleep modes. We want almost everything shutdown until it gets an interrupt.

gdbinit

@@ -0,0 +1,6 @@
+# the jlink debugger seems to want a pause after reset before we tell it to start running
+define restart
+  monitor reset 
+  shell sleep 1
+  cont 
+end

lib/BluetoothOTA/src/BluetoothUtil.cpp

@@ -1,70 +1,68 @@
 #include "BluetoothUtil.h"
 #include "BluetoothSoftwareUpdate.h"
-#include <esp_gatt_defs.h>
-#include <BLE2902.h>
-#include <Arduino.h>
-#include <Update.h>
 #include "configuration.h"
+#include <Arduino.h>
+#include <BLE2902.h>
+#include <Update.h>
+#include <esp_gatt_defs.h>
 
 SimpleAllocator btPool;
 
 /**
  * Create standard device info service
  **/
-BLEService *createDeviceInfomationService(BLEServer *server, std::string hwVendor, std::string swVersion, std::string hwVersion = "")
+BLEService *createDeviceInfomationService(BLEServer *server, std::string hwVendor, std::string swVersion,
+                                          std::string hwVersion = "")
 {
-  BLEService *deviceInfoService = server->createService(BLEUUID((uint16_t)ESP_GATT_UUID_DEVICE_INFO_SVC));
+    BLEService *deviceInfoService = server->createService(BLEUUID((uint16_t)ESP_GATT_UUID_DEVICE_INFO_SVC));
 
-  BLECharacteristic *swC = new BLECharacteristic(BLEUUID((uint16_t)ESP_GATT_UUID_SW_VERSION_STR), BLECharacteristic::PROPERTY_READ);
-  BLECharacteristic *mfC = new BLECharacteristic(BLEUUID((uint16_t)ESP_GATT_UUID_MANU_NAME), BLECharacteristic::PROPERTY_READ);
-  // BLECharacteristic SerialNumberCharacteristic(BLEUUID((uint16_t) ESP_GATT_UUID_SERIAL_NUMBER_STR), BLECharacteristic::PROPERTY_READ);
+    BLECharacteristic *swC =
+        new BLECharacteristic(BLEUUID((uint16_t)ESP_GATT_UUID_SW_VERSION_STR), BLECharacteristic::PROPERTY_READ);
+    BLECharacteristic *mfC = new BLECharacteristic(BLEUUID((uint16_t)ESP_GATT_UUID_MANU_NAME), BLECharacteristic::PROPERTY_READ);
+    // BLECharacteristic SerialNumberCharacteristic(BLEUUID((uint16_t) ESP_GATT_UUID_SERIAL_NUMBER_STR),
+    // BLECharacteristic::PROPERTY_READ);
 
-  /*
-	 * Mandatory characteristic for device info service?
+    /*
+           * Mandatory characteristic for device info service?
 
-	BLECharacteristic *m_pnpCharacteristic = m_deviceInfoService->createCharacteristic(ESP_GATT_UUID_PNP_ID, BLECharacteristic::PROPERTY_READ);
+          BLECharacteristic *m_pnpCharacteristic = m_deviceInfoService->createCharacteristic(ESP_GATT_UUID_PNP_ID,
+      BLECharacteristic::PROPERTY_READ);
 
-    uint8_t sig, uint16_t vid, uint16_t pid, uint16_t version;
-	uint8_t pnp[] = { sig, (uint8_t) (vid >> 8), (uint8_t) vid, (uint8_t) (pid >> 8), (uint8_t) pid, (uint8_t) (version >> 8), (uint8_t) version };
-	m_pnpCharacteristic->setValue(pnp, sizeof(pnp));
-    */
-  swC->setValue(swVersion);
-  deviceInfoService->addCharacteristic(addBLECharacteristic(swC));
-  mfC->setValue(hwVendor);
-  deviceInfoService->addCharacteristic(addBLECharacteristic(mfC));
-  if (!hwVersion.empty())
-  {
-    BLECharacteristic *hwvC = new BLECharacteristic(BLEUUID((uint16_t)ESP_GATT_UUID_HW_VERSION_STR), BLECharacteristic::PROPERTY_READ);
-    hwvC->setValue(hwVersion);
-    deviceInfoService->addCharacteristic(addBLECharacteristic(hwvC));
-  }
-  //SerialNumberCharacteristic.setValue("FIXME");
-  //deviceInfoService->addCharacteristic(&SerialNumberCharacteristic);
+      uint8_t sig, uint16_t vid, uint16_t pid, uint16_t version;
+          uint8_t pnp[] = { sig, (uint8_t) (vid >> 8), (uint8_t) vid, (uint8_t) (pid >> 8), (uint8_t) pid, (uint8_t) (version >>
+      8), (uint8_t) version }; m_pnpCharacteristic->setValue(pnp, sizeof(pnp));
+      */
+    swC->setValue(swVersion);
+    deviceInfoService->addCharacteristic(addBLECharacteristic(swC));
+    mfC->setValue(hwVendor);
+    deviceInfoService->addCharacteristic(addBLECharacteristic(mfC));
+    if (!hwVersion.empty()) {
+        BLECharacteristic *hwvC =
+            new BLECharacteristic(BLEUUID((uint16_t)ESP_GATT_UUID_HW_VERSION_STR), BLECharacteristic::PROPERTY_READ);
+        hwvC->setValue(hwVersion);
+        deviceInfoService->addCharacteristic(addBLECharacteristic(hwvC));
+    }
+    // SerialNumberCharacteristic.setValue("FIXME");
+    // deviceInfoService->addCharacteristic(&SerialNumberCharacteristic);
 
-  // m_manufacturerCharacteristic = m_deviceInfoService->createCharacteristic((uint16_t) 0x2a29, BLECharacteristic::PROPERTY_READ);
-  // m_manufacturerCharacteristic->setValue(name);
+    // m_manufacturerCharacteristic = m_deviceInfoService->createCharacteristic((uint16_t) 0x2a29,
+    // BLECharacteristic::PROPERTY_READ); m_manufacturerCharacteristic->setValue(name);
 
-  /* add these later?
-    ESP_GATT_UUID_SYSTEM_ID
-    */
+    /* add these later?
+      ESP_GATT_UUID_SYSTEM_ID
+      */
 
-  // caller must call service->start();
-  return deviceInfoService;
+    // caller must call service->start();
+    return deviceInfoService;
 }
 
 bool _BLEClientConnected = false;
 
 class MyServerCallbacks : public BLEServerCallbacks
 {
-  void onConnect(BLEServer *pServer)
-  {
-    _BLEClientConnected = true;
-  };
+    void onConnect(BLEServer *pServer) { _BLEClientConnected = true; };
 
-  void onDisconnect(BLEServer *pServer)
-  {
-    _BLEClientConnected = false;
-  }
+    void onDisconnect(BLEServer *pServer) { _BLEClientConnected = false; }
 };
 
 #define MAX_DESCRIPTORS 32
@@ -78,34 +76,34 @@ static size_t numDescs;
 /// Add a characteristic that we will delete when we restart
 BLECharacteristic *addBLECharacteristic(BLECharacteristic *c)
 {
-  assert(numChars < MAX_CHARACTERISTICS);
-  chars[numChars++] = c;
-  return c;
+    assert(numChars < MAX_CHARACTERISTICS);
+    chars[numChars++] = c;
+    return c;
 }
 
 /// Add a characteristic that we will delete when we restart
 BLEDescriptor *addBLEDescriptor(BLEDescriptor *c)
 {
-  assert(numDescs < MAX_DESCRIPTORS);
-  descs[numDescs++] = c;
+    assert(numDescs < MAX_DESCRIPTORS);
+    descs[numDescs++] = c;
 
-  return c;
+    return c;
 }
 
 // Help routine to add a description to any BLECharacteristic and add it to the service
 // We default to require an encrypted BOND for all these these characterstics
 void addWithDesc(BLEService *service, BLECharacteristic *c, const char *description)
 {
-  c->setAccessPermissions(ESP_GATT_PERM_READ_ENCRYPTED | ESP_GATT_PERM_WRITE_ENCRYPTED);
+    c->setAccessPermissions(ESP_GATT_PERM_READ_ENCRYPTED | ESP_GATT_PERM_WRITE_ENCRYPTED);
 
-  BLEDescriptor *desc = new BLEDescriptor(BLEUUID((uint16_t)ESP_GATT_UUID_CHAR_DESCRIPTION), strlen(description) + 1);
-  assert(desc);
-  desc->setAccessPermissions(ESP_GATT_PERM_READ_ENCRYPTED | ESP_GATT_PERM_WRITE_ENCRYPTED);
-  desc->setValue(description);
-  c->addDescriptor(desc);
-  service->addCharacteristic(c);
-  addBLECharacteristic(c);
-  addBLEDescriptor(desc);
+    BLEDescriptor *desc = new BLEDescriptor(BLEUUID((uint16_t)ESP_GATT_UUID_CHAR_DESCRIPTION), strlen(description) + 1);
+    assert(desc);
+    desc->setAccessPermissions(ESP_GATT_PERM_READ_ENCRYPTED | ESP_GATT_PERM_WRITE_ENCRYPTED);
+    desc->setValue(description);
+    c->addDescriptor(desc);
+    service->addCharacteristic(c);
+    addBLECharacteristic(c);
+    addBLEDescriptor(desc);
 }
 
 static BLECharacteristic *batteryLevelC;
@@ -115,19 +113,20 @@ static BLECharacteristic *batteryLevelC;
  */
 BLEService *createBatteryService(BLEServer *server)
 {
-  // Create the BLE Service
-  BLEService *pBattery = server->createService(BLEUUID((uint16_t)0x180F));
+    // Create the BLE Service
+    BLEService *pBattery = server->createService(BLEUUID((uint16_t)0x180F));
 
-  batteryLevelC = new BLECharacteristic(BLEUUID((uint16_t)ESP_GATT_UUID_BATTERY_LEVEL), BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
+    batteryLevelC = new BLECharacteristic(BLEUUID((uint16_t)ESP_GATT_UUID_BATTERY_LEVEL),
+                                          BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
 
-  addWithDesc(pBattery, batteryLevelC, "Percentage 0 - 100");
-  batteryLevelC->addDescriptor(addBLEDescriptor(new BLE2902())); // Needed so clients can request notification
+    addWithDesc(pBattery, batteryLevelC, "Percentage 0 - 100");
+    batteryLevelC->addDescriptor(addBLEDescriptor(new BLE2902())); // Needed so clients can request notification
 
-  // I don't think we need to advertise this
-  // server->getAdvertising()->addServiceUUID(pBattery->getUUID());
-  pBattery->start();
+    // I don't think we need to advertise this
+    // server->getAdvertising()->addServiceUUID(pBattery->getUUID());
+    pBattery->start();
 
-  return pBattery;
+    return pBattery;
 }
 
 /**
@@ -136,87 +135,82 @@ BLEService *createBatteryService(BLEServer *server)
  */
 void updateBatteryLevel(uint8_t level)
 {
-  // Pretend to update battery levels - fixme do elsewhere
-  if (batteryLevelC)
-  {
-    batteryLevelC->setValue(&level, 1);
-    batteryLevelC->notify();
-  }
+    // Pretend to update battery levels - fixme do elsewhere
+    if (batteryLevelC) {
+        batteryLevelC->setValue(&level, 1);
+        batteryLevelC->notify();
+    }
 }
 
 void dumpCharacteristic(BLECharacteristic *c)
 {
-  std::string value = c->getValue();
+    std::string value = c->getValue();
 
-  if (value.length() > 0)
-  {
-    DEBUG_MSG("New value: ");
-    for (int i = 0; i < value.length(); i++)
-      DEBUG_MSG("%c", value[i]);
+    if (value.length() > 0) {
+        DEBUG_MSG("New value: ");
+        for (int i = 0; i < value.length(); i++)
+            DEBUG_MSG("%c", value[i]);
 
-    DEBUG_MSG("\n");
-  }
+        DEBUG_MSG("\n");
+    }
 }
 
 /** converting endianness pull out a 32 bit value */
 uint32_t getValue32(BLECharacteristic *c, uint32_t defaultValue)
 {
-  std::string value = c->getValue();
-  uint32_t r = defaultValue;
+    std::string value = c->getValue();
+    uint32_t r = defaultValue;
 
-  if (value.length() == 4)
-    r = value[0] | (value[1] << 8UL) | (value[2] << 16UL) | (value[3] << 24UL);
+    if (value.length() == 4)
+        r = value[0] | (value[1] << 8UL) | (value[2] << 16UL) | (value[3] << 24UL);
 
-  return r;
+    return r;
 }
 
 class MySecurity : public BLESecurityCallbacks
 {
- protected:
-  bool onConfirmPIN(uint32_t pin)
-  {
-    Serial.printf("onConfirmPIN %u\n", pin);
-    return false;
-  }
-
-  uint32_t onPassKeyRequest()
-  {
-    Serial.println("onPassKeyRequest");
-    return 123511; // not used
-  }
-
-  void onPassKeyNotify(uint32_t pass_key)
-  {
-    Serial.printf("onPassKeyNotify %u\n", pass_key);
-    startCb(pass_key);
-  }
-
-  bool onSecurityRequest()
-  {
-    Serial.println("onSecurityRequest");
-    return true;
-  }
-
-  void onAuthenticationComplete(esp_ble_auth_cmpl_t cmpl)
-  {
-    if (cmpl.success)
+  protected:
+    bool onConfirmPIN(uint32_t pin)
     {
-      uint16_t length;
-      esp_ble_gap_get_whitelist_size(&length);
-      Serial.printf(" onAuthenticationComplete -> success size: %d\n", length);
-    }
-    else
-    {
-      Serial.printf("onAuthenticationComplete -> fail %d\n", cmpl.fail_reason);
+        Serial.printf("onConfirmPIN %u\n", pin);
+        return false;
     }
 
-    // Remove our custom PIN request screen.
-    stopCb();
-  }
+    uint32_t onPassKeyRequest()
+    {
+        Serial.println("onPassKeyRequest");
+        return 123511; // not used
+    }
 
- public:
-  StartBluetoothPinScreenCallback startCb;
-  StopBluetoothPinScreenCallback stopCb;
+    void onPassKeyNotify(uint32_t pass_key)
+    {
+        Serial.printf("onPassKeyNotify %u\n", pass_key);
+        startCb(pass_key);
+    }
+
+    bool onSecurityRequest()
+    {
+        Serial.println("onSecurityRequest");
+        return true;
+    }
+
+    void onAuthenticationComplete(esp_ble_auth_cmpl_t cmpl)
+    {
+        if (cmpl.success) {
+            uint16_t length;
+            esp_ble_gap_get_whitelist_size(&length);
+            Serial.printf(" authenticated and connected to phone\n");
+        } else {
+            Serial.printf("phone authenticate failed %d\n", cmpl.fail_reason);
+        }
+
+        // Remove our custom PIN request screen.
+        stopCb();
+    }
+
+  public:
+    StartBluetoothPinScreenCallback startCb;
+    StopBluetoothPinScreenCallback stopCb;
 };
 
 BLEServer *pServer;
@@ -225,88 +219,88 @@ BLEService *pDevInfo, *pUpdate;
 
 void deinitBLE()
 {
-  assert(pServer);
+    assert(pServer);
 
-  pServer->getAdvertising()->stop();
+    pServer->getAdvertising()->stop();
 
-  destroyUpdateService();
+    destroyUpdateService();
 
-  pUpdate->stop();
-  pDevInfo->stop();
-  pUpdate->stop(); // we delete them below
+    pUpdate->stop();
+    pDevInfo->stop();
+    pUpdate->stop(); // we delete them below
 
-  // First shutdown bluetooth
-  BLEDevice::deinit(false);
+    // First shutdown bluetooth
+    BLEDevice::deinit(false);
 
-  // do not delete this - it is dynamically allocated, but only once - statically in BLEDevice
-  // delete pServer->getAdvertising();
+    // do not delete this - it is dynamically allocated, but only once - statically in BLEDevice
+    // delete pServer->getAdvertising();
 
-  delete pUpdate;
-  delete pDevInfo;
-  delete pServer;
+    delete pUpdate;
+    delete pDevInfo;
+    delete pServer;
 
-  batteryLevelC = NULL; // Don't let anyone generate bogus notifies
+    batteryLevelC = NULL; // Don't let anyone generate bogus notifies
 
-  for (int i = 0; i < numChars; i++)
-    delete chars[i];
-  numChars = 0;
+    for (int i = 0; i < numChars; i++)
+        delete chars[i];
+    numChars = 0;
 
-  for (int i = 0; i < numDescs; i++)
-    delete descs[i];
-  numDescs = 0;
+    for (int i = 0; i < numDescs; i++)
+        delete descs[i];
+    numDescs = 0;
 
-  btPool.reset();
+    btPool.reset();
 }
 
-BLEServer *initBLE(
-    StartBluetoothPinScreenCallback startBtPinScreen,
-    StopBluetoothPinScreenCallback stopBtPinScreen,
-    std::string deviceName, std::string hwVendor, std::string swVersion, std::string hwVersion)
+BLEServer *initBLE(StartBluetoothPinScreenCallback startBtPinScreen, StopBluetoothPinScreenCallback stopBtPinScreen,
+                   std::string deviceName, std::string hwVendor, std::string swVersion, std::string hwVersion)
 {
-  BLEDevice::init(deviceName);
-  BLEDevice::setEncryptionLevel(ESP_BLE_SEC_ENCRYPT);
+    BLEDevice::init(deviceName);
+    BLEDevice::setEncryptionLevel(ESP_BLE_SEC_ENCRYPT);
 
-  /*
-   * Required in authentication process to provide displaying and/or input passkey or yes/no butttons confirmation
-   */
-  static MySecurity mySecurity;
-  mySecurity.startCb = startBtPinScreen;
-  mySecurity.stopCb = stopBtPinScreen;
-  BLEDevice::setSecurityCallbacks(&mySecurity);
+    /*
+     * Required in authentication process to provide displaying and/or input passkey or yes/no butttons confirmation
+     */
+    static MySecurity mySecurity;
+    mySecurity.startCb = startBtPinScreen;
+    mySecurity.stopCb = stopBtPinScreen;
+    BLEDevice::setSecurityCallbacks(&mySecurity);
 
-  // Create the BLE Server
-  pServer = BLEDevice::createServer();
-  static MyServerCallbacks myCallbacks;
-  pServer->setCallbacks(&myCallbacks);
+    // Create the BLE Server
+    pServer = BLEDevice::createServer();
+    static MyServerCallbacks myCallbacks;
+    pServer->setCallbacks(&myCallbacks);
 
-  pDevInfo = createDeviceInfomationService(pServer, hwVendor, swVersion, hwVersion);
+    pDevInfo = createDeviceInfomationService(pServer, hwVendor, swVersion, hwVersion);
 
-  // We now let users create the battery service only if they really want (not all devices have a battery)
-  // BLEService *pBattery = createBatteryService(pServer);
+    // We now let users create the battery service only if they really want (not all devices have a battery)
+    // BLEService *pBattery = createBatteryService(pServer);
 
-  pUpdate = createUpdateService(pServer, hwVendor, swVersion, hwVersion); // We need to advertise this so our android ble scan operation can see it
+    pUpdate = createUpdateService(pServer, hwVendor, swVersion,
+                                  hwVersion); // We need to advertise this so our android ble scan operation can see it
 
-  // It seems only one service can be advertised - so for now don't advertise our updater
-  // pServer->getAdvertising()->addServiceUUID(pUpdate->getUUID());
+    // It seems only one service can be advertised - so for now don't advertise our updater
+    // pServer->getAdvertising()->addServiceUUID(pUpdate->getUUID());
 
-  // start all our services (do this after creating all of them)
-  pDevInfo->start();
-  pUpdate->start();
+    // start all our services (do this after creating all of them)
+    pDevInfo->start();
+    pUpdate->start();
 
-  // FIXME turn on this restriction only after the device is paired with a phone
-  // advert->setScanFilter(false, true); // We let anyone scan for us (FIXME, perhaps only allow that until we are paired with a phone and configured) but only let whitelist phones connect
+    // FIXME turn on this restriction only after the device is paired with a phone
+    // advert->setScanFilter(false, true); // We let anyone scan for us (FIXME, perhaps only allow that until we are paired with a
+    // phone and configured) but only let whitelist phones connect
 
-  static BLESecurity security; // static to avoid allocs
-  BLESecurity *pSecurity = &security;
-  pSecurity->setCapability(ESP_IO_CAP_OUT);
-  pSecurity->setAuthenticationMode(ESP_LE_AUTH_REQ_SC_BOND);
-  pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
+    static BLESecurity security; // static to avoid allocs
+    BLESecurity *pSecurity = &security;
+    pSecurity->setCapability(ESP_IO_CAP_OUT);
+    pSecurity->setAuthenticationMode(ESP_LE_AUTH_REQ_SC_BOND);
+    pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
 
-  return pServer;
+    return pServer;
 }
 
 // Called from loop
 void loopBLE()
 {
-  bluetoothRebootCheck();
+    bluetoothRebootCheck();
 }

lib/segger_rtt/License.txt

@@ -0,0 +1,34 @@
+Important - Read carefully:
+
+SEGGER RTT - Real Time Transfer for embedded targets
+
+All rights reserved.
+
+SEGGER strongly recommends to not make any changes
+to or modify the source code of this software in order to stay
+compatible with the RTT protocol and J-Link.
+
+Redistribution and use in source and binary forms, with or
+without modification, are permitted provided that the following
+condition is met:
+
+o Redistributions of source code must retain the above copyright
+  notice, this condition and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+
+
+(c) 2014 - 2016  SEGGER Microcontroller GmbH
+www.segger.com

lib/segger_rtt/README.txt

@@ -0,0 +1,20 @@
+README.txt for the SEGGER RTT Implementation Pack.
+
+Included files:
+===============
+Root Directory
+  - Examples
+    - Main_RTT_InputEchoApp.c    - Sample application which echoes input on Channel 0.
+    - Main_RTT_MenuApp.c         - Sample application to demonstrate RTT bi-directional functionality.
+    - Main_RTT_PrintfTest.c      - Sample application to test RTT small printf implementation.
+    - Main_RTT_SpeedTestApp.c    - Sample application for measuring RTT performance. embOS needed.
+  - RTT
+    - SEGGER_RTT.c                - The RTT implementation.
+    - SEGGER_RTT.h                - Header for RTT implementation.
+    - SEGGER_RTT_Conf.h           - Pre-processor configuration for the RTT implementation.
+    - SEGGER_RTT_Printf.c         - Simple implementation of printf to write formatted strings via RTT.
+  - Syscalls
+    - RTT_Syscalls_GCC.c          - Low-level syscalls to retarget printf() to RTT with GCC / Newlib.
+    - RTT_Syscalls_IAR.c          - Low-level syscalls to retarget printf() to RTT with IAR compiler.
+    - RTT_Syscalls_KEIL.c         - Low-level syscalls to retarget printf() to RTT with KEIL/uVision compiler.
+    - RTT_Syscalls_SES.c          - Low-level syscalls to retarget printf() to RTT with SEGGER Embedded Studio.

lib/segger_rtt/Syscalls/SEGGER_RTT_Syscalls_GCC.c

@@ -0,0 +1,121 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2019 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER RTT * Real Time Transfer for embedded targets         *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* All rights reserved.                                               *
+*                                                                    *
+* SEGGER strongly recommends to not make any changes                 *
+* to or modify the source code of this software in order to stay     *
+* compatible with the RTT protocol and J-Link.                       *
+*                                                                    *
+* Redistribution and use in source and binary forms, with or         *
+* without modification, are permitted provided that the following    *
+* condition is met:                                                  *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this condition and the following disclaimer.             *
+*                                                                    *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND             *
+* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,        *
+* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF           *
+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *
+* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           *
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  *
+* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;    *
+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF      *
+* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT          *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE  *
+* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH   *
+* DAMAGE.                                                            *
+*                                                                    *
+**********************************************************************
+---------------------------END-OF-HEADER------------------------------
+File    : SEGGER_RTT_Syscalls_GCC.c
+Purpose : Low-level functions for using printf() via RTT in GCC.
+          To use RTT for printf output, include this file in your
+          application.
+Revision: $Rev: 17697 $
+----------------------------------------------------------------------
+*/
+#if (defined __GNUC__) && !(defined __SES_ARM) && !(defined __CROSSWORKS_ARM)
+
+#include "SEGGER_RTT.h"
+#include <reent.h> // required for _write_r
+
+/*********************************************************************
+ *
+ *       Types
+ *
+ **********************************************************************
+ */
+//
+// If necessary define the _reent struct
+// to match the one passed by the used standard library.
+//
+struct _reent;
+
+/*********************************************************************
+ *
+ *       Function prototypes
+ *
+ **********************************************************************
+ */
+int _write(int file, char *ptr, int len);
+// _ssize_t _write_r(struct _reent *r, int file, const void *ptr, int len);
+
+/*********************************************************************
+ *
+ *       Global functions
+ *
+ **********************************************************************
+ */
+
+/*********************************************************************
+ *
+ *       _write()
+ *
+ * Function description
+ *   Low-level write function.
+ *   libc subroutines will use this system routine for output to all files,
+ *   including stdout.
+ *   Write data via RTT.
+ */
+int _write(int file, char *ptr, int len)
+{
+    (void)file; /* Not used, avoid warning */
+    SEGGER_RTT_Write(0, ptr, len);
+    return len;
+}
+
+/*********************************************************************
+ *
+ *       _write_r()
+ *
+ * Function description
+ *   Low-level reentrant write function.
+ *   libc subroutines will use this system routine for output to all files,
+ *   including stdout.
+ *   Write data via RTT.
+ */
+_ssize_t _write_r(struct _reent *r, int file, const void *ptr, int len)
+{
+    (void)file; /* Not used, avoid warning */
+    (void)r;    /* Not used, avoid warning */
+    SEGGER_RTT_Write(0, ptr, len);
+    return len;
+}
+
+#endif
+/****** End Of File *************************************************/

lib/segger_rtt/Syscalls/SEGGER_RTT_Syscalls_IAR.c

@@ -0,0 +1,115 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2019 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER RTT * Real Time Transfer for embedded targets         *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* All rights reserved.                                               *
+*                                                                    *
+* SEGGER strongly recommends to not make any changes                 *
+* to or modify the source code of this software in order to stay     *
+* compatible with the RTT protocol and J-Link.                       *
+*                                                                    *
+* Redistribution and use in source and binary forms, with or         *
+* without modification, are permitted provided that the following    *
+* condition is met:                                                  *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this condition and the following disclaimer.             *
+*                                                                    *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND             *
+* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,        *
+* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF           *
+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *
+* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           *
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  *
+* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;    *
+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF      *
+* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT          *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE  *
+* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH   *
+* DAMAGE.                                                            *
+*                                                                    *
+**********************************************************************
+---------------------------END-OF-HEADER------------------------------
+File    : SEGGER_RTT_Syscalls_IAR.c
+Purpose : Low-level functions for using printf() via RTT in IAR.
+          To use RTT for printf output, include this file in your
+          application and set the Library Configuration to Normal.
+Revision: $Rev: 17697 $
+----------------------------------------------------------------------
+*/
+#ifdef __IAR_SYSTEMS_ICC__
+
+//
+// Since IAR EWARM V8 and EWRX V4, yfuns.h is considered as deprecated and LowLevelIOInterface.h
+// shall be used instead. To not break any compatibility with older compiler versions, we have a
+// version check in here.
+//
+#if ((defined __ICCARM__) && (__VER__ >= 8000000)) || ((defined __ICCRX__)  && (__VER__ >= 400))
+  #include <LowLevelIOInterface.h>
+#else
+  #include <yfuns.h>
+#endif
+
+#include "SEGGER_RTT.h"
+#pragma module_name = "?__write"
+
+/*********************************************************************
+*
+*       Function prototypes
+*
+**********************************************************************
+*/
+size_t __write(int handle, const unsigned char * buffer, size_t size);
+
+/*********************************************************************
+*
+*       Global functions
+*
+**********************************************************************
+*/
+/*********************************************************************
+*
+*       __write()
+*
+* Function description
+*   Low-level write function.
+*   Standard library subroutines will use this system routine
+*   for output to all files, including stdout.
+*   Write data via RTT.
+*/
+size_t __write(int handle, const unsigned char * buffer, size_t size) {
+  (void) handle;  /* Not used, avoid warning */
+  SEGGER_RTT_Write(0, (const char*)buffer, size);
+  return size;
+}
+
+/*********************************************************************
+*
+*       __write_buffered()
+*
+* Function description
+*   Low-level write function.
+*   Standard library subroutines will use this system routine
+*   for output to all files, including stdout.
+*   Write data via RTT.
+*/
+size_t __write_buffered(int handle, const unsigned char * buffer, size_t size) {
+  (void) handle;  /* Not used, avoid warning */
+  SEGGER_RTT_Write(0, (const char*)buffer, size);
+  return size;
+}
+
+#endif
+/****** End Of File *************************************************/

lib/segger_rtt/Syscalls/SEGGER_RTT_Syscalls_KEIL.c

@@ -0,0 +1,386 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2019 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER RTT * Real Time Transfer for embedded targets         *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* All rights reserved.                                               *
+*                                                                    *
+* SEGGER strongly recommends to not make any changes                 *
+* to or modify the source code of this software in order to stay     *
+* compatible with the RTT protocol and J-Link.                       *
+*                                                                    *
+* Redistribution and use in source and binary forms, with or         *
+* without modification, are permitted provided that the following    *
+* condition is met:                                                  *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this condition and the following disclaimer.             *
+*                                                                    *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND             *
+* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,        *
+* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF           *
+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *
+* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           *
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  *
+* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;    *
+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF      *
+* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT          *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE  *
+* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH   *
+* DAMAGE.                                                            *
+*                                                                    *
+**********************************************************************
+---------------------------END-OF-HEADER------------------------------
+File    : RTT_Syscalls_KEIL.c
+Purpose : Retargeting module for KEIL MDK-CM3.
+          Low-level functions for using printf() via RTT
+Revision: $Rev: 17697 $
+----------------------------------------------------------------------
+*/
+#ifdef __CC_ARM
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <rt_sys.h>
+#include <rt_misc.h>
+
+#include "SEGGER_RTT.h"
+/*********************************************************************
+*
+*       #pragmas
+*
+**********************************************************************
+*/
+#pragma import(__use_no_semihosting)
+
+#ifdef _MICROLIB
+  #pragma import(__use_full_stdio)
+#endif
+
+/*********************************************************************
+*
+*       Defines non-configurable
+*
+**********************************************************************
+*/
+
+/* Standard IO device handles - arbitrary, but any real file system handles must be
+   less than 0x8000. */
+#define STDIN             0x8001    // Standard Input Stream
+#define STDOUT            0x8002    // Standard Output Stream
+#define STDERR            0x8003    // Standard Error Stream
+
+/*********************************************************************
+*
+*       Public const
+*
+**********************************************************************
+*/
+#if __ARMCC_VERSION < 5000000
+//const char __stdin_name[]  = "STDIN";
+const char __stdout_name[] = "STDOUT";
+const char __stderr_name[] = "STDERR";
+#endif
+
+/*********************************************************************
+*
+*       Public code
+*
+**********************************************************************
+*/
+
+/*********************************************************************
+*
+*       _ttywrch
+*
+*  Function description:
+*    Outputs a character to the console
+*
+*  Parameters:
+*    c    - character to output
+*  
+*/
+void _ttywrch(int c) {
+  fputc(c, stdout); // stdout
+  fflush(stdout);
+}
+
+/*********************************************************************
+*
+*       _sys_open
+*
+*  Function description:
+*    Opens the device/file in order to do read/write operations
+*
+*  Parameters:
+*    sName        - sName of the device/file to open
+*    OpenMode    - This parameter is currently ignored
+*  
+*  Return value:
+*    != 0     - Handle to the object to open, otherwise 
+*    == 0     -"device" is not handled by this module
+*
+*/
+FILEHANDLE _sys_open(const char * sName, int OpenMode) {
+  (void)OpenMode;
+  // Register standard Input Output devices.
+  if (strcmp(sName, __stdout_name) == 0) {
+    return (STDOUT);
+  } else if (strcmp(sName, __stderr_name) == 0) {
+    return (STDERR);
+  } else
+  return (0);  // Not implemented
+}
+
+/*********************************************************************
+*
+*       _sys_close
+*
+*  Function description:
+*    Closes the handle to the open device/file
+*
+*  Parameters:
+*    hFile    - Handle to a file opened via _sys_open
+*  
+*  Return value:
+*    0     - device/file closed
+*
+*/
+int _sys_close(FILEHANDLE hFile) {
+  (void)hFile;
+  return 0;  // Not implemented
+}
+
+/*********************************************************************
+*
+*       _sys_write
+*
+*  Function description:
+*    Writes the data to an open handle.
+*    Currently this function only outputs data to the console
+*
+*  Parameters:
+*    hFile    - Handle to a file opened via _sys_open
+*    pBuffer  - Pointer to the data that shall be written
+*    NumBytes      - Number of bytes to write
+*    Mode     - The Mode that shall be used
+*  
+*  Return value:
+*    Number of bytes *not* written to the file/device
+*
+*/
+int _sys_write(FILEHANDLE hFile, const unsigned char * pBuffer, unsigned NumBytes, int Mode) {
+  int r = 0;
+
+  (void)Mode;
+  if (hFile == STDOUT) {
+    SEGGER_RTT_Write(0, (const char*)pBuffer, NumBytes);
+		return 0;
+  }
+  return r;
+}
+
+/*********************************************************************
+*
+*       _sys_read
+*
+*  Function description:
+*    Reads data from an open handle.
+*    Currently this modules does nothing.
+*
+*  Parameters:
+*    hFile    - Handle to a file opened via _sys_open
+*    pBuffer  - Pointer to buffer to store the read data
+*    NumBytes      - Number of bytes to read
+*    Mode     - The Mode that shall be used
+*  
+*  Return value:
+*    Number of bytes read from the file/device
+*
+*/
+int _sys_read(FILEHANDLE hFile, unsigned char * pBuffer, unsigned NumBytes, int Mode) {
+  (void)hFile;
+  (void)pBuffer;
+  (void)NumBytes;
+  (void)Mode;
+  return (0);  // Not implemented
+}
+
+/*********************************************************************
+*
+*       _sys_istty
+*
+*  Function description:
+*    This function shall return whether the opened file 
+*    is a console device or not.
+*
+*  Parameters:
+*    hFile    - Handle to a file opened via _sys_open
+*  
+*  Return value:
+*    1       - Device is     a console
+*    0       - Device is not a console
+*
+*/
+int _sys_istty(FILEHANDLE hFile) {
+  if (hFile > 0x8000) {
+    return (1);
+  }
+  return (0);  // Not implemented
+}
+
+/*********************************************************************
+*
+*       _sys_seek
+*
+*  Function description:
+*    Seeks via the file to a specific position
+*
+*  Parameters:
+*    hFile  - Handle to a file opened via _sys_open
+*    Pos    - 
+*  
+*  Return value:
+*    int       - 
+*
+*/
+int _sys_seek(FILEHANDLE hFile, long Pos) {
+  (void)hFile;
+  (void)Pos;
+  return (0);  // Not implemented
+}
+
+/*********************************************************************
+*
+*       _sys_ensure
+*
+*  Function description:
+*    
+*
+*  Parameters:
+*    hFile    - Handle to a file opened via _sys_open
+*  
+*  Return value:
+*    int       - 
+*
+*/
+int _sys_ensure(FILEHANDLE hFile) {
+  (void)hFile;
+  return (-1);  // Not implemented
+}
+
+/*********************************************************************
+*
+*       _sys_flen
+*
+*  Function description:
+*    Returns the length of the opened file handle
+*
+*  Parameters:
+*    hFile    - Handle to a file opened via _sys_open
+*  
+*  Return value:
+*    Length of the file
+*
+*/
+long _sys_flen(FILEHANDLE hFile) {
+  (void)hFile;
+  return (0);  // Not implemented
+}
+
+/*********************************************************************
+*
+*       _sys_tmpnam
+*
+*  Function description:
+*    This function converts the file number fileno for a temporary 
+*    file to a unique filename, for example, tmp0001.
+*
+*  Parameters:
+*    pBuffer    - Pointer to a buffer to store the name
+*    FileNum    - file number to convert
+*    MaxLen     - Size of the buffer
+*  
+*  Return value:
+*     1 - Error
+*     0 - Success  
+*
+*/
+int _sys_tmpnam(char * pBuffer, int FileNum, unsigned MaxLen) {
+  (void)pBuffer;
+  (void)FileNum;
+  (void)MaxLen;
+  return (1);  // Not implemented
+}
+
+/*********************************************************************
+*
+*       _sys_command_string
+*
+*  Function description:
+*    This function shall execute a system command.
+*
+*  Parameters:
+*    cmd    - Pointer to the command string
+*    len    - Length of the string
+*  
+*  Return value:
+*    == NULL - Command was not successfully executed
+*    == sCmd - Command was passed successfully
+*
+*/
+char * _sys_command_string(char * cmd, int len) {
+  (void)len;
+  return cmd;  // Not implemented
+}
+
+/*********************************************************************
+*
+*       _sys_exit
+*
+*  Function description:
+*    This function is called when the application returns from main
+*
+*  Parameters:
+*    ReturnCode    - Return code from the main function
+*  
+*
+*/
+void _sys_exit(int ReturnCode) {
+  (void)ReturnCode;
+  while (1);  // Not implemented
+}
+
+#if __ARMCC_VERSION >= 5000000
+/*********************************************************************
+*
+*       stdout_putchar
+*
+*  Function description:
+*    Put a character to the stdout
+*
+*  Parameters:
+*    ch    - Character to output
+*  
+*
+*/
+int stdout_putchar(int ch) {
+  (void)ch;
+  return ch;  // Not implemented
+}
+#endif
+
+#endif
+/*************************** End of file ****************************/

lib/segger_rtt/Syscalls/SEGGER_RTT_Syscalls_SES.c

@@ -0,0 +1,247 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2019 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER RTT * Real Time Transfer for embedded targets         *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* All rights reserved.                                               *
+*                                                                    *
+* SEGGER strongly recommends to not make any changes                 *
+* to or modify the source code of this software in order to stay     *
+* compatible with the RTT protocol and J-Link.                       *
+*                                                                    *
+* Redistribution and use in source and binary forms, with or         *
+* without modification, are permitted provided that the following    *
+* condition is met:                                                  *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this condition and the following disclaimer.             *
+*                                                                    *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND             *
+* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,        *
+* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF           *
+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *
+* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           *
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  *
+* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;    *
+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF      *
+* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT          *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE  *
+* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH   *
+* DAMAGE.                                                            *
+*                                                                    *
+**********************************************************************
+---------------------------END-OF-HEADER------------------------------
+File    : SEGGER_RTT_Syscalls_SES.c
+Purpose : Reimplementation of printf, puts and __getchar using RTT
+          in SEGGER Embedded Studio.
+          To use RTT for printf output, include this file in your
+          application.
+Revision: $Rev: 18539 $
+----------------------------------------------------------------------
+*/
+#if (defined __SES_ARM) || (defined __SES_RISCV) || (defined __CROSSWORKS_ARM)
+
+#include "SEGGER_RTT.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include "limits.h"
+#include "__libc.h"
+#include "__vfprintf.h"
+
+/*********************************************************************
+*
+*       Defines, configurable
+*
+**********************************************************************
+*/
+//
+// Select string formatting implementation.
+//
+// RTT printf formatting
+//  - Configurable stack usage. (SEGGER_RTT_PRINTF_BUFFER_SIZE in SEGGER_RTT_Conf.h)
+//  - No maximum string length.
+//  - Limited conversion specifiers and flags. (See SEGGER_RTT_printf.c)
+// Standard library printf formatting
+//  - Configurable formatting capabilities.
+//  - Full conversion specifier and flag support.
+//  - Maximum string length has to be known or (slightly) slower character-wise output.
+//
+// #define PRINTF_USE_SEGGER_RTT_FORMATTING    0 // Use standard library formatting
+// #define PRINTF_USE_SEGGER_RTT_FORMATTING    1 // Use RTT formatting
+//
+#ifndef   PRINTF_USE_SEGGER_RTT_FORMATTING
+  #define PRINTF_USE_SEGGER_RTT_FORMATTING    0
+#endif
+//
+// If using standard library formatting,
+// select maximum output string buffer size or character-wise output.
+//
+// #define PRINTF_BUFFER_SIZE                  0 // Use character-wise output
+// #define PRINTF_BUFFER_SIZE                128 // Default maximum string length
+//
+#ifndef   PRINTF_BUFFER_SIZE
+  #define PRINTF_BUFFER_SIZE                128
+#endif
+
+#if PRINTF_USE_SEGGER_RTT_FORMATTING  // Use SEGGER RTT formatting implementation
+/*********************************************************************
+*
+*       Function prototypes
+*
+**********************************************************************
+*/
+int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList);
+
+/*********************************************************************
+*
+*       Global functions, printf
+*
+**********************************************************************
+*/
+/*********************************************************************
+*
+*       printf()
+*
+*  Function description
+*    print a formatted string using RTT and SEGGER RTT formatting.
+*/
+int printf(const char *fmt,...) {
+  int     n;
+  va_list args;
+
+  va_start (args, fmt);
+  n = SEGGER_RTT_vprintf(0, fmt, &args);
+  va_end(args);
+  return n;
+}
+
+#elif PRINTF_BUFFER_SIZE == 0 // Use standard library formatting with character-wise output
+
+/*********************************************************************
+*
+*       Static functions
+*
+**********************************************************************
+*/
+static int _putchar(int x, __printf_tag_ptr ctx) {
+  (void)ctx;
+  SEGGER_RTT_Write(0, (char *)&x, 1);
+  return x;
+}
+
+/*********************************************************************
+*
+*       Global functions, printf
+*
+**********************************************************************
+*/
+/*********************************************************************
+*
+*       printf()
+*
+*  Function description
+*    print a formatted string character-wise, using RTT and standard
+*    library formatting.
+*/
+int printf(const char *fmt, ...) {
+  int         n;
+  va_list     args;
+  __printf_t  iod;
+
+  va_start(args, fmt);
+  iod.string    = 0;
+  iod.maxchars  = INT_MAX;
+  iod.output_fn = _putchar;
+  SEGGER_RTT_LOCK();
+  n = __vfprintf(&iod, fmt, args);
+  SEGGER_RTT_UNLOCK();
+  va_end(args);
+  return n;
+}
+
+#else // Use standard library formatting with static buffer
+
+/*********************************************************************
+*
+*       Global functions, printf
+*
+**********************************************************************
+*/
+/*********************************************************************
+*
+*       printf()
+*
+*  Function description
+*    print a formatted string using RTT and standard library formatting.
+*/
+int printf(const char *fmt,...) {
+  int     n;
+  char    aBuffer[PRINTF_BUFFER_SIZE];
+  va_list args;
+
+  va_start (args, fmt);
+  n = vsnprintf(aBuffer, sizeof(aBuffer), fmt, args);
+  if (n > (int)sizeof(aBuffer)) {
+    SEGGER_RTT_Write(0, aBuffer, sizeof(aBuffer));
+  } else if (n > 0) {
+    SEGGER_RTT_Write(0, aBuffer, n);
+  }
+  va_end(args);
+  return n;
+}
+#endif
+
+/*********************************************************************
+*
+*       Global functions
+*
+**********************************************************************
+*/
+/*********************************************************************
+*
+*       puts()
+*
+*  Function description
+*    print a string using RTT.
+*/
+int puts(const char *s) {
+  return SEGGER_RTT_WriteString(0, s);
+}
+
+/*********************************************************************
+*
+*       __putchar()
+*
+*  Function description
+*    Write one character via RTT.
+*/
+int __putchar(int x, __printf_tag_ptr ctx) {
+  (void)ctx;
+  SEGGER_RTT_Write(0, (char *)&x, 1);
+  return x;
+}
+
+/*********************************************************************
+*
+*       __getchar()
+*
+*  Function description
+*    Wait for and get a character via RTT.
+*/
+int __getchar() {
+  return SEGGER_RTT_WaitKey();
+}
+
+#endif
+/****** End Of File *************************************************/

lib/segger_rtt/examples/Main_RTT_InputEchoApp.c

@@ -0,0 +1,43 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*       Solutions for real time microcontroller applications         *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2018 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+
+--------- END-OF-HEADER --------------------------------------------
+File    : Main_RTT_MenuApp.c
+Purpose : Sample application to demonstrate RTT bi-directional functionality
+*/
+
+#define MAIN_C
+
+#include <stdio.h>
+
+#include "SEGGER_RTT.h"
+
+volatile int _Cnt;
+volatile int _Delay;
+
+static char r;
+
+/*********************************************************************
+*
+*       main
+*/
+void main(void) {
+
+  SEGGER_RTT_WriteString(0, "SEGGER Real-Time-Terminal Sample\r\n");
+  SEGGER_RTT_ConfigUpBuffer(0, NULL, NULL, 0, SEGGER_RTT_MODE_NO_BLOCK_SKIP);
+  do {
+    r = SEGGER_RTT_WaitKey();
+    SEGGER_RTT_Write(0, &r, 1);
+    r++;
+  } while (1);
+}
+
+/*************************** End of file ****************************/

lib/segger_rtt/examples/Main_RTT_MenuApp.c

@@ -0,0 +1,70 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*       Solutions for real time microcontroller applications         *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2018 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+--------- END-OF-HEADER --------------------------------------------
+File    : Main_RTT_MenuApp.c
+Purpose : Sample application to demonstrate RTT bi-directional functionality
+*/
+
+#define MAIN_C
+
+#include <stdio.h>
+
+#include "SEGGER_RTT.h"
+
+volatile int _Cnt;
+volatile int _Delay;
+
+/*********************************************************************
+*
+*       main
+*/
+void main(void) {
+  int r;
+  int CancelOp;
+
+  do {
+    _Cnt = 0;
+
+    SEGGER_RTT_WriteString(0, "SEGGER Real-Time-Terminal Sample\r\n");
+    SEGGER_RTT_WriteString(0, "Press <1> to continue in blocking mode (Application waits if necessary, no data lost)\r\n");
+    SEGGER_RTT_WriteString(0, "Press <2> to continue in non-blocking mode (Application does not wait, data lost if fifo full)\r\n");
+    do {
+      r = SEGGER_RTT_WaitKey();
+    } while ((r != '1') && (r != '2'));
+    if (r == '1') {
+      SEGGER_RTT_WriteString(0, "\r\nSelected <1>. Configuring RTT and starting...\r\n");
+      SEGGER_RTT_ConfigUpBuffer(0, NULL, NULL, 0, SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL);
+    } else {
+      SEGGER_RTT_WriteString(0, "\r\nSelected <2>. Configuring RTT and starting...\r\n");
+      SEGGER_RTT_ConfigUpBuffer(0, NULL, NULL, 0, SEGGER_RTT_MODE_NO_BLOCK_SKIP);
+    }
+    CancelOp = 0;
+    do {
+      //for (_Delay = 0; _Delay < 10000; _Delay++);
+      SEGGER_RTT_printf(0, "Count: %d. Press <Space> to get back to menu.\r\n", _Cnt++);
+      r = SEGGER_RTT_HasKey();
+      if (r) {
+        CancelOp = (SEGGER_RTT_GetKey() == ' ') ? 1 : 0;
+      }
+      //
+      // Check if user selected to cancel the current operation
+      //
+      if (CancelOp) {
+        SEGGER_RTT_WriteString(0, "Operation cancelled, going back to menu...\r\n");
+        break;
+      }
+    } while (1);
+    SEGGER_RTT_GetKey();
+    SEGGER_RTT_WriteString(0, "\r\n");
+  } while (1);
+}
+
+/*************************** End of file ****************************/

lib/segger_rtt/examples/Main_RTT_PrintfTest.c

@@ -0,0 +1,118 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*       Solutions for real time microcontroller applications         *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2018 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+
+--------- END-OF-HEADER --------------------------------------------
+File    : Main_RTT_MenuApp.c
+Purpose : Sample application to demonstrate RTT bi-directional functionality
+*/
+
+#define MAIN_C
+
+#include <stdio.h>
+
+#include "SEGGER_RTT.h"
+
+volatile int _Cnt;
+
+/*********************************************************************
+*
+*       main
+*/
+void main(void) {
+
+  SEGGER_RTT_ConfigUpBuffer(0, NULL, NULL, 0, SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL);
+
+  SEGGER_RTT_WriteString(0, "SEGGER Real-Time-Terminal Sample\r\n\r\n");
+  SEGGER_RTT_WriteString(0, "###### Testing SEGGER_printf() ######\r\n");
+
+  SEGGER_RTT_printf(0, "printf Test: %%c,         'S' : %c.\r\n", 'S');
+  SEGGER_RTT_printf(0, "printf Test: %%5c,        'E' : %5c.\r\n", 'E');
+  SEGGER_RTT_printf(0, "printf Test: %%-5c,       'G' : %-5c.\r\n", 'G');
+  SEGGER_RTT_printf(0, "printf Test: %%5.3c,      'G' : %-5c.\r\n", 'G');
+  SEGGER_RTT_printf(0, "printf Test: %%.3c,       'E' : %-5c.\r\n", 'E');
+  SEGGER_RTT_printf(0, "printf Test: %%c,         'R' : %c.\r\n", 'R');
+
+  SEGGER_RTT_printf(0, "printf Test: %%s,      \"RTT\" : %s.\r\n", "RTT");
+  SEGGER_RTT_printf(0, "printf Test: %%s, \"RTT\\r\\nRocks.\" : %s.\r\n", "RTT\r\nRocks.");
+
+  SEGGER_RTT_printf(0, "printf Test: %%u,       12345 : %u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%+u,      12345 : %+u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%.3u,     12345 : %.3u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%.6u,     12345 : %.6u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%6.3u,    12345 : %6.3u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%8.6u,    12345 : %8.6u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%08u,     12345 : %08u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%08.6u,   12345 : %08.6u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%0u,      12345 : %0u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-.6u,    12345 : %-.6u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-6.3u,   12345 : %-6.3u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-8.6u,   12345 : %-8.6u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-08u,    12345 : %-08u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-08.6u,  12345 : %-08.6u.\r\n", 12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-0u,     12345 : %-0u.\r\n", 12345);
+
+  SEGGER_RTT_printf(0, "printf Test: %%u,      -12345 : %u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%+u,     -12345 : %+u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%.3u,    -12345 : %.3u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%.6u,    -12345 : %.6u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%6.3u,   -12345 : %6.3u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%8.6u,   -12345 : %8.6u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%08u,    -12345 : %08u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%08.6u,  -12345 : %08.6u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%0u,     -12345 : %0u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-.6u,   -12345 : %-.6u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-6.3u,  -12345 : %-6.3u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-8.6u,  -12345 : %-8.6u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-08u,   -12345 : %-08u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-08.6u, -12345 : %-08.6u.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-0u,    -12345 : %-0u.\r\n", -12345);
+
+  SEGGER_RTT_printf(0, "printf Test: %%d,      -12345 : %d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%+d,     -12345 : %+d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%.3d,    -12345 : %.3d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%.6d,    -12345 : %.6d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%6.3d,   -12345 : %6.3d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%8.6d,   -12345 : %8.6d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%08d,    -12345 : %08d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%08.6d,  -12345 : %08.6d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%0d,     -12345 : %0d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-.6d,   -12345 : %-.6d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-6.3d,  -12345 : %-6.3d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-8.6d,  -12345 : %-8.6d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-08d,   -12345 : %-08d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-08.6d, -12345 : %-08.6d.\r\n", -12345);
+  SEGGER_RTT_printf(0, "printf Test: %%-0d,    -12345 : %-0d.\r\n", -12345);
+
+  SEGGER_RTT_printf(0, "printf Test: %%x,      0x1234ABC : %x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%+x,     0x1234ABC : %+x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%.3x,    0x1234ABC : %.3x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%.6x,    0x1234ABC : %.6x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%6.3x,   0x1234ABC : %6.3x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%8.6x,   0x1234ABC : %8.6x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%08x,    0x1234ABC : %08x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%08.6x,  0x1234ABC : %08.6x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%0x,     0x1234ABC : %0x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%-.6x,   0x1234ABC : %-.6x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%-6.3x,  0x1234ABC : %-6.3x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%-8.6x,  0x1234ABC : %-8.6x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%-08x,   0x1234ABC : %-08x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%-08.6x, 0x1234ABC : %-08.6x.\r\n", 0x1234ABC);
+  SEGGER_RTT_printf(0, "printf Test: %%-0x,    0x1234ABC : %-0x.\r\n", 0x1234ABC);
+
+  SEGGER_RTT_printf(0, "printf Test: %%p,      &_Cnt      : %p.\r\n", &_Cnt);
+
+  SEGGER_RTT_WriteString(0, "###### SEGGER_printf() Tests done. ######\r\n");
+  do {
+    _Cnt++;
+  } while (1);
+}
+
+/*************************** End of file ****************************/

lib/segger_rtt/examples/Main_RTT_SpeedTestApp.c

@@ -0,0 +1,69 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*       Solutions for real time microcontroller applications         *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2018 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+
+--------- END-OF-HEADER --------------------------------------------
+File    : Main_RTT_SpeedTestApp.c
+Purpose : Sample program for measuring RTT performance.
+*/
+
+#include "RTOS.h"
+#include "BSP.h"
+
+#include "SEGGER_RTT.h"
+#include <stdio.h>
+
+OS_STACKPTR int StackHP[128], StackLP[128];          /* Task stacks */
+OS_TASK TCBHP, TCBLP;                        /* Task-control-blocks */
+
+static void HPTask(void) {
+  while (1) {
+    //
+    // Measure time needed for RTT output
+    // Perform dummy write with 0 characters, so we know the overhead of toggling LEDs and RTT in general
+    //
+// Set BP here. Then start sampling on scope
+    BSP_ClrLED(0);
+    SEGGER_RTT_Write(0, 0, 0);
+    BSP_SetLED(0);
+    BSP_ClrLED(0);
+    SEGGER_RTT_Write(0, "01234567890123456789012345678901234567890123456789012345678901234567890123456789\r\n", 82);
+    BSP_SetLED(0);
+// Set BP here. Then stop sampling on scope
+    OS_Delay(200);
+  }
+}
+
+static void LPTask(void) {
+  while (1) {
+    BSP_ToggleLED(1);
+    OS_Delay (500);
+  }
+}
+
+/*********************************************************************
+*
+*       main
+*
+*********************************************************************/
+
+int main(void) {
+  OS_IncDI();                      /* Initially disable interrupts  */
+  OS_InitKern();                   /* Initialize OS                 */
+  OS_InitHW();                     /* Initialize Hardware for OS    */
+  BSP_Init();                      /* Initialize LED ports          */
+  BSP_SetLED(0);
+  /* You need to create at least one task before calling OS_Start() */
+  OS_CREATETASK(&TCBHP, "HP Task", HPTask, 100, StackHP);
+  OS_CREATETASK(&TCBLP, "LP Task", LPTask,  50, StackLP);
+  OS_Start();                      /* Start multitasking            */
+  return 0;
+}
+

lib/segger_rtt/include/SEGGER_RTT.h

@@ -0,0 +1,321 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2019 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER RTT * Real Time Transfer for embedded targets         *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* All rights reserved.                                               *
+*                                                                    *
+* SEGGER strongly recommends to not make any changes                 *
+* to or modify the source code of this software in order to stay     *
+* compatible with the RTT protocol and J-Link.                       *
+*                                                                    *
+* Redistribution and use in source and binary forms, with or         *
+* without modification, are permitted provided that the following    *
+* condition is met:                                                  *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this condition and the following disclaimer.             *
+*                                                                    *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND             *
+* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,        *
+* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF           *
+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *
+* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           *
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  *
+* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;    *
+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF      *
+* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT          *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE  *
+* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH   *
+* DAMAGE.                                                            *
+*                                                                    *
+**********************************************************************
+---------------------------END-OF-HEADER------------------------------
+File    : SEGGER_RTT.h
+Purpose : Implementation of SEGGER real-time transfer which allows
+          real-time communication on targets which support debugger 
+          memory accesses while the CPU is running.
+Revision: $Rev: 17697 $
+----------------------------------------------------------------------
+*/
+
+#ifndef SEGGER_RTT_H
+#define SEGGER_RTT_H
+
+#include "SEGGER_RTT_Conf.h"
+
+
+
+/*********************************************************************
+*
+*       Defines, defaults
+*
+**********************************************************************
+*/
+#ifndef RTT_USE_ASM
+  #if (defined __SES_ARM)                       // SEGGER Embedded Studio
+    #define _CC_HAS_RTT_ASM_SUPPORT 1
+  #elif (defined __CROSSWORKS_ARM)              // Rowley Crossworks
+    #define _CC_HAS_RTT_ASM_SUPPORT 1
+  #elif (defined __GNUC__)                      // GCC
+    #define _CC_HAS_RTT_ASM_SUPPORT 1
+  #elif (defined __clang__)                     // Clang compiler
+    #define _CC_HAS_RTT_ASM_SUPPORT 1
+  #elif (defined __IASMARM__)                   // IAR assembler
+    #define _CC_HAS_RTT_ASM_SUPPORT 1
+  #elif (defined __ICCARM__)                    // IAR compiler
+    #define _CC_HAS_RTT_ASM_SUPPORT 1
+  #else
+    #define _CC_HAS_RTT_ASM_SUPPORT 0
+  #endif
+  #if (defined __ARM_ARCH_7M__)                 // Cortex-M3/4
+    #define _CORE_HAS_RTT_ASM_SUPPORT 1
+  #elif (defined __ARM_ARCH_7EM__)              // Cortex-M7
+    #define _CORE_HAS_RTT_ASM_SUPPORT 1
+  #elif (defined __ARM_ARCH_8M_MAIN__)          // Cortex-M33
+    #define _CORE_HAS_RTT_ASM_SUPPORT 1
+  #elif (defined __ARM7M__)                     // IAR Cortex-M3/4
+    #if (__CORE__ == __ARM7M__)
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+    #else
+      #define _CORE_HAS_RTT_ASM_SUPPORT 0
+    #endif
+  #elif (defined __ARM7EM__)                    // IAR Cortex-M7
+    #if (__CORE__ == __ARM7EM__)
+      #define _CORE_HAS_RTT_ASM_SUPPORT 1
+    #else
+      #define _CORE_HAS_RTT_ASM_SUPPORT 0
+    #endif
+  #else
+    #define _CORE_HAS_RTT_ASM_SUPPORT 0
+  #endif
+  //
+  // If IDE and core support the ASM version, enable ASM version by default
+  //
+  #if (_CC_HAS_RTT_ASM_SUPPORT && _CORE_HAS_RTT_ASM_SUPPORT)
+    #define RTT_USE_ASM                           (1)
+  #else
+    #define RTT_USE_ASM                           (0)
+  #endif
+#endif
+
+#ifndef SEGGER_RTT_ASM  // defined when SEGGER_RTT.h is included from assembly file
+#include <stdlib.h>
+#include <stdarg.h>
+
+/*********************************************************************
+*
+*       Defines, fixed
+*
+**********************************************************************
+*/
+
+/*********************************************************************
+*
+*       Types
+*
+**********************************************************************
+*/
+
+//
+// Description for a circular buffer (also called "ring buffer")
+// which is used as up-buffer (T->H)
+//
+typedef struct {
+  const     char*    sName;         // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4"
+            char*    pBuffer;       // Pointer to start of buffer
+            unsigned SizeOfBuffer;  // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty.
+            unsigned WrOff;         // Position of next item to be written by either target.
+  volatile  unsigned RdOff;         // Position of next item to be read by host. Must be volatile since it may be modified by host.
+            unsigned Flags;         // Contains configuration flags
+} SEGGER_RTT_BUFFER_UP;
+
+//
+// Description for a circular buffer (also called "ring buffer")
+// which is used as down-buffer (H->T)
+//
+typedef struct {
+  const     char*    sName;         // Optional name. Standard names so far are: "Terminal", "SysView", "J-Scope_t4i4"
+            char*    pBuffer;       // Pointer to start of buffer
+            unsigned SizeOfBuffer;  // Buffer size in bytes. Note that one byte is lost, as this implementation does not fill up the buffer in order to avoid the problem of being unable to distinguish between full and empty.
+  volatile  unsigned WrOff;         // Position of next item to be written by host. Must be volatile since it may be modified by host.
+            unsigned RdOff;         // Position of next item to be read by target (down-buffer).
+            unsigned Flags;         // Contains configuration flags
+} SEGGER_RTT_BUFFER_DOWN;
+
+//
+// RTT control block which describes the number of buffers available
+// as well as the configuration for each buffer
+//
+//
+typedef struct {
+  char                    acID[16];                                 // Initialized to "SEGGER RTT"
+  int                     MaxNumUpBuffers;                          // Initialized to SEGGER_RTT_MAX_NUM_UP_BUFFERS (type. 2)
+  int                     MaxNumDownBuffers;                        // Initialized to SEGGER_RTT_MAX_NUM_DOWN_BUFFERS (type. 2)
+  SEGGER_RTT_BUFFER_UP    aUp[SEGGER_RTT_MAX_NUM_UP_BUFFERS];       // Up buffers, transferring information up from target via debug probe to host
+  SEGGER_RTT_BUFFER_DOWN  aDown[SEGGER_RTT_MAX_NUM_DOWN_BUFFERS];   // Down buffers, transferring information down from host via debug probe to target
+} SEGGER_RTT_CB;
+
+/*********************************************************************
+*
+*       Global data
+*
+**********************************************************************
+*/
+extern SEGGER_RTT_CB _SEGGER_RTT;
+
+/*********************************************************************
+*
+*       RTT API functions
+*
+**********************************************************************
+*/
+#ifdef __cplusplus
+  extern "C" {
+#endif
+int          SEGGER_RTT_AllocDownBuffer         (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
+int          SEGGER_RTT_AllocUpBuffer           (const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
+int          SEGGER_RTT_ConfigUpBuffer          (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
+int          SEGGER_RTT_ConfigDownBuffer        (unsigned BufferIndex, const char* sName, void* pBuffer, unsigned BufferSize, unsigned Flags);
+int          SEGGER_RTT_GetKey                  (void);
+unsigned     SEGGER_RTT_HasData                 (unsigned BufferIndex);
+int          SEGGER_RTT_HasKey                  (void);
+unsigned     SEGGER_RTT_HasDataUp               (unsigned BufferIndex);
+void         SEGGER_RTT_Init                    (void);
+unsigned     SEGGER_RTT_Read                    (unsigned BufferIndex,       void* pBuffer, unsigned BufferSize);
+unsigned     SEGGER_RTT_ReadNoLock              (unsigned BufferIndex,       void* pData,   unsigned BufferSize);
+int          SEGGER_RTT_SetNameDownBuffer       (unsigned BufferIndex, const char* sName);
+int          SEGGER_RTT_SetNameUpBuffer         (unsigned BufferIndex, const char* sName);
+int          SEGGER_RTT_SetFlagsDownBuffer      (unsigned BufferIndex, unsigned Flags);
+int          SEGGER_RTT_SetFlagsUpBuffer        (unsigned BufferIndex, unsigned Flags);
+int          SEGGER_RTT_WaitKey                 (void);
+unsigned     SEGGER_RTT_Write                   (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_WriteNoLock             (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_WriteSkipNoLock         (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_ASM_WriteSkipNoLock     (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_WriteString             (unsigned BufferIndex, const char* s);
+void         SEGGER_RTT_WriteWithOverwriteNoLock(unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_PutChar                 (unsigned BufferIndex, char c);
+unsigned     SEGGER_RTT_PutCharSkip             (unsigned BufferIndex, char c);
+unsigned     SEGGER_RTT_PutCharSkipNoLock       (unsigned BufferIndex, char c);
+unsigned     SEGGER_RTT_GetAvailWriteSpace      (unsigned BufferIndex);
+unsigned     SEGGER_RTT_GetBytesInBuffer        (unsigned BufferIndex);
+//
+// Function macro for performance optimization
+//
+#define      SEGGER_RTT_HASDATA(n)       (_SEGGER_RTT.aDown[n].WrOff - _SEGGER_RTT.aDown[n].RdOff)
+
+#if RTT_USE_ASM
+  #define SEGGER_RTT_WriteSkipNoLock  SEGGER_RTT_ASM_WriteSkipNoLock
+#endif
+
+/*********************************************************************
+*
+*       RTT transfer functions to send RTT data via other channels.
+*
+**********************************************************************
+*/
+unsigned     SEGGER_RTT_ReadUpBuffer            (unsigned BufferIndex, void* pBuffer, unsigned BufferSize);
+unsigned     SEGGER_RTT_ReadUpBufferNoLock      (unsigned BufferIndex, void* pData, unsigned BufferSize);
+unsigned     SEGGER_RTT_WriteDownBuffer         (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+unsigned     SEGGER_RTT_WriteDownBufferNoLock   (unsigned BufferIndex, const void* pBuffer, unsigned NumBytes);
+
+#define      SEGGER_RTT_HASDATA_UP(n)    (_SEGGER_RTT.aUp[n].WrOff - _SEGGER_RTT.aUp[n].RdOff)
+
+/*********************************************************************
+*
+*       RTT "Terminal" API functions
+*
+**********************************************************************
+*/
+int     SEGGER_RTT_SetTerminal        (unsigned char TerminalId);
+int     SEGGER_RTT_TerminalOut        (unsigned char TerminalId, const char* s);
+
+/*********************************************************************
+*
+*       RTT printf functions (require SEGGER_RTT_printf.c)
+*
+**********************************************************************
+*/
+int SEGGER_RTT_printf(unsigned BufferIndex, const char * sFormat, ...);
+int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList);
+
+#ifdef __cplusplus
+  }
+#endif
+
+#endif // ifndef(SEGGER_RTT_ASM)
+
+/*********************************************************************
+*
+*       Defines
+*
+**********************************************************************
+*/
+
+//
+// Operating modes. Define behavior if buffer is full (not enough space for entire message)
+//
+#define SEGGER_RTT_MODE_NO_BLOCK_SKIP         (0)     // Skip. Do not block, output nothing. (Default)
+#define SEGGER_RTT_MODE_NO_BLOCK_TRIM         (1)     // Trim: Do not block, output as much as fits.
+#define SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL    (2)     // Block: Wait until there is space in the buffer.
+#define SEGGER_RTT_MODE_MASK                  (3)
+
+//
+// Control sequences, based on ANSI.
+// Can be used to control color, and clear the screen
+//
+#define RTT_CTRL_RESET                "\x1B[0m"         // Reset to default colors
+#define RTT_CTRL_CLEAR                "\x1B[2J"         // Clear screen, reposition cursor to top left
+
+#define RTT_CTRL_TEXT_BLACK           "\x1B[2;30m"
+#define RTT_CTRL_TEXT_RED             "\x1B[2;31m"
+#define RTT_CTRL_TEXT_GREEN           "\x1B[2;32m"
+#define RTT_CTRL_TEXT_YELLOW          "\x1B[2;33m"
+#define RTT_CTRL_TEXT_BLUE            "\x1B[2;34m"
+#define RTT_CTRL_TEXT_MAGENTA         "\x1B[2;35m"
+#define RTT_CTRL_TEXT_CYAN            "\x1B[2;36m"
+#define RTT_CTRL_TEXT_WHITE           "\x1B[2;37m"
+
+#define RTT_CTRL_TEXT_BRIGHT_BLACK    "\x1B[1;30m"
+#define RTT_CTRL_TEXT_BRIGHT_RED      "\x1B[1;31m"
+#define RTT_CTRL_TEXT_BRIGHT_GREEN    "\x1B[1;32m"
+#define RTT_CTRL_TEXT_BRIGHT_YELLOW   "\x1B[1;33m"
+#define RTT_CTRL_TEXT_BRIGHT_BLUE     "\x1B[1;34m"
+#define RTT_CTRL_TEXT_BRIGHT_MAGENTA  "\x1B[1;35m"
+#define RTT_CTRL_TEXT_BRIGHT_CYAN     "\x1B[1;36m"
+#define RTT_CTRL_TEXT_BRIGHT_WHITE    "\x1B[1;37m"
+
+#define RTT_CTRL_BG_BLACK             "\x1B[24;40m"
+#define RTT_CTRL_BG_RED               "\x1B[24;41m"
+#define RTT_CTRL_BG_GREEN             "\x1B[24;42m"
+#define RTT_CTRL_BG_YELLOW            "\x1B[24;43m"
+#define RTT_CTRL_BG_BLUE              "\x1B[24;44m"
+#define RTT_CTRL_BG_MAGENTA           "\x1B[24;45m"
+#define RTT_CTRL_BG_CYAN              "\x1B[24;46m"
+#define RTT_CTRL_BG_WHITE             "\x1B[24;47m"
+
+#define RTT_CTRL_BG_BRIGHT_BLACK      "\x1B[4;40m"
+#define RTT_CTRL_BG_BRIGHT_RED        "\x1B[4;41m"
+#define RTT_CTRL_BG_BRIGHT_GREEN      "\x1B[4;42m"
+#define RTT_CTRL_BG_BRIGHT_YELLOW     "\x1B[4;43m"
+#define RTT_CTRL_BG_BRIGHT_BLUE       "\x1B[4;44m"
+#define RTT_CTRL_BG_BRIGHT_MAGENTA    "\x1B[4;45m"
+#define RTT_CTRL_BG_BRIGHT_CYAN       "\x1B[4;46m"
+#define RTT_CTRL_BG_BRIGHT_WHITE      "\x1B[4;47m"
+
+
+#endif
+
+/*************************** End of file ****************************/

lib/segger_rtt/include/SEGGER_RTT_Conf.h

@@ -0,0 +1,384 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2019 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER RTT * Real Time Transfer for embedded targets         *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* All rights reserved.                                               *
+*                                                                    *
+* SEGGER strongly recommends to not make any changes                 *
+* to or modify the source code of this software in order to stay     *
+* compatible with the RTT protocol and J-Link.                       *
+*                                                                    *
+* Redistribution and use in source and binary forms, with or         *
+* without modification, are permitted provided that the following    *
+* condition is met:                                                  *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this condition and the following disclaimer.             *
+*                                                                    *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND             *
+* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,        *
+* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF           *
+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *
+* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           *
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  *
+* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;    *
+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF      *
+* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT          *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE  *
+* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH   *
+* DAMAGE.                                                            *
+*                                                                    *
+**********************************************************************
+---------------------------END-OF-HEADER------------------------------
+File    : SEGGER_RTT_Conf.h
+Purpose : Implementation of SEGGER real-time transfer (RTT) which
+          allows real-time communication on targets which support
+          debugger memory accesses while the CPU is running.
+Revision: $Rev: 18601 $
+
+*/
+
+#ifndef SEGGER_RTT_CONF_H
+#define SEGGER_RTT_CONF_H
+
+#ifdef __IAR_SYSTEMS_ICC__
+  #include <intrinsics.h>
+#endif
+
+/*********************************************************************
+*
+*       Defines, configurable
+*
+**********************************************************************
+*/
+#ifndef   SEGGER_RTT_MAX_NUM_UP_BUFFERS
+  #define SEGGER_RTT_MAX_NUM_UP_BUFFERS             (3)     // Max. number of up-buffers (T->H) available on this target    (Default: 3)
+#endif
+
+#ifndef   SEGGER_RTT_MAX_NUM_DOWN_BUFFERS
+  #define SEGGER_RTT_MAX_NUM_DOWN_BUFFERS           (3)     // Max. number of down-buffers (H->T) available on this target  (Default: 3)
+#endif
+
+#ifndef   BUFFER_SIZE_UP
+  #define BUFFER_SIZE_UP                            (1024)  // Size of the buffer for terminal output of target, up to host (Default: 1k)
+#endif
+
+#ifndef   BUFFER_SIZE_DOWN
+  #define BUFFER_SIZE_DOWN                          (16)    // Size of the buffer for terminal input to target from host (Usually keyboard input) (Default: 16)
+#endif
+
+#ifndef   SEGGER_RTT_PRINTF_BUFFER_SIZE
+  #define SEGGER_RTT_PRINTF_BUFFER_SIZE             (64u)    // Size of buffer for RTT printf to bulk-send chars via RTT     (Default: 64)
+#endif
+
+#ifndef   SEGGER_RTT_MODE_DEFAULT
+  #define SEGGER_RTT_MODE_DEFAULT                   SEGGER_RTT_MODE_NO_BLOCK_SKIP // Mode for pre-initialized terminal channel (buffer 0)
+#endif
+
+/*********************************************************************
+*
+*       RTT memcpy configuration
+*
+*       memcpy() is good for large amounts of data, 
+*       but the overhead is big for small amounts, which are usually stored via RTT.
+*       With SEGGER_RTT_MEMCPY_USE_BYTELOOP a simple byte loop can be used instead.
+*
+*       SEGGER_RTT_MEMCPY() can be used to replace standard memcpy() in RTT functions.
+*       This is may be required with memory access restrictions, 
+*       such as on Cortex-A devices with MMU.
+*/
+#ifndef   SEGGER_RTT_MEMCPY_USE_BYTELOOP
+  #define SEGGER_RTT_MEMCPY_USE_BYTELOOP              0 // 0: Use memcpy/SEGGER_RTT_MEMCPY, 1: Use a simple byte-loop
+#endif
+//
+// Example definition of SEGGER_RTT_MEMCPY to external memcpy with GCC toolchains and Cortex-A targets
+//
+//#if ((defined __SES_ARM) || (defined __CROSSWORKS_ARM) || (defined __GNUC__)) && (defined (__ARM_ARCH_7A__))  
+//  #define SEGGER_RTT_MEMCPY(pDest, pSrc, NumBytes)      SEGGER_memcpy((pDest), (pSrc), (NumBytes))
+//#endif
+
+//
+// Target is not allowed to perform other RTT operations while string still has not been stored completely.
+// Otherwise we would probably end up with a mixed string in the buffer.
+// If using  RTT from within interrupts, multiple tasks or multi processors, define the SEGGER_RTT_LOCK() and SEGGER_RTT_UNLOCK() function here.
+//
+// SEGGER_RTT_MAX_INTERRUPT_PRIORITY can be used in the sample lock routines on Cortex-M3/4.
+// Make sure to mask all interrupts which can send RTT data, i.e. generate SystemView events, or cause task switches.
+// When high-priority interrupts must not be masked while sending RTT data, SEGGER_RTT_MAX_INTERRUPT_PRIORITY needs to be adjusted accordingly.
+// (Higher priority = lower priority number)
+// Default value for embOS: 128u
+// Default configuration in FreeRTOS: configMAX_SYSCALL_INTERRUPT_PRIORITY: ( configLIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY << (8 - configPRIO_BITS) )
+// In case of doubt mask all interrupts: 1 << (8 - BASEPRI_PRIO_BITS) i.e. 1 << 5 when 3 bits are implemented in NVIC
+// or define SEGGER_RTT_LOCK() to completely disable interrupts.
+//
+#ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY
+  #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY         (0x20)   // Interrupt priority to lock on SEGGER_RTT_LOCK on Cortex-M3/4 (Default: 0x20)
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for SEGGER Embedded Studio,
+*       Rowley CrossStudio and GCC
+*/
+#if ((defined(__SES_ARM) || defined(__SES_RISCV) || defined(__CROSSWORKS_ARM) || defined(__GNUC__) || defined(__clang__)) && !defined (__CC_ARM) && !defined(WIN32))
+  #if (defined(__ARM_ARCH_6M__) || defined(__ARM_ARCH_8M_BASE__))
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                    unsigned int LockState;                                         \
+                                  __asm volatile ("mrs   %0, primask  \n\t"                         \
+                                                  "movs  r1, $1       \n\t"                         \
+                                                  "msr   primask, r1  \n\t"                         \
+                                                  : "=r" (LockState)                                \
+                                                  :                                                 \
+                                                  : "r1"                                            \
+                                                  );
+
+    #define SEGGER_RTT_UNLOCK()   __asm volatile ("msr   primask, %0  \n\t"                         \
+                                                  :                                                 \
+                                                  : "r" (LockState)                                 \
+                                                  :                                                 \
+                                                  );                                                \
+                                }
+  #elif (defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_8M_MAIN__))
+    #ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY
+      #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY   (0x20)
+    #endif
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                    unsigned int LockState;                                         \
+                                  __asm volatile ("mrs   %0, basepri  \n\t"                         \
+                                                  "mov   r1, %1       \n\t"                         \
+                                                  "msr   basepri, r1  \n\t"                         \
+                                                  : "=r" (LockState)                                \
+                                                  : "i"(SEGGER_RTT_MAX_INTERRUPT_PRIORITY)          \
+                                                  : "r1"                                            \
+                                                  );
+
+    #define SEGGER_RTT_UNLOCK()   __asm volatile ("msr   basepri, %0  \n\t"                         \
+                                                  :                                                 \
+                                                  : "r" (LockState)                                 \
+                                                  :                                                 \
+                                                  );                                                \
+                                }
+
+  #elif defined(__ARM_ARCH_7A__)
+    #define SEGGER_RTT_LOCK() {                                                \
+                                 unsigned int LockState;                       \
+                                 __asm volatile ("mrs r1, CPSR \n\t"           \
+                                                 "mov %0, r1 \n\t"             \
+                                                 "orr r1, r1, #0xC0 \n\t"      \
+                                                 "msr CPSR_c, r1 \n\t"         \
+                                                 : "=r" (LockState)            \
+                                                 :                             \
+                                                 : "r1"                        \
+                                                 );
+
+    #define SEGGER_RTT_UNLOCK() __asm volatile ("mov r0, %0 \n\t"              \
+                                                "mrs r1, CPSR \n\t"            \
+                                                "bic r1, r1, #0xC0 \n\t"       \
+                                                "and r0, r0, #0xC0 \n\t"       \
+                                                "orr r1, r1, r0 \n\t"          \
+                                                "msr CPSR_c, r1 \n\t"          \
+                                                :                              \
+                                                : "r" (LockState)              \
+                                                : "r0", "r1"                   \
+                                                );                             \
+                            }
+  #elif defined(__riscv) || defined(__riscv_xlen)
+    #define SEGGER_RTT_LOCK()  {                                               \
+                                 unsigned int LockState;                       \
+                                 __asm volatile ("csrr  %0, mstatus  \n\t"     \
+                                                 "csrci mstatus, 8   \n\t"     \
+                                                 "andi  %0, %0,  8   \n\t"     \
+                                                 : "=r" (LockState)            \
+                                                 :                             \
+                                                 :                             \
+                                                );
+                               
+  #define SEGGER_RTT_UNLOCK()    __asm volatile ("csrr  a1, mstatus  \n\t"     \
+                                                 "or    %0, %0, a1   \n\t"     \
+                                                 "csrs  mstatus, %0  \n\t"     \
+                                                 :                             \
+                                                 : "r"  (LockState)            \
+                                                 : "a1"                        \
+                                                );                             \
+                               }
+  #else
+    #define SEGGER_RTT_LOCK()
+    #define SEGGER_RTT_UNLOCK()
+  #endif
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for IAR EWARM
+*/
+#ifdef __ICCARM__
+  #if (defined (__ARM6M__)          && (__CORE__ == __ARM6M__))             ||                      \
+      (defined (__ARM8M_BASELINE__) && (__CORE__ == __ARM8M_BASELINE__))
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  LockState = __get_PRIMASK();                                      \
+                                  __set_PRIMASK(1);
+
+    #define SEGGER_RTT_UNLOCK()   __set_PRIMASK(LockState);                                         \
+                                }
+  #elif (defined (__ARM7EM__)         && (__CORE__ == __ARM7EM__))          ||                      \
+        (defined (__ARM7M__)          && (__CORE__ == __ARM7M__))           ||                      \
+        (defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__))  ||                      \
+        (defined (__ARM8M_MAINLINE__) && (__CORE__ == __ARM8M_MAINLINE__))
+    #ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY
+      #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY   (0x20)
+    #endif
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  LockState = __get_BASEPRI();                                      \
+                                  __set_BASEPRI(SEGGER_RTT_MAX_INTERRUPT_PRIORITY);
+
+    #define SEGGER_RTT_UNLOCK()   __set_BASEPRI(LockState);                                         \
+                                }
+  #endif
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for IAR RX
+*/
+#ifdef __ICCRX__
+  #define SEGGER_RTT_LOCK()   {                                                                     \
+                                unsigned long LockState;                                            \
+                                LockState = __get_interrupt_state();                                \
+                                __disable_interrupt();
+
+  #define SEGGER_RTT_UNLOCK()   __set_interrupt_state(LockState);                                   \
+                              }
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for IAR RL78
+*/
+#ifdef __ICCRL78__
+  #define SEGGER_RTT_LOCK()   {                                                                     \
+                                __istate_t LockState;                                               \
+                                LockState = __get_interrupt_state();                                \
+                                __disable_interrupt();
+
+  #define SEGGER_RTT_UNLOCK()   __set_interrupt_state(LockState);                                   \
+                              }
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for KEIL ARM
+*/
+#ifdef __CC_ARM
+  #if (defined __TARGET_ARCH_6S_M)
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  register unsigned char PRIMASK __asm( "primask");                 \
+                                  LockState = PRIMASK;                                              \
+                                  PRIMASK = 1u;                                                     \
+                                  __schedule_barrier();
+
+    #define SEGGER_RTT_UNLOCK()   PRIMASK = LockState;                                              \
+                                  __schedule_barrier();                                             \
+                                }
+  #elif (defined(__TARGET_ARCH_7_M) || defined(__TARGET_ARCH_7E_M))
+    #ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY
+      #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY   (0x20)
+    #endif
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  register unsigned char BASEPRI __asm( "basepri");                 \
+                                  LockState = BASEPRI;                                              \
+                                  BASEPRI = SEGGER_RTT_MAX_INTERRUPT_PRIORITY;                      \
+                                  __schedule_barrier();
+
+    #define SEGGER_RTT_UNLOCK()   BASEPRI = LockState;                                              \
+                                  __schedule_barrier();                                             \
+                                }
+  #endif
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for TI ARM
+*/
+#ifdef __TI_ARM__
+  #if defined (__TI_ARM_V6M0__)
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  LockState = __get_PRIMASK();                                      \
+                                  __set_PRIMASK(1);
+
+    #define SEGGER_RTT_UNLOCK()   __set_PRIMASK(LockState);                                         \
+                                }
+  #elif (defined (__TI_ARM_V7M3__) || defined (__TI_ARM_V7M4__))
+    #ifndef   SEGGER_RTT_MAX_INTERRUPT_PRIORITY
+      #define SEGGER_RTT_MAX_INTERRUPT_PRIORITY   (0x20)
+    #endif
+    #define SEGGER_RTT_LOCK()   {                                                                   \
+                                  unsigned int LockState;                                           \
+                                  LockState = _set_interrupt_priority(SEGGER_RTT_MAX_INTERRUPT_PRIORITY);
+
+    #define SEGGER_RTT_UNLOCK()   _set_interrupt_priority(LockState);                               \
+                                }
+  #endif
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for CCRX
+*/
+#ifdef __RX
+  #define SEGGER_RTT_LOCK()   {                                                                     \
+                                unsigned long LockState;                                            \
+                                LockState = get_psw() & 0x010000;                                   \
+                                clrpsw_i();                           
+                                    
+  #define SEGGER_RTT_UNLOCK()   set_psw(get_psw() | LockState);                                     \
+                              }
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration for embOS Simulation on Windows
+*       (Can also be used for generic RTT locking with embOS)
+*/
+#if defined(WIN32) || defined(SEGGER_RTT_LOCK_EMBOS)
+
+void OS_SIM_EnterCriticalSection(void);
+void OS_SIM_LeaveCriticalSection(void);
+
+#define SEGGER_RTT_LOCK()       {                                                                   \
+                                  OS_SIM_EnterCriticalSection();
+
+#define SEGGER_RTT_UNLOCK()       OS_SIM_LeaveCriticalSection();                                    \
+                                }
+#endif
+
+/*********************************************************************
+*
+*       RTT lock configuration fallback
+*/
+#ifndef   SEGGER_RTT_LOCK
+  #define SEGGER_RTT_LOCK()                // Lock RTT (nestable)   (i.e. disable interrupts)
+#endif
+
+#ifndef   SEGGER_RTT_UNLOCK
+  #define SEGGER_RTT_UNLOCK()              // Unlock RTT (nestable) (i.e. enable previous interrupt lock state)
+#endif
+
+#endif
+/*************************** End of file ****************************/

lib/segger_rtt/src/SEGGER_RTT_ASM_ARMv7M.S

@@ -0,0 +1,235 @@
+/*********************************************************************
+*                   (c) SEGGER Microcontroller GmbH                  *
+*                        The Embedded Experts                        *
+*                           www.segger.com                           *
+**********************************************************************
+
+-------------------------- END-OF-HEADER -----------------------------
+
+File    : SEGGER_RTT_ASM_ARMv7M.S
+Purpose : Assembler implementation of RTT functions for ARMv7M
+
+Additional information:
+  This module is written to be assembler-independent and works with
+  GCC and clang (Embedded Studio) and IAR.
+*/
+
+#define SEGGER_RTT_ASM      // Used to control processed input from header file
+#include "SEGGER_RTT.h"
+
+/*********************************************************************
+*
+*       Defines, fixed
+*
+**********************************************************************
+*/
+#define _CCIAR   0
+#define _CCCLANG 1
+
+#if (defined __SES_ARM) || (defined __GNUC__) || (defined __clang__)
+  #define _CC_TYPE             _CCCLANG
+  #define _PUB_SYM             .global
+  #define _EXT_SYM             .extern
+  #define _END                 .end
+  #define _WEAK                .weak
+  #define _THUMB_FUNC          .thumb_func
+  #define _THUMB_CODE          .code 16
+  #define _WORD                .word
+  #define _SECTION(Sect, Type, AlignExp) .section Sect ##, "ax"
+  #define _ALIGN(Exp)          .align Exp 
+  #define _PLACE_LITS          .ltorg
+  #define _DATA_SECT_START 
+  #define _C_STARTUP           _start
+  #define _STACK_END           __stack_end__
+  #define _RAMFUNC
+  //
+  // .text     => Link to flash
+  // .fast     => Link to RAM
+  // OtherSect => Usually link to RAM
+  // Alignment is 2^x
+  //
+#elif defined (__IASMARM__)
+  #define _CC_TYPE             _CCIAR
+  #define _PUB_SYM             PUBLIC
+  #define _EXT_SYM             EXTERN
+  #define _END                 END
+  #define _WEAK                _WEAK
+  #define _THUMB_FUNC
+  #define _THUMB_CODE          THUMB
+  #define _WORD                DCD
+  #define _SECTION(Sect, Type, AlignExp) SECTION Sect ## : ## Type ## :REORDER:NOROOT ## (AlignExp)
+  #define _ALIGN(Exp)          alignrom Exp 
+  #define _PLACE_LITS
+  #define _DATA_SECT_START     DATA
+  #define _C_STARTUP           __iar_program_start
+  #define _STACK_END           sfe(CSTACK)
+  #define _RAMFUNC             SECTION_TYPE SHT_PROGBITS, SHF_WRITE | SHF_EXECINSTR
+  //
+  // .text     => Link to flash
+  // .textrw   => Link to RAM
+  // OtherSect => Usually link to RAM
+  // NOROOT    => Allows linker to throw away the function, if not referenced
+  // Alignment is 2^x
+  //
+#endif
+
+#if (_CC_TYPE == _CCIAR)
+        NAME SEGGER_RTT_ASM_ARMv7M
+#else
+        .syntax unified
+#endif
+
+#if defined (RTT_USE_ASM) && (RTT_USE_ASM == 1)
+        #define SHT_PROGBITS 0x1
+
+/*********************************************************************
+*
+*       Public / external symbols
+*
+**********************************************************************
+*/
+
+        _EXT_SYM __aeabi_memcpy
+        _EXT_SYM __aeabi_memcpy4
+        _EXT_SYM _SEGGER_RTT
+
+        _PUB_SYM SEGGER_RTT_ASM_WriteSkipNoLock
+
+/*********************************************************************
+*
+*       SEGGER_RTT_WriteSkipNoLock
+*
+*  Function description
+*    Stores a specified number of characters in SEGGER RTT
+*    control block which is then read by the host.
+*    SEGGER_RTT_WriteSkipNoLock does not lock the application and
+*    skips all data, if the data does not fit into the buffer.
+*
+*  Parameters
+*    BufferIndex  Index of "Up"-buffer to be used (e.g. 0 for "Terminal").
+*    pBuffer      Pointer to character array. Does not need to point to a \0 terminated string.
+*    NumBytes     Number of bytes to be stored in the SEGGER RTT control block.
+*                 MUST be > 0!!!
+*                 This is done for performance reasons, so no initial check has do be done.
+*
+*  Return value
+*    1: Data has been copied
+*    0: No space, data has not been copied
+*
+*  Notes
+*    (1) If there is not enough space in the "Up"-buffer, all data is dropped.
+*    (2) For performance reasons this function does not call Init()
+*        and may only be called after RTT has been initialized.
+*        Either by calling SEGGER_RTT_Init() or calling another RTT API function first.
+*/
+        _SECTION(.text, CODE, 2)
+        _ALIGN(2)
+        _THUMB_FUNC
+SEGGER_RTT_ASM_WriteSkipNoLock:   // unsigned SEGGER_RTT_WriteSkipNoLock(unsigned BufferIndex, const void* pData, unsigned NumBytes) {
+        //
+        // Cases:
+        //   1) RdOff <= WrOff => Space until wrap-around is sufficient
+        //   2) RdOff <= WrOff => Space after wrap-around needed (copy in 2 chunks)
+        //   3) RdOff <  WrOff => No space in buf
+        //   4) RdOff >  WrOff => Space is sufficient
+        //   5) RdOff >  WrOff => No space in buf
+        //
+        // 1) is the most common case for large buffers and assuming that J-Link reads the data fast enough
+        //
+        // Register usage:
+        //   R0 Temporary needed as RdOff, <Tmp> register later on
+        //   R1 pData
+        //   R2 <NumBytes>
+        //   R3 <Tmp> register. Hold free for subroutine calls
+        //   R4 <Rem>
+        //   R5 pRing->pBuffer
+        //   R6 pRing (Points to active struct SEGGER_RTT_BUFFER_DOWN)
+        //   R7 WrOff
+        //
+        PUSH     {R4-R7}
+        ADD      R3,R0,R0, LSL #+1
+        LDR.W    R0,=_SEGGER_RTT                 // pRing = &_SEGGER_RTT.aUp[BufferIndex];
+        ADD      R0,R0,R3, LSL #+3
+        ADD      R6,R0,#+24
+        LDR      R0,[R6, #+16]                   // RdOff = pRing->RdOff;
+        LDR      R7,[R6, #+12]                   // WrOff = pRing->WrOff;
+        LDR      R5,[R6, #+4]                    // pRing->pBuffer
+        CMP      R7,R0
+        BCC.N    _CheckCase4                     // if (RdOff <= WrOff) {                           => Case 1), 2) or 3)
+        //
+        // Handling for case 1, later on identical to case 4
+        //
+        LDR      R3,[R6, #+8]                    //  Avail = pRing->SizeOfBuffer - WrOff - 1u;      => Space until wrap-around (assume 1 byte not usable for case that RdOff == 0)
+        SUBS     R4,R3,R7                        // <Rem> (Used in case we jump into case 2 afterwards)
+        SUBS     R3,R4,#+1                       // <Avail>
+        CMP      R3,R2
+        BCC.N    _CheckCase2                     // if (Avail >= NumBytes) {  => Case 1)?
+_Case4:
+        ADDS     R5,R7,R5                        // pBuffer += WrOff
+        ADDS     R0,R2,R7                        // v = WrOff + NumBytes
+        //
+        // 2x unrolling for the copy loop that is used most of the time
+        // This is a special optimization for small SystemView packets and makes them even faster
+        //
+        _ALIGN(2)
+_LoopCopyStraight:                               // memcpy(pRing->pBuffer + WrOff, pData, NumBytes);
+        LDRB     R3,[R1], #+1
+        STRB     R3,[R5], #+1                    // *pDest++ = *pSrc++
+        SUBS     R2,R2,#+1
+        BEQ      _CSDone
+        LDRB     R3,[R1], #+1
+        STRB     R3,[R5], #+1                    // *pDest++ = *pSrc++
+        SUBS     R2,R2,#+1
+        BNE      _LoopCopyStraight
+_CSDone:
+        STR      R0,[R6, #+12]                   // pRing->WrOff = WrOff + NumBytes;
+        MOVS     R0,#+1
+        POP      {R4-R7}
+        BX       LR                              // Return 1
+_CheckCase2:
+        ADDS     R0,R0,R3                        // Avail += RdOff; => Space incl. wrap-around
+        CMP      R0,R2
+        BCC.N    _Case3                          // if (Avail >= NumBytes) {           => Case 2? => If not, we have case 3) (does not fit)
+        //
+        // Handling for case 2
+        //
+        ADDS     R0,R7,R5                        // v = pRing->pBuffer + WrOff => Do not change pRing->pBuffer here because 2nd chunk needs org. value
+        SUBS     R2,R2,R4                        // NumBytes -= Rem;  (Rem = pRing->SizeOfBuffer - WrOff; => Space until end of buffer)
+_LoopCopyBeforeWrapAround:                       // memcpy(pRing->pBuffer + WrOff, pData, Rem); => Copy 1st chunk
+        LDRB     R3,[R1], #+1
+        STRB     R3,[R0], #+1                    // *pDest++ = *pSrc++
+        SUBS     R4,R4,#+1
+        BNE      _LoopCopyBeforeWrapAround
+        //
+        // Special case: First check that assumed RdOff == 0 calculated that last element before wrap-around could not be used
+        // But 2nd check (considering space until wrap-around and until RdOff) revealed that RdOff is not 0, so we can use the last element
+        // In this case, we may use a copy straight until buffer end anyway without needing to copy 2 chunks
+        // Therefore, check if 2nd memcpy is necessary at all
+        //
+        ADDS     R4,R2,#+0                       // Save <NumBytes> (needed as counter in loop but must be written to <WrOff> after the loop). Also use this inst to update the flags to skip 2nd loop if possible
+        BEQ.N    _No2ChunkNeeded                 // if (NumBytes) {
+_LoopCopyAfterWrapAround:                        // memcpy(pRing->pBuffer, pData + Rem, NumBytes);
+        LDRB     R3,[R1], #+1                    // pData already points to the next src byte due to copy loop increment before this loop
+        STRB     R3,[R5], #+1                    // *pDest++ = *pSrc++
+        SUBS     R2,R2,#+1
+        BNE      _LoopCopyAfterWrapAround
+_No2ChunkNeeded:
+        STR      R4,[R6, #+12]                   // pRing->WrOff = NumBytes; => Must be written after copying data because J-Link may read control block asynchronously while writing into buffer
+        MOVS     R0,#+1
+        POP      {R4-R7}
+        BX       LR                              // Return 1
+_CheckCase4:
+        SUBS     R0,R0,R7
+        SUBS     R0,R0,#+1                       // Avail = RdOff - WrOff - 1u;
+        CMP      R0,R2
+        BCS.N    _Case4                          // if (Avail >= NumBytes) {      => Case 4) == 1) ? => If not, we have case 5) == 3) (does not fit)
+_Case3:
+        MOVS     R0,#+0
+        POP      {R4-R7}
+        BX       LR                              // Return 0
+        _PLACE_LITS
+
+#endif  // defined (RTT_USE_ASM) && (RTT_USE_ASM == 1)
+        _END
+
+/*************************** End of file ****************************/

lib/segger_rtt/src/SEGGER_RTT_printf.c

@@ -0,0 +1,500 @@
+/*********************************************************************
+*                    SEGGER Microcontroller GmbH                     *
+*                        The Embedded Experts                        *
+**********************************************************************
+*                                                                    *
+*            (c) 1995 - 2019 SEGGER Microcontroller GmbH             *
+*                                                                    *
+*       www.segger.com     Support: support@segger.com               *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+*       SEGGER RTT * Real Time Transfer for embedded targets         *
+*                                                                    *
+**********************************************************************
+*                                                                    *
+* All rights reserved.                                               *
+*                                                                    *
+* SEGGER strongly recommends to not make any changes                 *
+* to or modify the source code of this software in order to stay     *
+* compatible with the RTT protocol and J-Link.                       *
+*                                                                    *
+* Redistribution and use in source and binary forms, with or         *
+* without modification, are permitted provided that the following    *
+* condition is met:                                                  *
+*                                                                    *
+* o Redistributions of source code must retain the above copyright   *
+*   notice, this condition and the following disclaimer.             *
+*                                                                    *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND             *
+* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,        *
+* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF           *
+* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE           *
+* DISCLAIMED. IN NO EVENT SHALL SEGGER Microcontroller BE LIABLE FOR *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           *
+* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  *
+* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;    *
+* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF      *
+* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT          *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE  *
+* USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH   *
+* DAMAGE.                                                            *
+*                                                                    *
+**********************************************************************
+---------------------------END-OF-HEADER------------------------------
+File    : SEGGER_RTT_printf.c
+Purpose : Replacement for printf to write formatted data via RTT
+Revision: $Rev: 17697 $
+----------------------------------------------------------------------
+*/
+#include "SEGGER_RTT.h"
+#include "SEGGER_RTT_Conf.h"
+
+/*********************************************************************
+*
+*       Defines, configurable
+*
+**********************************************************************
+*/
+
+#ifndef SEGGER_RTT_PRINTF_BUFFER_SIZE
+  #define SEGGER_RTT_PRINTF_BUFFER_SIZE (64)
+#endif
+
+#include <stdlib.h>
+#include <stdarg.h>
+
+
+#define FORMAT_FLAG_LEFT_JUSTIFY   (1u << 0)
+#define FORMAT_FLAG_PAD_ZERO       (1u << 1)
+#define FORMAT_FLAG_PRINT_SIGN     (1u << 2)
+#define FORMAT_FLAG_ALTERNATE      (1u << 3)
+
+/*********************************************************************
+*
+*       Types
+*
+**********************************************************************
+*/
+
+typedef struct {
+  char*     pBuffer;
+  unsigned  BufferSize;
+  unsigned  Cnt;
+
+  int   ReturnValue;
+
+  unsigned RTTBufferIndex;
+} SEGGER_RTT_PRINTF_DESC;
+
+/*********************************************************************
+*
+*       Function prototypes
+*
+**********************************************************************
+*/
+
+/*********************************************************************
+*
+*       Static code
+*
+**********************************************************************
+*/
+/*********************************************************************
+*
+*       _StoreChar
+*/
+static void _StoreChar(SEGGER_RTT_PRINTF_DESC * p, char c) {
+  unsigned Cnt;
+
+  Cnt = p->Cnt;
+  if ((Cnt + 1u) <= p->BufferSize) {
+    *(p->pBuffer + Cnt) = c;
+    p->Cnt = Cnt + 1u;
+    p->ReturnValue++;
+  }
+  //
+  // Write part of string, when the buffer is full
+  //
+  if (p->Cnt == p->BufferSize) {
+    if (SEGGER_RTT_Write(p->RTTBufferIndex, p->pBuffer, p->Cnt) != p->Cnt) {
+      p->ReturnValue = -1;
+    } else {
+      p->Cnt = 0u;
+    }
+  }
+}
+
+/*********************************************************************
+*
+*       _PrintUnsigned
+*/
+static void _PrintUnsigned(SEGGER_RTT_PRINTF_DESC * pBufferDesc, unsigned v, unsigned Base, unsigned NumDigits, unsigned FieldWidth, unsigned FormatFlags) {
+  static const char _aV2C[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+  unsigned Div;
+  unsigned Digit;
+  unsigned Number;
+  unsigned Width;
+  char c;
+
+  Number = v;
+  Digit = 1u;
+  //
+  // Get actual field width
+  //
+  Width = 1u;
+  while (Number >= Base) {
+    Number = (Number / Base);
+    Width++;
+  }
+  if (NumDigits > Width) {
+    Width = NumDigits;
+  }
+  //
+  // Print leading chars if necessary
+  //
+  if ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0u) {
+    if (FieldWidth != 0u) {
+      if (((FormatFlags & FORMAT_FLAG_PAD_ZERO) == FORMAT_FLAG_PAD_ZERO) && (NumDigits == 0u)) {
+        c = '0';
+      } else {
+        c = ' ';
+      }
+      while ((FieldWidth != 0u) && (Width < FieldWidth)) {
+        FieldWidth--;
+        _StoreChar(pBufferDesc, c);
+        if (pBufferDesc->ReturnValue < 0) {
+          break;
+        }
+      }
+    }
+  }
+  if (pBufferDesc->ReturnValue >= 0) {
+    //
+    // Compute Digit.
+    // Loop until Digit has the value of the highest digit required.
+    // Example: If the output is 345 (Base 10), loop 2 times until Digit is 100.
+    //
+    while (1) {
+      if (NumDigits > 1u) {       // User specified a min number of digits to print? => Make sure we loop at least that often, before checking anything else (> 1 check avoids problems with NumDigits being signed / unsigned)
+        NumDigits--;
+      } else {
+        Div = v / Digit;
+        if (Div < Base) {        // Is our divider big enough to extract the highest digit from value? => Done
+          break;
+        }
+      }
+      Digit *= Base;
+    }
+    //
+    // Output digits
+    //
+    do {
+      Div = v / Digit;
+      v -= Div * Digit;
+      _StoreChar(pBufferDesc, _aV2C[Div]);
+      if (pBufferDesc->ReturnValue < 0) {
+        break;
+      }
+      Digit /= Base;
+    } while (Digit);
+    //
+    // Print trailing spaces if necessary
+    //
+    if ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == FORMAT_FLAG_LEFT_JUSTIFY) {
+      if (FieldWidth != 0u) {
+        while ((FieldWidth != 0u) && (Width < FieldWidth)) {
+          FieldWidth--;
+          _StoreChar(pBufferDesc, ' ');
+          if (pBufferDesc->ReturnValue < 0) {
+            break;
+          }
+        }
+      }
+    }
+  }
+}
+
+/*********************************************************************
+*
+*       _PrintInt
+*/
+static void _PrintInt(SEGGER_RTT_PRINTF_DESC * pBufferDesc, int v, unsigned Base, unsigned NumDigits, unsigned FieldWidth, unsigned FormatFlags) {
+  unsigned Width;
+  int Number;
+
+  Number = (v < 0) ? -v : v;
+
+  //
+  // Get actual field width
+  //
+  Width = 1u;
+  while (Number >= (int)Base) {
+    Number = (Number / (int)Base);
+    Width++;
+  }
+  if (NumDigits > Width) {
+    Width = NumDigits;
+  }
+  if ((FieldWidth > 0u) && ((v < 0) || ((FormatFlags & FORMAT_FLAG_PRINT_SIGN) == FORMAT_FLAG_PRINT_SIGN))) {
+    FieldWidth--;
+  }
+
+  //
+  // Print leading spaces if necessary
+  //
+  if ((((FormatFlags & FORMAT_FLAG_PAD_ZERO) == 0u) || (NumDigits != 0u)) && ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0u)) {
+    if (FieldWidth != 0u) {
+      while ((FieldWidth != 0u) && (Width < FieldWidth)) {
+        FieldWidth--;
+        _StoreChar(pBufferDesc, ' ');
+        if (pBufferDesc->ReturnValue < 0) {
+          break;
+        }
+      }
+    }
+  }
+  //
+  // Print sign if necessary
+  //
+  if (pBufferDesc->ReturnValue >= 0) {
+    if (v < 0) {
+      v = -v;
+      _StoreChar(pBufferDesc, '-');
+    } else if ((FormatFlags & FORMAT_FLAG_PRINT_SIGN) == FORMAT_FLAG_PRINT_SIGN) {
+      _StoreChar(pBufferDesc, '+');
+    } else {
+
+    }
+    if (pBufferDesc->ReturnValue >= 0) {
+      //
+      // Print leading zeros if necessary
+      //
+      if (((FormatFlags & FORMAT_FLAG_PAD_ZERO) == FORMAT_FLAG_PAD_ZERO) && ((FormatFlags & FORMAT_FLAG_LEFT_JUSTIFY) == 0u) && (NumDigits == 0u)) {
+        if (FieldWidth != 0u) {
+          while ((FieldWidth != 0u) && (Width < FieldWidth)) {
+            FieldWidth--;
+            _StoreChar(pBufferDesc, '0');
+            if (pBufferDesc->ReturnValue < 0) {
+              break;
+            }
+          }
+        }
+      }
+      if (pBufferDesc->ReturnValue >= 0) {
+        //
+        // Print number without sign
+        //
+        _PrintUnsigned(pBufferDesc, (unsigned)v, Base, NumDigits, FieldWidth, FormatFlags);
+      }
+    }
+  }
+}
+
+/*********************************************************************
+*
+*       Public code
+*
+**********************************************************************
+*/
+/*********************************************************************
+*
+*       SEGGER_RTT_vprintf
+*
+*  Function description
+*    Stores a formatted string in SEGGER RTT control block.
+*    This data is read by the host.
+*
+*  Parameters
+*    BufferIndex  Index of "Up"-buffer to be used. (e.g. 0 for "Terminal")
+*    sFormat      Pointer to format string
+*    pParamList   Pointer to the list of arguments for the format string
+*
+*  Return values
+*    >= 0:  Number of bytes which have been stored in the "Up"-buffer.
+*     < 0:  Error
+*/
+int SEGGER_RTT_vprintf(unsigned BufferIndex, const char * sFormat, va_list * pParamList) {
+  char c;
+  SEGGER_RTT_PRINTF_DESC BufferDesc;
+  int v;
+  unsigned NumDigits;
+  unsigned FormatFlags;
+  unsigned FieldWidth;
+  char acBuffer[SEGGER_RTT_PRINTF_BUFFER_SIZE];
+
+  BufferDesc.pBuffer        = acBuffer;
+  BufferDesc.BufferSize     = SEGGER_RTT_PRINTF_BUFFER_SIZE;
+  BufferDesc.Cnt            = 0u;
+  BufferDesc.RTTBufferIndex = BufferIndex;
+  BufferDesc.ReturnValue    = 0;
+
+  do {
+    c = *sFormat;
+    sFormat++;
+    if (c == 0u) {
+      break;
+    }
+    if (c == '%') {
+      //
+      // Filter out flags
+      //
+      FormatFlags = 0u;
+      v = 1;
+      do {
+        c = *sFormat;
+        switch (c) {
+        case '-': FormatFlags |= FORMAT_FLAG_LEFT_JUSTIFY; sFormat++; break;
+        case '0': FormatFlags |= FORMAT_FLAG_PAD_ZERO;     sFormat++; break;
+        case '+': FormatFlags |= FORMAT_FLAG_PRINT_SIGN;   sFormat++; break;
+        case '#': FormatFlags |= FORMAT_FLAG_ALTERNATE;    sFormat++; break;
+        default:  v = 0; break;
+        }
+      } while (v);
+      //
+      // filter out field with
+      //
+      FieldWidth = 0u;
+      do {
+        c = *sFormat;
+        if ((c < '0') || (c > '9')) {
+          break;
+        }
+        sFormat++;
+        FieldWidth = (FieldWidth * 10u) + ((unsigned)c - '0');
+      } while (1);
+
+      //
+      // Filter out precision (number of digits to display)
+      //
+      NumDigits = 0u;
+      c = *sFormat;
+      if (c == '.') {
+        sFormat++;
+        do {
+          c = *sFormat;
+          if ((c < '0') || (c > '9')) {
+            break;
+          }
+          sFormat++;
+          NumDigits = NumDigits * 10u + ((unsigned)c - '0');
+        } while (1);
+      }
+      //
+      // Filter out length modifier
+      //
+      c = *sFormat;
+      do {
+        if ((c == 'l') || (c == 'h')) {
+          sFormat++;
+          c = *sFormat;
+        } else {
+          break;
+        }
+      } while (1);
+      //
+      // Handle specifiers
+      //
+      switch (c) {
+      case 'c': {
+        char c0;
+        v = va_arg(*pParamList, int);
+        c0 = (char)v;
+        _StoreChar(&BufferDesc, c0);
+        break;
+      }
+      case 'd':
+        v = va_arg(*pParamList, int);
+        _PrintInt(&BufferDesc, v, 10u, NumDigits, FieldWidth, FormatFlags);
+        break;
+      case 'u':
+        v = va_arg(*pParamList, int);
+        _PrintUnsigned(&BufferDesc, (unsigned)v, 10u, NumDigits, FieldWidth, FormatFlags);
+        break;
+      case 'x':
+      case 'X':
+        v = va_arg(*pParamList, int);
+        _PrintUnsigned(&BufferDesc, (unsigned)v, 16u, NumDigits, FieldWidth, FormatFlags);
+        break;
+      case 's':
+        {
+          const char * s = va_arg(*pParamList, const char *);
+          do {
+            c = *s;
+            s++;
+            if (c == '\0') {
+              break;
+            }
+           _StoreChar(&BufferDesc, c);
+          } while (BufferDesc.ReturnValue >= 0);
+        }
+        break;
+      case 'p':
+        v = va_arg(*pParamList, int);
+        _PrintUnsigned(&BufferDesc, (unsigned)v, 16u, 8u, 8u, 0u);
+        break;
+      case '%':
+        _StoreChar(&BufferDesc, '%');
+        break;
+      default:
+        break;
+      }
+      sFormat++;
+    } else {
+      _StoreChar(&BufferDesc, c);
+    }
+  } while (BufferDesc.ReturnValue >= 0);
+
+  if (BufferDesc.ReturnValue > 0) {
+    //
+    // Write remaining data, if any
+    //
+    if (BufferDesc.Cnt != 0u) {
+      SEGGER_RTT_Write(BufferIndex, acBuffer, BufferDesc.Cnt);
+    }
+    BufferDesc.ReturnValue += (int)BufferDesc.Cnt;
+  }
+  return BufferDesc.ReturnValue;
+}
+
+/*********************************************************************
+*
+*       SEGGER_RTT_printf
+*
+*  Function description
+*    Stores a formatted string in SEGGER RTT control block.
+*    This data is read by the host.
+*
+*  Parameters
+*    BufferIndex  Index of "Up"-buffer to be used. (e.g. 0 for "Terminal")
+*    sFormat      Pointer to format string, followed by the arguments for conversion
+*
+*  Return values
+*    >= 0:  Number of bytes which have been stored in the "Up"-buffer.
+*     < 0:  Error
+*
+*  Notes
+*    (1) Conversion specifications have following syntax:
+*          %[flags][FieldWidth][.Precision]ConversionSpecifier
+*    (2) Supported flags:
+*          -: Left justify within the field width
+*          +: Always print sign extension for signed conversions
+*          0: Pad with 0 instead of spaces. Ignored when using '-'-flag or precision
+*        Supported conversion specifiers:
+*          c: Print the argument as one char
+*          d: Print the argument as a signed integer
+*          u: Print the argument as an unsigned integer
+*          x: Print the argument as an hexadecimal integer
+*          s: Print the string pointed to by the argument
+*          p: Print the argument as an 8-digit hexadecimal integer. (Argument shall be a pointer to void.)
+*/
+int SEGGER_RTT_printf(unsigned BufferIndex, const char * sFormat, ...) {
+  int r;
+  va_list ParamList;
+
+  va_start(ParamList, sFormat);
+  r = SEGGER_RTT_vprintf(BufferIndex, sFormat, &ParamList);
+  va_end(ParamList);
+  return r;
+}
+/*************************** End of file ****************************/

platformio.ini

@@ -9,12 +9,17 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-default_envs = tbeam
+default_envs = tbeam ; Note: the github actions CI test build can't yet build NRF52 targets
 
 [common]
-; default to a US frequency range, change it as needed for your region and hardware (CN, JP, EU433, EU865)
-hw_version = US
+; common is not currently used
 
+; REQUIRED environment variables - if not set the specified default will be sued
+; The following environment variables must be set in the shell if you'd like to override them.
+; They are used in this ini file as systenv.VARNAME, so in your shell do export "VARNAME=fish"
+; HW_VERSION (default US)
+; APP_VERSION (default emptystring)
+; HW_VERSION (default emptystring)
 
 [env]
 platform = espressif32
@@ -26,7 +31,11 @@ board_build.partitions = partition-table.csv
 
 ; note: we add src to our include search path so that lmic_project_config can override
 ; FIXME: fix lib/BluetoothOTA dependency back on src/ so we can remove -Isrc
-build_flags = -Wno-missing-field-initializers -Isrc -Isrc/rf95 -Os -Wl,-Map,.pio/build/output.map -DAXP_DEBUG_PORT=Serial -DHW_VERSION_${common.hw_version}
+build_flags = -Wno-missing-field-initializers -Isrc -Isrc/mesh -Isrc/gps -Ilib/nanopb/include -Os -Wl,-Map,.pio/build/output.map 
+  -DAXP_DEBUG_PORT=Serial 
+  -DHW_VERSION_${sysenv.COUNTRY}
+  -DAPP_VERSION=${sysenv.APP_VERSION}
+  -DHW_VERSION=${sysenv.HW_VERSION}
 
 ; not needed included in ttgo-t-beam board file
 ; also to use PSRAM https://docs.platformio.org/en/latest/platforms/espressif32.html#external-ram-psram
@@ -42,7 +51,7 @@ build_flags = -Wno-missing-field-initializers -Isrc -Isrc/rf95 -Os -Wl,-Map,.pio
 ; the default is esptool
 ; upload_protocol = esp-prog
 
-monitor_speed = 115200
+monitor_speed = 921600
 
 # debug_tool = esp-prog
 # debug_port = /dev/ttyACM0
@@ -64,15 +73,18 @@ lib_deps =
   Wire ; explicitly needed here because the AXP202 library forgets to add it
   https://github.com/meshtastic/arduino-fsm.git 
   https://github.com/meshtastic/SparkFun_Ublox_Arduino_Library.git
+  https://github.com/meshtastic/RadioLib.git
+  https://github.com/meshtastic/TinyGPSPlus.git 
   
 ; Common settings for ESP targes, mixin with extends = esp32_base
 [esp32_base]
 src_filter = 
-  ${env.src_filter} -<bare/>
+  ${env.src_filter} -<nrf52/>
 upload_speed = 921600
 debug_init_break = tbreak setup
 build_flags =
   ${env.build_flags} -Wall -Wextra
+lib_ignore = segger_rtt
 
 ; The 1.0 release of the TBEAM board
 [env:tbeam]
@@ -111,18 +123,30 @@ build_flags =
   ${esp32_base.build_flags} -D TTGO_LORA_V2
 
 
-; This is a temporary build target to test turning off particular hardare bits in the build (to improve modularity)
-[env:bare]
+; The NRF52840-dk development board
+[env:nrf52dk]
 platform = nordicnrf52
-board = nrf52840_dk_adafruit ; nicer than nrf52840_dk - more full gpio mappings
+board = ppr
 framework = arduino
 debug_tool = jlink
+build_type = debug ; I'm debugging with ICE a lot now
 build_flags = 
-  ${env.build_flags} -D BARE_BOARD -Wno-unused-variable -Isrc/bare
+  ${env.build_flags} -Wno-unused-variable -Isrc/nrf52
 src_filter = 
   ${env.src_filter} -<esp32/>
 lib_ignore =
   BluetoothOTA
 lib_deps = 
   ${env.lib_deps}
+  UC1701
+  https://github.com/meshtastic/BQ25703A.git
 monitor_port = /dev/ttyACM1
+
+debug_extra_cmds =
+  source gdbinit
+
+; Set initial breakpoint (defaults to main)
+debug_init_break =
+;debug_init_break = tbreak loop
+;debug_init_break = tbreak Reset_Handler
+

src/GPS.cpp

@@ -1,222 +0,0 @@
-
-#include "GPS.h"
-#include "configuration.h"
-#include "time.h"
-#include <assert.h>
-#include <sys/time.h>
-
-#ifdef GPS_RX_PIN
-HardwareSerial _serial_gps(GPS_SERIAL_NUM);
-#else
-// Assume NRF52
-// Uart _serial_gps(GPS_SERIAL_NUM);
-#endif
-
-bool timeSetFromGPS; // We try to set our time from GPS each time we wake from sleep
-
-GPS gps;
-
-// stuff that really should be in in the instance instead...
-static uint32_t
-    timeStartMsec; // Once we have a GPS lock, this is where we hold the initial msec clock that corresponds to that time
-static uint64_t zeroOffsetSecs; // GPS based time in secs since 1970 - only updated once on initial lock
-
-static bool wantNewLocation = true;
-
-GPS::GPS() : PeriodicTask() {}
-
-void GPS::setup()
-{
-    readFromRTC(); // read the main CPU RTC at first
-
-#ifdef GPS_RX_PIN
-    _serial_gps.begin(GPS_BAUDRATE, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
-    // _serial_gps.setRxBufferSize(1024); // the default is 256
-    // ublox.enableDebugging(Serial);
-
-    // note: the lib's implementation has the wrong docs for what the return val is
-    // it is not a bool, it returns zero for success
-    isConnected = ublox.begin(_serial_gps);
-
-    // try a second time, the ublox lib serial parsing is buggy?
-    if (!isConnected)
-        isConnected = ublox.begin(_serial_gps);
-
-    if (isConnected) {
-        DEBUG_MSG("Connected to GPS successfully, TXpin=%d\n", GPS_TX_PIN);
-
-        bool factoryReset = false;
-        bool ok;
-        if (factoryReset) {
-            // It is useful to force back into factory defaults (9600baud, NEMA to test the behavior of boards that don't have
-            // GPS_TX connected)
-            ublox.factoryReset();
-            delay(2000);
-            isConnected = ublox.begin(_serial_gps);
-            DEBUG_MSG("Factory reset success=%d\n", isConnected);
-            if (isConnected) {
-                ublox.assumeAutoPVT(true, true); // Just parse NEMA for now
-            }
-        } else {
-            ok = ublox.setUART1Output(COM_TYPE_UBX, 500); // Use native API
-            assert(ok);
-            ok = ublox.setNavigationFrequency(1, 500); // Produce 4x/sec to keep the amount of time we stall in getPVT low
-            assert(ok);
-            // ok = ublox.setAutoPVT(false); // Not implemented on NEO-6M
-            // assert(ok);
-            // ok = ublox.setDynamicModel(DYN_MODEL_BIKE); // probably PEDESTRIAN but just in case assume bike speeds
-            // assert(ok);
-            ok = ublox.powerSaveMode(); // use power save mode
-            assert(ok);
-        }
-        ok = ublox.saveConfiguration(2000);
-        assert(ok);
-    } else {
-        // Some boards might have only the TX line from the GPS connected, in that case, we can't configure it at all.  Just
-        // assume NEMA at 9600 baud.
-        DEBUG_MSG("ERROR: No bidirectional GPS found, hoping that it still might work\n");
-
-        // tell lib, we are expecting the module to send PVT messages by itself to our Rx pin
-        // you can set second parameter to "false" if you want to control the parsing and eviction of the data (need to call
-        // checkUblox cyclically)
-        ublox.assumeAutoPVT(true, true);
-    }
-#endif
-}
-
-void GPS::readFromRTC()
-{
-    struct timeval tv; /* btw settimeofday() is helpfull here too*/
-
-    if (!gettimeofday(&tv, NULL)) {
-        uint32_t now = millis();
-
-        DEBUG_MSG("Read RTC time as %ld (cur millis %u) valid=%d\n", tv.tv_sec, now, timeSetFromGPS);
-        timeStartMsec = now;
-        zeroOffsetSecs = tv.tv_sec;
-    }
-}
-
-/// If we haven't yet set our RTC this boot, set it from a GPS derived time
-void GPS::perhapsSetRTC(const struct timeval *tv)
-{
-    if (!timeSetFromGPS) {
-        timeSetFromGPS = true;
-        DEBUG_MSG("Setting RTC %ld secs\n", tv->tv_sec);
-#ifndef NO_ESP32
-        settimeofday(tv, NULL);
-#else
-        assert(0);
-#endif
-        readFromRTC();
-    }
-}
-
-#include <time.h>
-
-// for the time being we need to rapidly read from the serial port to prevent overruns
-void GPS::loop()
-{
-    PeriodicTask::loop();
-}
-
-uint32_t GPS::getTime()
-{
-    return ((millis() - timeStartMsec) / 1000) + zeroOffsetSecs;
-}
-
-uint32_t GPS::getValidTime()
-{
-    return timeSetFromGPS ? getTime() : 0;
-}
-
-/// Returns true if we think the board can enter deep or light sleep now (we might be trying to get a GPS lock)
-bool GPS::canSleep()
-{
-    return true; // we leave GPS on during sleep now, so sleep is okay !wantNewLocation;
-}
-
-/// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
-void GPS::prepareSleep()
-{
-    if (isConnected)
-        ublox.powerOff();
-}
-
-void GPS::doTask()
-{
-#ifdef GPS_RX_PIN
-    uint8_t fixtype = 3; // If we are only using the RX pin, assume we have a 3d fix
-
-    if (isConnected) {
-        // Consume all characters that have arrived
-
-        // getPVT automatically calls checkUblox
-        ublox.checkUblox(); // See if new data is available. Process bytes as they come in.
-
-        // If we don't have a fix (a quick check), don't try waiting for a solution)
-        // Hmmm my fix type reading returns zeros for fix, which doesn't seem correct, because it is still sptting out positions
-        // turn off for now
-        // fixtype = ublox.getFixType();
-        DEBUG_MSG("fix type %d\n", fixtype);
-    }
-
-    // DEBUG_MSG("sec %d\n", ublox.getSecond());
-    // DEBUG_MSG("lat %d\n", ublox.getLatitude());
-
-    // any fix that has time
-    if (!timeSetFromGPS && ublox.getT()) {
-        struct timeval tv;
-
-        /* Convert to unix time
-The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of seconds that have elapsed since January 1, 1970
-(midnight UTC/GMT), not counting leap seconds (in ISO 8601: 1970-01-01T00:00:00Z).
-*/
-        struct tm t;
-        t.tm_sec = ublox.getSecond();
-        t.tm_min = ublox.getMinute();
-        t.tm_hour = ublox.getHour();
-        t.tm_mday = ublox.getDay();
-        t.tm_mon = ublox.getMonth() - 1;
-        t.tm_year = ublox.getYear() - 1900;
-        t.tm_isdst = false;
-        time_t res = mktime(&t);
-        tv.tv_sec = res;
-        tv.tv_usec = 0; // time.centisecond() * (10 / 1000);
-
-        DEBUG_MSG("Got time from GPS month=%d, year=%d, unixtime=%ld\n", t.tm_mon, t.tm_year, tv.tv_sec);
-        if (t.tm_year < 0 || t.tm_year >= 300)
-            DEBUG_MSG("Ignoring invalid GPS time\n");
-        else
-            perhapsSetRTC(&tv);
-    }
-
-    if ((fixtype >= 3 && fixtype <= 4) && ublox.getP()) // rd fixes only
-    {
-        // we only notify if position has changed
-        latitude = ublox.getLatitude() * 1e-7;
-        longitude = ublox.getLongitude() * 1e-7;
-        altitude = ublox.getAltitude() / 1000; // in mm convert to meters
-        DEBUG_MSG("new gps pos lat=%f, lon=%f, alt=%d\n", latitude, longitude, altitude);
-
-        hasValidLocation = (latitude != 0) || (longitude != 0); // bogus lat lon is reported as 0,0
-        if (hasValidLocation) {
-            wantNewLocation = false;
-            notifyObservers(NULL);
-            // ublox.powerOff();
-        }
-    } else // we didn't get a location update, go back to sleep and hope the characters show up
-        wantNewLocation = true;
-#endif
-
-    // Once we have sent a location once we only poll the GPS rarely, otherwise check back every 1s until we have something over
-    // the serial
-    setPeriod(hasValidLocation && !wantNewLocation ? 30 * 1000 : 10 * 1000);
-}
-
-void GPS::startLock()
-{
-    DEBUG_MSG("Looking for GPS lock\n");
-    wantNewLocation = true;
-    setPeriod(1);
-}

src/GPS.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include "Observer.h"
-#include "PeriodicTask.h"
-#include "SparkFun_Ublox_Arduino_Library.h"
-#include "sys/time.h"
-
-/**
- * A gps class that only reads from the GPS periodically (and FIXME - eventually keeps the gps powered down except when reading)
- *
- * When new data is available it will notify observers.
- */
-class GPS : public PeriodicTask, public Observable<void *>
-{
-    SFE_UBLOX_GPS ublox;
-
-  public:
-    double latitude, longitude;
-    uint32_t altitude;
-    bool isConnected; // Do we have a GPS we are talking to
-
-    GPS();
-
-    /// Return time since 1970 in secs.  Until we have a GPS lock we will be returning time based at zero
-    uint32_t getTime();
-
-    /// Return time since 1970 in secs.  If we don't have a GPS lock return zero
-    uint32_t getValidTime();
-
-    void setup();
-
-    virtual void loop();
-
-    virtual void doTask();
-
-    /// If we haven't yet set our RTC this boot, set it from a GPS derived time
-    void perhapsSetRTC(const struct timeval *tv);
-
-    /// Returns true if we think the board can enter deep or light sleep now (we might be trying to get a GPS lock)
-    bool canSleep();
-
-    /// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
-    void prepareSleep();
-
-    /// Restart our lock attempt - try to get and broadcast a GPS reading ASAP
-    void startLock();
-
-    /// Returns ture if we have acquired GPS lock.
-    bool hasLock() const { return hasValidLocation; }
-
-  private:
-    void readFromRTC();
-
-    bool hasValidLocation = false; // default to false, until we complete our first read
-};
-
-extern GPS gps;

src/OSTimer.cpp

@@ -0,0 +1,49 @@
+#include "OSTimer.h"
+#include "configuration.h"
+
+#ifdef NO_ESP32
+
+/**
+ * Schedule a callback to run.  The callback must _not_ block, though it is called from regular thread level (not ISR)
+ *
+ * NOTE! xTimerPend... seems to ignore the time passed in on ESP32 - I haven't checked on NRF52
+ *
+ * @return true if successful, false if the timer fifo is too full.
+ */
+bool scheduleOSCallback(PendableFunction callback, void *param1, uint32_t param2, uint32_t delayMsec)
+{
+    return xTimerPendFunctionCall(callback, param1, param2, pdMS_TO_TICKS(delayMsec));
+}
+
+#else
+
+// Super skanky quick hack to use hardware timers of the ESP32
+static hw_timer_t *timer;
+static PendableFunction tCallback;
+static void *tParam1;
+static uint32_t tParam2;
+
+static void IRAM_ATTR onTimer()
+{
+    (*tCallback)(tParam1, tParam2);
+}
+
+bool scheduleHWCallback(PendableFunction callback, void *param1, uint32_t param2, uint32_t delayMsec)
+{
+    if (!timer) {
+        timer = timerBegin(0, 80, true); // one usec per tick (main clock is 80MhZ on ESP32)
+        assert(timer);
+        timerAttachInterrupt(timer, &onTimer, true);
+    }
+
+    tCallback = callback;
+    tParam1 = param1;
+    tParam2 = param2;
+
+    timerAlarmWrite(timer, delayMsec * 1000L, false); // Do not reload, we want it to be a single shot timer
+    timerRestart(timer);
+    timerAlarmEnable(timer);
+    return true;
+}
+
+#endif

src/OSTimer.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <Arduino.h>
+
+typedef void (*PendableFunction)(void *pvParameter1, uint32_t ulParameter2);
+
+/**
+ * Schedule a callback to run.  The callback must _not_ block, though it is called from regular thread level (not ISR)
+ *
+ * NOTE! ESP32 implementation is busted - always waits 0 ticks
+ * 
+ * @return true if successful, false if the timer fifo is too full.
+ */
+ bool scheduleOSCallback(PendableFunction callback, void *param1, uint32_t param2, uint32_t delayMsec);
+
+
+/// Uses a hardware timer, but calls the handler in _interrupt_ context
+bool scheduleHWCallback(PendableFunction callback, void *param1, uint32_t param2, uint32_t delayMsec);

src/Observer.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <Arduino.h>
-
+#include <assert.h>
 #include <list>
 
 template <class T> class Observable;
@@ -14,7 +14,6 @@ template <class T> class Observer
     Observable<T> *observed = NULL;
 
   public:
-
     virtual ~Observer();
 
     void observe(Observable<T> *o);

src/PeriodicTask.cpp

@@ -1,21 +1,39 @@
 #include "PeriodicTask.h"
 #include "Periodic.h"
+PeriodicScheduler periodicScheduler;
 
 PeriodicTask::PeriodicTask(uint32_t initialPeriod) : period(initialPeriod) {}
 
-/// call this from loop
-void PeriodicTask::loop()
+void PeriodicTask::setup()
 {
-    {
-        meshtastic::LockGuard lg(&lock);
-        uint32_t now = millis();
-        if (!period || (now - lastMsec) < period) {
-            return;
+    periodicScheduler.schedule(this);
+}
+
+/// call this from loop
+void PeriodicScheduler::loop()
+{
+    meshtastic::LockGuard lg(&lock);
+
+    uint32_t now = millis();
+    for (auto t : tasks) {
+        if (t->period && (now - t->lastMsec) >= t->period) {
+
+            t->doTask();
+            t->lastMsec = now;
         }
-        lastMsec = now;
     }
-    // Release the lock in case the task wants to change the period.
-    doTask();
+}
+
+void PeriodicScheduler::schedule(PeriodicTask *t)
+{
+    meshtastic::LockGuard lg(&lock);
+    tasks.insert(t);
+}
+
+void PeriodicScheduler::unschedule(PeriodicTask *t)
+{
+    meshtastic::LockGuard lg(&lock);
+    tasks.erase(t);
 }
 
 void Periodic::doTask()

src/PeriodicTask.h

@@ -1,8 +1,40 @@
 #pragma once
 
-#include <cstdint>
-
 #include "lock.h"
+#include <cstdint>
+#include <unordered_set>
+
+class PeriodicTask;
+
+/**
+ * Runs all PeriodicTasks in the system.
+ *
+ * Currently called from main loop() but eventually should be its own thread blocked on a freertos timer.
+ */
+class PeriodicScheduler
+{
+    friend class PeriodicTask;
+
+    /**
+     * This really should be some form of heap, and when the period gets changed on a task it should get
+     * rescheduled in that heap.  Currently it is just a dumb array and everytime we run loop() we check
+     * _every_ tasks.  If it was a heap we'd only have to check the first task.
+     */
+    std::unordered_set<PeriodicTask *> tasks;
+
+    // Protects the above variables.
+    meshtastic::Lock lock;
+
+  public:
+    /// Run any next tasks which are due for execution
+    void loop();
+
+  private:
+    void schedule(PeriodicTask *t);
+    void unschedule(PeriodicTask *t);
+};
+
+extern PeriodicScheduler periodicScheduler;
 
 /**
  * A base class for tasks that want their doTask() method invoked periodically
@@ -13,26 +45,33 @@
  */
 class PeriodicTask
 {
+    friend class PeriodicScheduler;
+
     uint32_t lastMsec = 0;
     uint32_t period = 1; // call soon after creation
 
-    // Protects the above variables.
-    meshtastic::Lock lock;
-
   public:
-    virtual ~PeriodicTask() {}
+    virtual ~PeriodicTask() { periodicScheduler.unschedule(this); }
 
+    /**
+     * Constructor (will schedule with the global PeriodicScheduler)
+     */
     PeriodicTask(uint32_t initialPeriod = 1);
 
-    /// call this from loop
-    virtual void loop();
+    /** MUST be be called once at startup (but after threading is running - i.e. not from a constructor)
+     */
+    void setup();
 
-    /// Set a new period in msecs (can be called from doTask or elsewhere and the scheduler will cope)
-    void setPeriod(uint32_t p)
-    {
-        meshtastic::LockGuard lg(&lock);
-        period = p;
-    }
+    /**
+     * Set a new period in msecs (can be called from doTask or elsewhere and the scheduler will cope)
+     * While zero this task is disabled and will not run
+     */
+    void setPeriod(uint32_t p) { period = p; }
+
+    /**
+     * Syntatic sugar for suspending tasks
+     */
+    void disable() { setPeriod(0); }
 
   protected:
     virtual void doTask() = 0;

src/PowerFSM.cpp

@@ -87,7 +87,7 @@ static void lsIdle()
 static void lsExit()
 {
     // setGPSPower(true); // restore GPS power
-    gps.startLock();
+    gps->startLock();
 }
 
 static void nbEnter()
@@ -173,10 +173,13 @@ void PowerFSM_setup()
 
     powerFSM.add_timed_transition(&stateDARK, &stateNB, radioConfig.preferences.phone_timeout_secs * 1000, NULL, "Phone timeout");
 
+#ifndef NRF52_SERIES
+    // We never enter light-sleep state on NRF52 (because the CPU uses so little power normally)
     powerFSM.add_timed_transition(&stateNB, &stateLS, radioConfig.preferences.min_wake_secs * 1000, NULL, "Min wake timeout");
 
     powerFSM.add_timed_transition(&stateDARK, &stateLS, radioConfig.preferences.wait_bluetooth_secs * 1000, NULL,
                                   "Bluetooth timeout");
+#endif
 
     powerFSM.add_timed_transition(&stateLS, &stateSDS, radioConfig.preferences.mesh_sds_timeout_secs * 1000, NULL,
                                   "mesh timeout");

src/RedirectablePrint.cpp

@@ -0,0 +1,13 @@
+#include "RedirectablePrint.h"
+#include <assert.h>
+
+/**
+ * A printer that doesn't go anywhere
+ */
+NoopPrint noopPrint;
+
+void RedirectablePrint::setDestination(Print *_dest)
+{
+    assert(_dest);
+    dest = _dest;
+}

src/RedirectablePrint.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <Print.h>
+
+/**
+ * A Printable that can be switched to squirt its bytes to a different sink.
+ * This class is mostly useful to allow debug printing to be redirected away from Serial
+ * to some other transport if we switch Serial usage (on the fly) to some other purpose.
+ */
+class RedirectablePrint : public Print
+{
+    Print *dest;
+
+  public:
+    RedirectablePrint(Print *_dest) : dest(_dest) {}
+
+    /**
+     * Set a new destination
+     */
+    void setDestination(Print *dest);
+
+    virtual size_t write(uint8_t c) { return dest->write(c); }
+};
+
+class NoopPrint : public Print
+{
+  public:
+    virtual size_t write(uint8_t c) { return 1; }
+};
+
+/**
+ * A printer that doesn't go anywhere
+ */
+extern NoopPrint noopPrint;

src/SerialConsole.cpp

@@ -0,0 +1,37 @@
+#include "SerialConsole.h"
+#include "configuration.h"
+#include <Arduino.h>
+
+#define Port Serial
+
+SerialConsole console;
+
+SerialConsole::SerialConsole() : StreamAPI(&Port), RedirectablePrint(&Port)
+{
+    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
+}
+
+/// Do late init that can't happen at constructor time
+void SerialConsole::init()
+{
+    Port.begin(SERIAL_BAUD);
+    StreamAPI::init();
+    emitRebooted();
+}
+
+/**
+ * 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)
+{
+    // Note: for the time being we could _allow_ debug printing to keep going out the console
+    // I _think_ this is okay because we currently only print debug msgs from loop() and we are only
+    // dispatching serial protobuf msgs from loop() as well.  When things are more threaded in the future this
+    // will need to change.
+    // setDestination(&noopPrint);
+    canWrite = true;
+
+    StreamAPI::handleToRadio(buf, len);
+}

src/SerialConsole.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "RedirectablePrint.h"
+#include "StreamAPI.h"
+/**
+ * Provides both debug printing and, if the client starts sending protobufs to us, switches to send/receive protobufs
+ * (and starts dropping debug printing - FIXME, eventually those prints should be encapsulated in protobufs).
+ */
+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 size_t write(uint8_t c)
+    {
+        if (c == '\n') // prefix any newlines with carriage return
+            RedirectablePrint::write('\r');
+        return RedirectablePrint::write(c);
+    }
+};
+
+extern SerialConsole console;

src/WorkerThread.cpp

@@ -0,0 +1,43 @@
+#include "WorkerThread.h"
+#include <assert.h>
+
+void Thread::start(const char *name, size_t stackSize, uint32_t priority)
+{
+    auto r = xTaskCreate(callRun, name, stackSize, this, priority, &taskHandle);
+    assert(r == pdPASS);
+}
+
+void Thread::callRun(void *_this)
+{
+    ((Thread *)_this)->doRun();
+}
+
+void WorkerThread::doRun()
+{
+    while (!wantExit) {
+        block();
+        loop();
+    }
+}
+
+/**
+ * Notify this thread so it can run
+ */
+void NotifiedWorkerThread::notify(uint32_t v, eNotifyAction action)
+{
+    xTaskNotify(taskHandle, v, action);
+}
+
+/**
+ * Notify from an ISR
+ */
+void NotifiedWorkerThread::notifyFromISR(BaseType_t *highPriWoken, uint32_t v, eNotifyAction action)
+{
+    xTaskNotifyFromISR(taskHandle, v, action, highPriWoken);
+}
+
+void NotifiedWorkerThread::block()
+{
+    xTaskNotifyWait(0,                                          // don't clear notification on entry
+                    clearOnRead, &notification, portMAX_DELAY); // Wait forever
+}

src/WorkerThread.h

@@ -0,0 +1,84 @@
+#include <Arduino.h>
+
+class Thread
+{
+  protected:
+    TaskHandle_t taskHandle = NULL;
+
+    /**
+     * set this to true to ask thread to cleanly exit asap
+     */
+    volatile bool wantExit = false;
+
+  public:
+    void start(const char *name, size_t stackSize = 1024, uint32_t priority = tskIDLE_PRIORITY);
+
+    virtual ~Thread() { vTaskDelete(taskHandle); }
+
+  protected:
+    /**
+     * The method that will be called when start is called.
+     */
+    virtual void doRun() = 0;
+
+  private:
+    static void callRun(void *_this);
+};
+
+/**
+ * This wraps threading (FreeRTOS for now) with a blocking API intended for efficiently converting onlyschool arduino loop() code.
+ *
+ * Use as a mixin base class for the classes you want to convert.
+ *
+ * https://www.freertos.org/RTOS_Task_Notification_As_Mailbox.html
+ */
+class WorkerThread : public Thread
+{
+  protected:
+    /**
+     * A method that should block execution - either waiting ona queue/mutex or a "task notification"
+     */
+    virtual void block() = 0;
+
+    virtual void loop() = 0;
+
+    /**
+     * The method that will be called when start is called.
+     */
+    virtual void doRun();
+};
+
+/**
+ * A worker thread that waits on a freertos notification
+ */
+class NotifiedWorkerThread : public WorkerThread
+{
+  public:
+    /**
+     * Notify this thread so it can run
+     */
+    void notify(uint32_t v = 0, eNotifyAction action = eNoAction);
+
+    /**
+     * Notify from an ISR
+     */
+    void notifyFromISR(BaseType_t *highPriWoken, uint32_t v = 0, eNotifyAction action = eNoAction);
+
+  protected:
+    /**
+     * The notification that was most recently used to wake the thread.  Read from loop()
+     */
+    uint32_t notification = 0;
+
+    /**
+     * What notification bits should be cleared just after we read and return them in notification?
+     *
+     * Defaults to clear all of them.
+     */
+    uint32_t clearOnRead = UINT32_MAX;
+
+    /**
+     * A method that should block execution - either waiting ona queue/mutex or a "task notification"
+     */
+    virtual void block();
+};

src/bare/main-bare.cpp

@@ -1,6 +0,0 @@
-#include "target_specific.h"
-
-void setBluetoothEnable(bool on)
-{
-    // Do nothing
-}

src/configuration.h

@@ -31,8 +31,9 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 // If app version is not specified we assume we are not being invoked by the build script
 #ifndef APP_VERSION
-#define APP_VERSION 0.0.0   // this def normally comes from build-all.sh
-#define HW_VERSION 1.0 - US // normally comes from build-all.sh and contains the region code
+#error APP_VERSION, HW_VERSION, and HW_VERSION_countryname must be set by the build environment
+//#define APP_VERSION 0.0.0   // this def normally comes from build-all.sh
+//#define HW_VERSION 1.0 - US // normally comes from build-all.sh and contains the region code
 #endif
 
 // -----------------------------------------------------------------------------
@@ -45,24 +46,11 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //#define USE_JTAG
 #endif
 
-#define DEBUG_PORT Serial  // Serial debug port
-#define SERIAL_BAUD 115200 // Serial debug baud rate
-
 #define REQUIRE_RADIO true // If true, we will fail to start if the radio is not found
 
 #define xstr(s) str(s)
 #define str(s) #s
 
-// -----------------------------------------------------------------------------
-// DEBUG
-// -----------------------------------------------------------------------------
-
-#ifdef DEBUG_PORT
-#define DEBUG_MSG(...) DEBUG_PORT.printf(__VA_ARGS__)
-#else
-#define DEBUG_MSG(...)
-#endif
-
 // -----------------------------------------------------------------------------
 // OLED
 // -----------------------------------------------------------------------------
@@ -121,6 +109,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // Leave undefined to disable our PMU IRQ handler
 #define PMU_IRQ 35
 
+#define AXP192_SLAVE_ADDRESS 0x34
+
 #elif defined(TBEAM_V07)
 // This string must exactly match the case used in release file names or the android updater won't work
 #define HW_VENDOR "tbeam0.7"
@@ -198,17 +188,21 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
     0 // If defined, this will be used for user button presses, if your board doesn't have a physical switch, you can wire one
 // between this pin and ground
 
-#define RESET_GPIO 14    // If defined, this pin will be used to reset the LORA radio
-#define RF95_IRQ_GPIO 26 // IRQ line for the LORA radio
-#define DIO1_GPIO 35     // DIO1 & DIO2 are not currently used, but they must be assigned to a pin number
-#define DIO2_GPIO 34     // DIO1 & DIO2 are not currently used, but they must be assigned to a pin number
-#elif defined(BARE_BOARD)
+#define RESET_GPIO 14        // If defined, this pin will be used to reset the LORA radio
+#define RF95_IRQ_GPIO 26     // IRQ line for the LORA radio
+#define DIO1_GPIO 35         // DIO1 & DIO2 are not currently used, but they must be assigned to a pin number
+#define DIO2_GPIO 34         // DIO1 & DIO2 are not currently used, but they must be assigned to a pin number
+#elif defined(NRF52840_XXAA) // All of the NRF52 targets are configured using variant.h, so this section shouldn't need to be
+                             // board specific
+
+// FIXME, use variant.h defs for all of this!!!
+
 // This string must exactly match the case used in release file names or the android updater won't work
-#define HW_VENDOR "bare"
+#define HW_VENDOR "nrf52"
 
 #define NO_ESP32 // Don't use ESP32 libs (mainly bluetooth)
 
-// Turn off GPS code for now
+// We bind to the GPS using variant.h instead for this platform (Serial1)
 #undef GPS_RX_PIN
 #undef GPS_TX_PIN
 
@@ -222,12 +216,43 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #undef LED_INVERTED
 #define LED_INVERTED 1
 
+// Temporarily testing if we can build the RF95 driver for NRF52
+#if 0
+#define RESET_GPIO 14    // If defined, this pin will be used to reset the LORA radio
+#define RF95_IRQ_GPIO 26 // IRQ line for the LORA radio
+#define DIO1_GPIO 35     // DIO1 & DIO2 are not currently used, but they must be assigned to a pin number
+#define DIO2_GPIO 34     // DIO1 & DIO2 are not currently used, but they must be assigned to a pin number
+#endif
+
+#endif
+
+// -----------------------------------------------------------------------------
+// DEBUG
+// -----------------------------------------------------------------------------
+
+#define SERIAL_BAUD 921600 // Serial debug baud rate
+
+#ifdef NO_ESP32
+#define USE_SEGGER
+#endif
+#ifdef USE_SEGGER
+#include "SEGGER_RTT.h"
+#define DEBUG_MSG(...) SEGGER_RTT_printf(0, __VA_ARGS__)
+#else
+#include "SerialConsole.h"
+
+#define DEBUG_PORT console // Serial debug port
+
+#ifdef DEBUG_PORT
+#define DEBUG_MSG(...) DEBUG_PORT.printf(__VA_ARGS__)
+#else
+#define DEBUG_MSG(...)
+#endif
 #endif
 
 // -----------------------------------------------------------------------------
 // AXP192 (Rev1-specific options)
 // -----------------------------------------------------------------------------
 
-// #define AXP192_SLAVE_ADDRESS  0x34 // Now defined in axp20x.h
 #define GPS_POWER_CTRL_CH 3
 #define LORA_POWER_CTRL_CH 2

src/error.h

@@ -3,7 +3,7 @@
 #include <Arduino.h>
 
 /// Error codes for critical error
-enum CriticalErrorCode { NoError, ErrTxWatchdog, ErrSleepEnterWait, ErrNoRadio };
+enum CriticalErrorCode { NoError, ErrTxWatchdog, ErrSleepEnterWait, ErrNoRadio, ErrUnspecified };
 
 /// Record an error that should be reported via analytics
 void recordCriticalError(CriticalErrorCode code, uint32_t address = 0);

src/esp32/MeshBluetoothService.cpp

@@ -6,19 +6,44 @@
 #include <esp_gatt_defs.h>
 
 #include "CallbackCharacteristic.h"
+#include "GPS.h"
 #include "MeshService.h"
 #include "NodeDB.h"
+#include "PhoneAPI.h"
 #include "PowerFSM.h"
 #include "configuration.h"
 #include "mesh-pb-constants.h"
 #include "mesh.pb.h"
 
-#include "GPS.h"
-
 // This scratch buffer is used for various bluetooth reads/writes - but it is safe because only one bt operation can be in
 // proccess at once
 static uint8_t trBytes[_max(_max(_max(_max(ToRadio_size, RadioConfig_size), User_size), MyNodeInfo_size), FromRadio_size)];
 
+static CallbackCharacteristic *meshFromNumCharacteristic;
+
+BLEService *meshService;
+
+// If defined we will also support the old API
+#define SUPPORT_OLD_BLE_API
+
+class BluetoothPhoneAPI : public PhoneAPI
+{
+    /**
+     * Subclasses can use this as a hook to provide custom notifications for their transport (i.e. bluetooth notifies)
+     */
+    virtual void onNowHasData(uint32_t fromRadioNum)
+    {
+        PhoneAPI::onNowHasData(fromRadioNum);
+
+        if (meshFromNumCharacteristic) { // this ptr might change from sleep to sleep, or even be null
+            meshFromNumCharacteristic->setValue(fromRadioNum);
+            meshFromNumCharacteristic->notify();
+        }
+    }
+};
+
+BluetoothPhoneAPI *bluetoothPhoneAPI;
+
 class ProtobufCharacteristic : public CallbackCharacteristic
 {
     const pb_msgdesc_t *fields;
@@ -58,6 +83,7 @@ class ProtobufCharacteristic : public CallbackCharacteristic
     }
 };
 
+#ifdef SUPPORT_OLD_BLE_API
 class NodeInfoCharacteristic : public BLECharacteristic, public BLEKeepAliveCallbacks
 {
   public:
@@ -114,7 +140,7 @@ class RadioCharacteristic : public ProtobufCharacteristic
     {
         DEBUG_MSG("Writing radio config\n");
         ProtobufCharacteristic::onWrite(c);
-        service.reloadConfig();
+        bluetoothPhoneAPI->handleSetRadio(radioConfig);
     }
 };
 
@@ -135,101 +161,11 @@ class OwnerCharacteristic : public ProtobufCharacteristic
 
         static User o; // if the phone doesn't set ID we are careful to keep ours, we also always keep our macaddr
         if (writeToDest(c, &o)) {
-            int changed = 0;
-
-            if (*o.long_name) {
-                changed |= strcmp(owner.long_name, o.long_name);
-                strcpy(owner.long_name, o.long_name);
-            }
-            if (*o.short_name) {
-                changed |= strcmp(owner.short_name, o.short_name);
-                strcpy(owner.short_name, o.short_name);
-            }
-            if (*o.id) {
-                changed |= strcmp(owner.id, o.id);
-                strcpy(owner.id, o.id);
-            }
-
-            if (changed) // If nothing really changed, don't broadcast on the network or write to flash
-                service.reloadOwner();
+            bluetoothPhoneAPI->handleSetOwner(o);
         }
     }
 };
 
-class ToRadioCharacteristic : public CallbackCharacteristic
-{
-  public:
-    ToRadioCharacteristic() : CallbackCharacteristic("f75c76d2-129e-4dad-a1dd-7866124401e7", BLECharacteristic::PROPERTY_WRITE) {}
-
-    void onWrite(BLECharacteristic *c)
-    {
-        BLEKeepAliveCallbacks::onWrite(c);
-        DEBUG_MSG("Got on write\n");
-
-        service.handleToRadio(c->getValue());
-    }
-};
-
-class FromRadioCharacteristic : public CallbackCharacteristic
-{
-  public:
-    FromRadioCharacteristic() : CallbackCharacteristic("8ba2bcc2-ee02-4a55-a531-c525c5e454d5", BLECharacteristic::PROPERTY_READ)
-    {
-    }
-
-    void onRead(BLECharacteristic *c)
-    {
-        BLEKeepAliveCallbacks::onRead(c);
-        MeshPacket *mp = service.getForPhone();
-
-        // Someone is going to read our value as soon as this callback returns.  So fill it with the next message in the queue
-        // or make empty if the queue is empty
-        if (!mp) {
-            DEBUG_MSG("toPhone queue is empty\n");
-            c->setValue((uint8_t *)"", 0);
-        } else {
-            static FromRadio fRadio;
-
-            // Encapsulate as a FromRadio packet
-            memset(&fRadio, 0, sizeof(fRadio));
-            fRadio.which_variant = FromRadio_packet_tag;
-            fRadio.variant.packet = *mp;
-
-            size_t numbytes = pb_encode_to_bytes(trBytes, sizeof(trBytes), FromRadio_fields, &fRadio);
-            DEBUG_MSG("delivering toPhone packet to phone %d bytes\n", numbytes);
-            c->setValue(trBytes, numbytes);
-
-            service.releaseToPool(mp); // we just copied the bytes, so don't need this buffer anymore
-        }
-    }
-};
-
-class FromNumCharacteristic : public CallbackCharacteristic, public Observer<uint32_t>
-{
-  public:
-    FromNumCharacteristic()
-        : CallbackCharacteristic("ed9da18c-a800-4f66-a670-aa7547e34453", BLECharacteristic::PROPERTY_WRITE |
-                                                                             BLECharacteristic::PROPERTY_READ |
-                                                                             BLECharacteristic::PROPERTY_NOTIFY)
-    {
-        observe(&service.fromNumChanged);
-    }
-
-    void onRead(BLECharacteristic *c)
-    {
-        BLEKeepAliveCallbacks::onRead(c);
-        DEBUG_MSG("FIXME implement fromnum read\n");
-    }
-
-    /// If the mesh service tells us fromNum has changed, tell the phone
-    virtual int onNotify(uint32_t newValue)
-    {
-        setValue(newValue);
-        notify();
-        return 0;
-    }
-};
-
 class MyNodeInfoCharacteristic : public ProtobufCharacteristic
 {
   public:
@@ -242,7 +178,7 @@ class MyNodeInfoCharacteristic : public ProtobufCharacteristic
     void onRead(BLECharacteristic *c)
     {
         // update gps connection state
-        myNodeInfo.has_gps = gps.isConnected;
+        myNodeInfo.has_gps = gps->isConnected;
 
         ProtobufCharacteristic::onRead(c);
 
@@ -251,15 +187,73 @@ class MyNodeInfoCharacteristic : public ProtobufCharacteristic
     }
 };
 
-FromNumCharacteristic *meshFromNumCharacteristic;
+#endif
 
-BLEService *meshService;
+class ToRadioCharacteristic : public CallbackCharacteristic
+{
+  public:
+    ToRadioCharacteristic() : CallbackCharacteristic("f75c76d2-129e-4dad-a1dd-7866124401e7", BLECharacteristic::PROPERTY_WRITE) {}
+
+    void onWrite(BLECharacteristic *c)
+    {
+        BLEKeepAliveCallbacks::onWrite(c);
+        DEBUG_MSG("Got on write\n");
+
+        bluetoothPhoneAPI->handleToRadio(c->getData(), c->getValue().length());
+    }
+};
+
+class FromRadioCharacteristic : public CallbackCharacteristic
+{
+  public:
+    FromRadioCharacteristic() : CallbackCharacteristic("8ba2bcc2-ee02-4a55-a531-c525c5e454d5", BLECharacteristic::PROPERTY_READ)
+    {
+    }
+
+    void onRead(BLECharacteristic *c)
+    {
+        BLEKeepAliveCallbacks::onRead(c);
+        size_t numBytes = bluetoothPhoneAPI->getFromRadio(trBytes);
+
+        // Someone is going to read our value as soon as this callback returns.  So fill it with the next message in the queue
+        // or make empty if the queue is empty
+        if (numBytes) {
+            c->setValue(trBytes, numBytes);
+        } else {
+            c->setValue((uint8_t *)"", 0);
+        }
+    }
+};
+
+class FromNumCharacteristic : public CallbackCharacteristic
+{
+  public:
+    FromNumCharacteristic()
+        : CallbackCharacteristic("ed9da18c-a800-4f66-a670-aa7547e34453", BLECharacteristic::PROPERTY_WRITE |
+                                                                             BLECharacteristic::PROPERTY_READ |
+                                                                             BLECharacteristic::PROPERTY_NOTIFY)
+    {
+        // observe(&service.fromNumChanged);
+    }
+
+    void onRead(BLECharacteristic *c)
+    {
+        BLEKeepAliveCallbacks::onRead(c);
+        DEBUG_MSG("FIXME implement fromnum read\n");
+    }
+};
 
 /*
 See bluetooth-api.md for documentation.
  */
 BLEService *createMeshBluetoothService(BLEServer *server)
 {
+    // Only create our phone API object once
+    if (!bluetoothPhoneAPI) {
+        bluetoothPhoneAPI = new BluetoothPhoneAPI();
+        bluetoothPhoneAPI->init();
+    }
+
     // Create the BLE Service, we need more than the default of 15 handles
     BLEService *service = server->createService(BLEUUID("6ba1b218-15a8-461f-9fa8-5dcae273eafd"), 30, 0);
 
@@ -269,10 +263,12 @@ BLEService *createMeshBluetoothService(BLEServer *server)
     addWithDesc(service, meshFromNumCharacteristic, "fromRadio");
     addWithDesc(service, new ToRadioCharacteristic, "toRadio");
     addWithDesc(service, new FromRadioCharacteristic, "fromNum");
+#ifdef SUPPORT_OLD_BLE_API
     addWithDesc(service, new MyNodeInfoCharacteristic, "myNode");
     addWithDesc(service, new RadioCharacteristic, "radio");
     addWithDesc(service, new OwnerCharacteristic, "owner");
     addWithDesc(service, new NodeInfoCharacteristic, "nodeinfo");
+#endif
 
     meshFromNumCharacteristic->addDescriptor(addBLEDescriptor(new BLE2902())); // Needed so clients can request notification
 

src/esp32/main-esp32.cpp

@@ -3,6 +3,7 @@
 #include "PowerFSM.h"
 #include "configuration.h"
 #include "main.h"
+#include "power.h"
 #include "target_specific.h"
 
 bool bluetoothOn;
@@ -51,3 +52,184 @@ void setBluetoothEnable(bool on)
         }
     }
 }
+
+void getMacAddr(uint8_t *dmac)
+{
+    assert(esp_efuse_mac_get_default(dmac) == ESP_OK);
+}
+
+#ifdef TBEAM_V10
+
+// FIXME. nasty hack cleanup how we load axp192
+#undef AXP192_SLAVE_ADDRESS
+#include "axp20x.h"
+AXP20X_Class axp;
+bool pmu_irq = false;
+
+/// Reads power status to powerStatus singleton.
+//
+// TODO(girts): move this and other axp stuff to power.h/power.cpp.
+void readPowerStatus()
+{
+    powerStatus.haveBattery = axp.isBatteryConnect();
+    if (powerStatus.haveBattery) {
+        powerStatus.batteryVoltageMv = axp.getBattVoltage();
+    }
+    powerStatus.usb = axp.isVBUSPlug();
+    powerStatus.charging = axp.isChargeing();
+}
+#endif // TBEAM_V10
+
+#ifdef AXP192_SLAVE_ADDRESS
+/**
+ * Init the power manager chip
+ *
+ * axp192 power
+    DCDC1 0.7-3.5V @ 1200mA max -> OLED // If you turn this off you'll lose comms to the axp192 because the OLED and the axp192
+ share the same i2c bus, instead use ssd1306 sleep mode DCDC2 -> unused DCDC3 0.7-3.5V @ 700mA max -> ESP32 (keep this on!) LDO1
+ 30mA -> charges GPS backup battery // charges the tiny J13 battery by the GPS to power the GPS ram (for a couple of days), can
+ not be turned off LDO2 200mA -> LORA LDO3 200mA -> GPS
+ */
+void axp192Init()
+{
+    if (axp192_found) {
+        if (!axp.begin(Wire, AXP192_SLAVE_ADDRESS)) {
+            DEBUG_MSG("AXP192 Begin PASS\n");
+
+            // axp.setChgLEDMode(LED_BLINK_4HZ);
+            DEBUG_MSG("DCDC1: %s\n", axp.isDCDC1Enable() ? "ENABLE" : "DISABLE");
+            DEBUG_MSG("DCDC2: %s\n", axp.isDCDC2Enable() ? "ENABLE" : "DISABLE");
+            DEBUG_MSG("LDO2: %s\n", axp.isLDO2Enable() ? "ENABLE" : "DISABLE");
+            DEBUG_MSG("LDO3: %s\n", axp.isLDO3Enable() ? "ENABLE" : "DISABLE");
+            DEBUG_MSG("DCDC3: %s\n", axp.isDCDC3Enable() ? "ENABLE" : "DISABLE");
+            DEBUG_MSG("Exten: %s\n", axp.isExtenEnable() ? "ENABLE" : "DISABLE");
+            DEBUG_MSG("----------------------------------------\n");
+
+            axp.setPowerOutPut(AXP192_LDO2, AXP202_ON); // LORA radio
+            axp.setPowerOutPut(AXP192_LDO3, AXP202_ON); // GPS main power
+            axp.setPowerOutPut(AXP192_DCDC2, AXP202_ON);
+            axp.setPowerOutPut(AXP192_EXTEN, AXP202_ON);
+            axp.setPowerOutPut(AXP192_DCDC1, AXP202_ON);
+            axp.setDCDC1Voltage(3300); // for the OLED power
+
+            DEBUG_MSG("DCDC1: %s\n", axp.isDCDC1Enable() ? "ENABLE" : "DISABLE");
+            DEBUG_MSG("DCDC2: %s\n", axp.isDCDC2Enable() ? "ENABLE" : "DISABLE");
+            DEBUG_MSG("LDO2: %s\n", axp.isLDO2Enable() ? "ENABLE" : "DISABLE");
+            DEBUG_MSG("LDO3: %s\n", axp.isLDO3Enable() ? "ENABLE" : "DISABLE");
+            DEBUG_MSG("DCDC3: %s\n", axp.isDCDC3Enable() ? "ENABLE" : "DISABLE");
+            DEBUG_MSG("Exten: %s\n", axp.isExtenEnable() ? "ENABLE" : "DISABLE");
+
+#if 0
+      // cribbing from https://github.com/m5stack/M5StickC/blob/master/src/AXP192.cpp to fix charger to be more like 300ms.  
+      // I finally found an english datasheet.  Will look at this later - but suffice it to say the default code from TTGO has 'issues'
+
+      axp.adc1Enable(0xff, 1); // turn on all adcs
+      uint8_t val = 0xc2;
+      axp._writeByte(0x33, 1, &val); // Bat charge voltage to 4.2, Current 280mA
+      val = 0b11110010;
+      // Set ADC sample rate to 200hz
+      // axp._writeByte(0x84, 1, &val);
+
+      // Not connected
+      //val = 0xfc;
+      //axp._writeByte(AXP202_VHTF_CHGSET, 1, &val); // Set temperature protection
+
+      //not used
+      //val = 0x46;
+      //axp._writeByte(AXP202_OFF_CTL, 1, &val); // enable bat detection
+#endif
+            axp.debugCharging();
+
+#ifdef PMU_IRQ
+            pinMode(PMU_IRQ, INPUT);
+            attachInterrupt(
+                PMU_IRQ, [] { pmu_irq = true; }, FALLING);
+
+            axp.adc1Enable(AXP202_BATT_CUR_ADC1, 1);
+            axp.enableIRQ(AXP202_BATT_REMOVED_IRQ | AXP202_BATT_CONNECT_IRQ | AXP202_CHARGING_FINISHED_IRQ | AXP202_CHARGING_IRQ |
+                              AXP202_VBUS_REMOVED_IRQ | AXP202_VBUS_CONNECT_IRQ | AXP202_PEK_SHORTPRESS_IRQ,
+                          1);
+
+            axp.clearIRQ();
+#endif
+            readPowerStatus();
+        } else {
+            DEBUG_MSG("AXP192 Begin FAIL\n");
+        }
+    } else {
+        DEBUG_MSG("AXP192 not found\n");
+    }
+}
+#endif
+
+void esp32Setup()
+{
+    randomSeed(esp_random()); // ESP docs say this is fairly random
+
+#ifdef AXP192_SLAVE_ADDRESS
+    axp192Init();
+#endif
+}
+
+#if 0
+// Turn off for now
+
+uint32_t axpDebugRead()
+{
+  axp.debugCharging();
+  DEBUG_MSG("vbus current %f\n", axp.getVbusCurrent());
+  DEBUG_MSG("charge current %f\n", axp.getBattChargeCurrent());
+  DEBUG_MSG("bat voltage %f\n", axp.getBattVoltage());
+  DEBUG_MSG("batt pct %d\n", axp.getBattPercentage());
+  DEBUG_MSG("is battery connected %d\n", axp.isBatteryConnect());
+  DEBUG_MSG("is USB connected %d\n", axp.isVBUSPlug());
+  DEBUG_MSG("is charging %d\n", axp.isChargeing());
+
+  return 30 * 1000;
+}
+
+Periodic axpDebugOutput(axpDebugRead);
+#endif
+
+/// loop code specific to ESP32 targets
+void esp32Loop()
+{
+    loopBLE();
+
+    // for debug printing
+    // radio.radioIf.canSleep();
+
+#ifdef PMU_IRQ
+    if (pmu_irq) {
+        pmu_irq = false;
+        axp.readIRQ();
+
+        DEBUG_MSG("pmu irq!\n");
+
+        if (axp.isChargingIRQ()) {
+            DEBUG_MSG("Battery start charging\n");
+        }
+        if (axp.isChargingDoneIRQ()) {
+            DEBUG_MSG("Battery fully charged\n");
+        }
+        if (axp.isVbusRemoveIRQ()) {
+            DEBUG_MSG("USB unplugged\n");
+        }
+        if (axp.isVbusPlugInIRQ()) {
+            DEBUG_MSG("USB plugged In\n");
+        }
+        if (axp.isBattPlugInIRQ()) {
+            DEBUG_MSG("Battery inserted\n");
+        }
+        if (axp.isBattRemoveIRQ()) {
+            DEBUG_MSG("Battery removed\n");
+        }
+        if (axp.isPEKShortPressIRQ()) {
+            DEBUG_MSG("PEK short button press\n");
+        }
+
+        readPowerStatus();
+        axp.clearIRQ();
+    }
+#endif // T_BEAM_V10
+}

src/gps/GPS.cpp

@@ -0,0 +1,81 @@
+
+#include "GPS.h"
+#include "configuration.h"
+#include "time.h"
+#include <assert.h>
+#include <sys/time.h>
+
+#ifdef GPS_RX_PIN
+HardwareSerial _serial_gps_real(GPS_SERIAL_NUM);
+HardwareSerial &GPS::_serial_gps = _serial_gps_real;
+#else
+// Assume NRF52
+HardwareSerial &GPS::_serial_gps = Serial1;
+#endif
+
+bool timeSetFromGPS; // We try to set our time from GPS each time we wake from sleep
+
+GPS *gps;
+
+// stuff that really should be in in the instance instead...
+static uint32_t
+    timeStartMsec; // Once we have a GPS lock, this is where we hold the initial msec clock that corresponds to that time
+static uint64_t zeroOffsetSecs; // GPS based time in secs since 1970 - only updated once on initial lock
+
+void readFromRTC()
+{
+    struct timeval tv; /* btw settimeofday() is helpfull here too*/
+
+    if (!gettimeofday(&tv, NULL)) {
+        uint32_t now = millis();
+
+        DEBUG_MSG("Read RTC time as %ld (cur millis %u) valid=%d\n", tv.tv_sec, now, timeSetFromGPS);
+        timeStartMsec = now;
+        zeroOffsetSecs = tv.tv_sec;
+    }
+}
+
+/// If we haven't yet set our RTC this boot, set it from a GPS derived time
+void perhapsSetRTC(const struct timeval *tv)
+{
+    if (!timeSetFromGPS) {
+        timeSetFromGPS = true;
+        DEBUG_MSG("Setting RTC %ld secs\n", tv->tv_sec);
+#ifndef NO_ESP32
+        settimeofday(tv, NULL);
+#else
+        DEBUG_MSG("ERROR TIME SETTING NOT IMPLEMENTED!\n");
+#endif
+        readFromRTC();
+    }
+}
+
+void perhapsSetRTC(struct tm &t)
+{
+    /* Convert to unix time
+    The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of seconds that have elapsed since January 1, 1970
+    (midnight UTC/GMT), not counting leap seconds (in ISO 8601: 1970-01-01T00:00:00Z).
+    */
+    time_t res = mktime(&t);
+    struct timeval tv;
+    tv.tv_sec = res;
+    tv.tv_usec = 0; // time.centisecond() * (10 / 1000);
+
+    // DEBUG_MSG("Got time from GPS month=%d, year=%d, unixtime=%ld\n", t.tm_mon, t.tm_year, tv.tv_sec);
+    if (t.tm_year < 0 || t.tm_year >= 300)
+        DEBUG_MSG("Ignoring invalid GPS time\n");
+    else
+        perhapsSetRTC(&tv);
+}
+
+#include <time.h>
+
+uint32_t getTime()
+{
+    return ((millis() - timeStartMsec) / 1000) + zeroOffsetSecs;
+}
+
+uint32_t getValidTime()
+{
+    return timeSetFromGPS ? getTime() : 0;
+}

src/gps/GPS.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "Observer.h"
+#include "PeriodicTask.h"
+#include "sys/time.h"
+
+/// If we haven't yet set our RTC this boot, set it from a GPS derived time
+void perhapsSetRTC(const struct timeval *tv);
+void perhapsSetRTC(struct tm &t);
+
+/// Return time since 1970 in secs.  Until we have a GPS lock we will be returning time based at zero
+uint32_t getTime();
+
+/// Return time since 1970 in secs.  If we don't have a GPS lock return zero
+uint32_t getValidTime();
+
+void readFromRTC();
+
+/**
+ * A gps class that only reads from the GPS periodically (and FIXME - eventually keeps the gps powered down except when reading)
+ *
+ * When new data is available it will notify observers.
+ */
+class GPS : public Observable<void *>
+{
+  protected:
+    bool hasValidLocation = false; // default to false, until we complete our first read
+
+    static HardwareSerial &_serial_gps;
+
+  public:
+    int32_t latitude = 0, longitude = 0; // as an int mult by 1e-7 to get value as double
+    int32_t altitude = 0;
+    bool isConnected = false; // Do we have a GPS we are talking to
+
+    virtual ~GPS() {}
+
+    /**
+     * Returns true if we succeeded
+     */
+    virtual bool setup() { return true; }
+
+    /// A loop callback for subclasses that need it.  FIXME, instead just block on serial reads
+    virtual void loop() {}
+
+    /// Returns ture if we have acquired GPS lock.
+    bool hasLock() const { return hasValidLocation; }
+
+    /**
+     * Restart our lock attempt - try to get and broadcast a GPS reading ASAP
+     * called after the CPU wakes from light-sleep state */
+    virtual void startLock() {}
+};
+
+extern GPS *gps;

src/gps/NEMAGPS.cpp

@@ -0,0 +1,65 @@
+#include "NEMAGPS.h"
+#include "configuration.h"
+
+static int32_t toDegInt(RawDegrees d)
+{
+    int32_t degMult = 10000000; // 1e7
+    int32_t r = d.deg * degMult + d.billionths / 100;
+    if (d.negative)
+        r *= -1;
+    return r;
+}
+
+void NEMAGPS::loop()
+{
+
+    while (_serial_gps.available() > 0) {
+        int c = _serial_gps.read();
+        // Serial.write(c);
+        reader.encode(c);
+    }
+
+    uint32_t now = millis();
+    if ((now - lastUpdateMsec) > 20 * 1000) { // Ugly hack for now - limit update checks to once every 20 secs (but still consume
+                                              // serial chars at whatever rate)
+        lastUpdateMsec = now;
+
+        auto ti = reader.time;
+        auto d = reader.date;
+        if (ti.isUpdated() && ti.isValid() && d.isValid()) {
+            /* Convert to unix time
+    The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of seconds that have elapsed since January 1, 1970
+    (midnight UTC/GMT), not counting leap seconds (in ISO 8601: 1970-01-01T00:00:00Z).
+    */
+            struct tm t;
+            t.tm_sec = ti.second();
+            t.tm_min = ti.minute();
+            t.tm_hour = ti.hour();
+            t.tm_mday = d.day();
+            t.tm_mon = d.month() - 1;
+            t.tm_year = d.year() - 1900;
+            t.tm_isdst = false;
+            perhapsSetRTC(t);
+
+            isConnected = true; // we seem to have a real GPS (but not necessarily a lock)
+        }
+
+        if (reader.location.isUpdated()) {
+            if (reader.altitude.isValid())
+                altitude = reader.altitude.meters();
+
+            if (reader.location.isValid()) {
+                auto loc = reader.location.value();
+                latitude = toDegInt(loc.lat);
+                longitude = toDegInt(loc.lng);
+            }
+
+            // expect gps pos lat=37.520825, lon=-122.309162, alt=158
+            DEBUG_MSG("new NEMA GPS pos lat=%f, lon=%f, alt=%d\n", latitude * 1e-7, longitude * 1e-7, altitude);
+
+            hasValidLocation = (latitude != 0) || (longitude != 0); // bogus lat lon is reported as 0,0
+            if (hasValidLocation)
+                notifyObservers(NULL);
+        }
+    }
+}

src/gps/NEMAGPS.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "GPS.h"
+#include "Observer.h"
+#include "PeriodicTask.h"
+#include "TinyGPS++.h"
+
+/**
+ * A gps class thatreads from a NEMA GPS stream (and FIXME - eventually keeps the gps powered down except when reading)
+ *
+ * When new data is available it will notify observers.
+ */
+class NEMAGPS : public GPS
+{
+    TinyGPSPlus reader;
+    
+    uint32_t lastUpdateMsec = 0;
+
+  public:
+    virtual void loop();
+};

src/gps/UBloxGPS.cpp

@@ -0,0 +1,139 @@
+#include "UBloxGPS.h"
+#include "sleep.h"
+#include <assert.h>
+
+UBloxGPS::UBloxGPS() : PeriodicTask()
+{
+    notifySleepObserver.observe(&notifySleep);
+}
+
+bool UBloxGPS::setup()
+{
+#ifdef GPS_RX_PIN
+    _serial_gps.begin(GPS_BAUDRATE, SERIAL_8N1, GPS_RX_PIN, GPS_TX_PIN);
+#else
+    _serial_gps.begin(GPS_BAUDRATE);
+#endif
+    // _serial_gps.setRxBufferSize(1024); // the default is 256
+    // ublox.enableDebugging(Serial);
+
+    // note: the lib's implementation has the wrong docs for what the return val is
+    // it is not a bool, it returns zero for success
+    isConnected = ublox.begin(_serial_gps);
+
+    // try a second time, the ublox lib serial parsing is buggy?
+    if (!isConnected)
+        isConnected = ublox.begin(_serial_gps);
+
+    if (isConnected) {
+        DEBUG_MSG("Connected to UBLOX GPS successfully\n");
+
+        bool factoryReset = false;
+        bool ok;
+        if (factoryReset) {
+            // It is useful to force back into factory defaults (9600baud, NEMA to test the behavior of boards that don't have
+            // GPS_TX connected)
+            ublox.factoryReset();
+            delay(3000);
+            isConnected = ublox.begin(_serial_gps);
+            DEBUG_MSG("Factory reset success=%d\n", isConnected);
+            ok = ublox.saveConfiguration(3000);
+            assert(ok);
+            return false;
+        } else {
+            ok = ublox.setUART1Output(COM_TYPE_UBX, 500); // Use native API
+            assert(ok);
+            ok = ublox.setNavigationFrequency(1, 500); // Produce 4x/sec to keep the amount of time we stall in getPVT low
+            assert(ok);
+            // ok = ublox.setAutoPVT(false); // Not implemented on NEO-6M
+            // assert(ok);
+            // ok = ublox.setDynamicModel(DYN_MODEL_BIKE); // probably PEDESTRIAN but just in case assume bike speeds
+            // assert(ok);
+            ok = ublox.powerSaveMode(); // use power save mode
+            assert(ok);
+        }
+        ok = ublox.saveConfiguration(3000);
+        assert(ok);
+
+        PeriodicTask::setup(); // We don't start our periodic task unless we actually found the device
+
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
+int UBloxGPS::prepareSleep(void *unused)
+{
+    if (isConnected)
+        ublox.powerOff();
+
+    return 0;
+}
+
+void UBloxGPS::doTask()
+{
+    uint8_t fixtype = 3; // If we are only using the RX pin, assume we have a 3d fix
+
+    assert(isConnected);
+
+    // Consume all characters that have arrived
+
+    // getPVT automatically calls checkUblox
+    ublox.checkUblox(); // See if new data is available. Process bytes as they come in.
+
+    // If we don't have a fix (a quick check), don't try waiting for a solution)
+    // Hmmm my fix type reading returns zeros for fix, which doesn't seem correct, because it is still sptting out positions
+    // turn off for now
+    // fixtype = ublox.getFixType();
+    DEBUG_MSG("fix type %d\n", fixtype);
+
+    // DEBUG_MSG("sec %d\n", ublox.getSecond());
+    // DEBUG_MSG("lat %d\n", ublox.getLatitude());
+
+    // any fix that has time
+    if (ublox.getT()) {
+        /* Convert to unix time
+The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of seconds that have elapsed since January 1, 1970
+(midnight UTC/GMT), not counting leap seconds (in ISO 8601: 1970-01-01T00:00:00Z).
+*/
+        struct tm t;
+        t.tm_sec = ublox.getSecond();
+        t.tm_min = ublox.getMinute();
+        t.tm_hour = ublox.getHour();
+        t.tm_mday = ublox.getDay();
+        t.tm_mon = ublox.getMonth() - 1;
+        t.tm_year = ublox.getYear() - 1900;
+        t.tm_isdst = false;
+        perhapsSetRTC(t);
+    }
+
+    if ((fixtype >= 3 && fixtype <= 4) && ublox.getP()) // rd fixes only
+    {
+        // we only notify if position has changed
+        latitude = ublox.getLatitude();
+        longitude = ublox.getLongitude();
+        altitude = ublox.getAltitude() / 1000; // in mm convert to meters
+        DEBUG_MSG("new gps pos lat=%f, lon=%f, alt=%d\n", latitude * 1e-7, longitude * 1e-7, altitude);
+
+        hasValidLocation = (latitude != 0) || (longitude != 0); // bogus lat lon is reported as 0,0
+        if (hasValidLocation) {
+            wantNewLocation = false;
+            notifyObservers(NULL);
+            // ublox.powerOff();
+        }
+    } else // we didn't get a location update, go back to sleep and hope the characters show up
+        wantNewLocation = true;
+
+    // Once we have sent a location once we only poll the GPS rarely, otherwise check back every 1s until we have something over
+    // the serial
+    setPeriod(hasValidLocation && !wantNewLocation ? 30 * 1000 : 10 * 1000);
+}
+
+void UBloxGPS::startLock()
+{
+    DEBUG_MSG("Looking for GPS lock\n");
+    wantNewLocation = true;
+    setPeriod(1);
+}

src/gps/UBloxGPS.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "GPS.h"
+#include "Observer.h"
+#include "PeriodicTask.h"
+#include "SparkFun_Ublox_Arduino_Library.h"
+
+/**
+ * A gps class that only reads from the GPS periodically (and FIXME - eventually keeps the gps powered down except when reading)
+ *
+ * When new data is available it will notify observers.
+ */
+class UBloxGPS : public GPS, public PeriodicTask
+{
+    SFE_UBLOX_GPS ublox;
+
+    bool wantNewLocation = true;
+
+    CallbackObserver<UBloxGPS, void *> notifySleepObserver = CallbackObserver<UBloxGPS, void *>(this, &UBloxGPS::prepareSleep);
+
+  public:
+    UBloxGPS();
+
+    /**
+     * Returns true if we succeeded
+     */
+    virtual bool setup();
+
+    virtual void doTask();
+
+    /**
+     * Restart our lock attempt - try to get and broadcast a GPS reading ASAP
+     * called after the CPU wakes from light-sleep state */
+    virtual void startLock();
+
+  private:
+
+    /// Prepare the GPS for the cpu entering deep or light sleep, expect to be gone for at least 100s of msecs
+    /// always returns 0 to indicate okay to sleep
+    int prepareSleep(void *unused);
+};

src/main.cpp

@@ -21,17 +21,20 @@
 
 */
 
-#include "GPS.h"
 #include "MeshRadio.h"
 #include "MeshService.h"
+#include "NEMAGPS.h"
 #include "NodeDB.h"
 #include "Periodic.h"
 #include "PowerFSM.h"
+#include "Router.h"
+#include "UBloxGPS.h"
 #include "configuration.h"
 #include "error.h"
 #include "power.h"
 // #include "rom/rtc.h"
 #include "FloodingRouter.h"
+#include "main.h"
 #include "screen.h"
 #include "sleep.h"
 #include <Wire.h>
@@ -41,22 +44,11 @@
 #include "BluetoothUtil.h"
 #endif
 
-#ifdef TBEAM_V10
-#include "axp20x.h"
-AXP20X_Class axp;
-bool pmu_irq = false;
-#endif
-
-// Global Screen singleton
-#ifdef I2C_SDA
-meshtastic::Screen screen(SSD1306_ADDRESS, I2C_SDA, I2C_SCL);
-#else
-// Fake values for pins to keep build happy, we won't ever initialize it.
-meshtastic::Screen screen(SSD1306_ADDRESS, 0, 0);
-#endif
+// We always create a screen object, but we only init it if we find the hardware
+meshtastic::Screen screen(SSD1306_ADDRESS);
 
 // Global power status singleton
-static meshtastic::PowerStatus powerStatus;
+meshtastic::PowerStatus powerStatus;
 
 bool ssd1306_found;
 bool axp192_found;
@@ -84,7 +76,7 @@ void scanI2Cdevice(void)
                 ssd1306_found = true;
                 DEBUG_MSG("ssd1306 display found\n");
             }
-#ifdef TBEAM_V10
+#ifdef AXP192_SLAVE_ADDRESS
             if (addr == AXP192_SLAVE_ADDRESS) {
                 axp192_found = true;
                 DEBUG_MSG("axp192 PMU found\n");
@@ -100,117 +92,6 @@ void scanI2Cdevice(void)
         DEBUG_MSG("done\n");
 }
 
-#ifdef TBEAM_V10
-/// Reads power status to powerStatus singleton.
-//
-// TODO(girts): move this and other axp stuff to power.h/power.cpp.
-void readPowerStatus()
-{
-    powerStatus.haveBattery = axp.isBatteryConnect();
-    if (powerStatus.haveBattery) {
-        powerStatus.batteryVoltageMv = axp.getBattVoltage();
-    }
-    powerStatus.usb = axp.isVBUSPlug();
-    powerStatus.charging = axp.isChargeing();
-}
-#endif // TBEAM_V10
-
-/**
- * Init the power manager chip
- *
- * axp192 power
-    DCDC1 0.7-3.5V @ 1200mA max -> OLED // If you turn this off you'll lose comms to the axp192 because the OLED and the axp192
- share the same i2c bus, instead use ssd1306 sleep mode DCDC2 -> unused DCDC3 0.7-3.5V @ 700mA max -> ESP32 (keep this on!) LDO1
- 30mA -> charges GPS backup battery // charges the tiny J13 battery by the GPS to power the GPS ram (for a couple of days), can
- not be turned off LDO2 200mA -> LORA LDO3 200mA -> GPS
- */
-void axp192Init()
-{
-#ifdef TBEAM_V10
-    if (axp192_found) {
-        if (!axp.begin(Wire, AXP192_SLAVE_ADDRESS)) {
-            DEBUG_MSG("AXP192 Begin PASS\n");
-
-            // axp.setChgLEDMode(LED_BLINK_4HZ);
-            DEBUG_MSG("DCDC1: %s\n", axp.isDCDC1Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("DCDC2: %s\n", axp.isDCDC2Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("LDO2: %s\n", axp.isLDO2Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("LDO3: %s\n", axp.isLDO3Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("DCDC3: %s\n", axp.isDCDC3Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("Exten: %s\n", axp.isExtenEnable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("----------------------------------------\n");
-
-            axp.setPowerOutPut(AXP192_LDO2, AXP202_ON); // LORA radio
-            axp.setPowerOutPut(AXP192_LDO3, AXP202_ON); // GPS main power
-            axp.setPowerOutPut(AXP192_DCDC2, AXP202_ON);
-            axp.setPowerOutPut(AXP192_EXTEN, AXP202_ON);
-            axp.setPowerOutPut(AXP192_DCDC1, AXP202_ON);
-            axp.setDCDC1Voltage(3300); // for the OLED power
-
-            DEBUG_MSG("DCDC1: %s\n", axp.isDCDC1Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("DCDC2: %s\n", axp.isDCDC2Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("LDO2: %s\n", axp.isLDO2Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("LDO3: %s\n", axp.isLDO3Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("DCDC3: %s\n", axp.isDCDC3Enable() ? "ENABLE" : "DISABLE");
-            DEBUG_MSG("Exten: %s\n", axp.isExtenEnable() ? "ENABLE" : "DISABLE");
-
-#if 0
-      // cribbing from https://github.com/m5stack/M5StickC/blob/master/src/AXP192.cpp to fix charger to be more like 300ms.  
-      // I finally found an english datasheet.  Will look at this later - but suffice it to say the default code from TTGO has 'issues'
-
-      axp.adc1Enable(0xff, 1); // turn on all adcs
-      uint8_t val = 0xc2;
-      axp._writeByte(0x33, 1, &val); // Bat charge voltage to 4.2, Current 280mA
-      val = 0b11110010;
-      // Set ADC sample rate to 200hz
-      // axp._writeByte(0x84, 1, &val);
-
-      // Not connected
-      //val = 0xfc;
-      //axp._writeByte(AXP202_VHTF_CHGSET, 1, &val); // Set temperature protection
-
-      //not used
-      //val = 0x46;
-      //axp._writeByte(AXP202_OFF_CTL, 1, &val); // enable bat detection
-#endif
-            axp.debugCharging();
-
-#ifdef PMU_IRQ
-            pinMode(PMU_IRQ, INPUT);
-            attachInterrupt(
-                PMU_IRQ, [] { pmu_irq = true; }, FALLING);
-
-            axp.adc1Enable(AXP202_BATT_CUR_ADC1, 1);
-            axp.enableIRQ(AXP202_BATT_REMOVED_IRQ | AXP202_BATT_CONNECT_IRQ | AXP202_CHARGING_FINISHED_IRQ | AXP202_CHARGING_IRQ |
-                              AXP202_VBUS_REMOVED_IRQ | AXP202_VBUS_CONNECT_IRQ | AXP202_PEK_SHORTPRESS_IRQ,
-                          1);
-
-            axp.clearIRQ();
-#endif
-            readPowerStatus();
-        } else {
-            DEBUG_MSG("AXP192 Begin FAIL\n");
-        }
-    } else {
-        DEBUG_MSG("AXP192 not found\n");
-    }
-#endif
-}
-
-void getMacAddr(uint8_t *dmac)
-{
-#ifndef NO_ESP32
-    assert(esp_efuse_mac_get_default(dmac) == ESP_OK);
-#else
-    dmac[0] = 0xde;
-    dmac[1] = 0xad;
-    dmac[2] = 0xbe;
-    dmac[3] = 0xef;
-    dmac[4] = 0x01;
-    dmac[5] = 0x02; // FIXME, macaddr stuff needed for NRF52
-#endif
-}
-
 const char *getDeviceName()
 {
     uint8_t dmac[6];
@@ -225,13 +106,35 @@ const char *getDeviceName()
 
 static MeshRadio *radio = NULL;
 
-#include "Router.h"
+static uint32_t ledBlinker()
+{
+    static bool ledOn;
+    ledOn ^= 1;
+
+    setLed(ledOn);
+
+    // have a very sparse duty cycle of LED being on, unless charging, then blink 0.5Hz square wave rate to indicate that
+    return powerStatus.charging ? 1000 : (ledOn ? 2 : 1000);
+}
+
+Periodic ledPeriodic(ledBlinker);
+
+#include "RF95Interface.h"
+#include "SX1262Interface.h"
+
+#ifdef NO_ESP32
+#include "variant.h"
+#endif
 
 void setup()
 {
+#ifdef USE_SEGGER
+    SEGGER_RTT_ConfigUpBuffer(0, NULL, NULL, 0, SEGGER_RTT_MODE_NO_BLOCK_TRIM);
+#endif
+
 // Debug
 #ifdef DEBUG_PORT
-    DEBUG_PORT.begin(SERIAL_BAUD);
+    DEBUG_PORT.init(); // Set serial baud rate and init our mesh console
 #endif
 
     initDeepSleep();
@@ -248,8 +151,10 @@ void setup()
 
 #ifdef I2C_SDA
     Wire.begin(I2C_SDA, I2C_SCL);
-    scanI2Cdevice();
+#else
+    Wire.begin();
 #endif
+    scanI2Cdevice();
 
     // Buttons & LED
 #ifdef BUTTON_PIN
@@ -261,6 +166,8 @@ void setup()
     digitalWrite(LED_PIN, 1 ^ LED_INVERTED); // turn on for now
 #endif
 
+    ledPeriodic.setup();
+
     // Hello
     DEBUG_MSG("Meshtastic swver=%s, hwver=%s\n", xstr(APP_VERSION), xstr(HW_VERSION));
 
@@ -268,27 +175,65 @@ void setup()
     // Don't init display if we don't have one or we are waking headless due to a timer event
     if (wakeCause == ESP_SLEEP_WAKEUP_TIMER)
         ssd1306_found = false; // forget we even have the hardware
+
+    esp32Setup();
+#endif
+
+#ifdef NRF52_SERIES
+    nrf52Setup();
 #endif
 
     // Initialize the screen first so we can show the logo while we start up everything else.
     if (ssd1306_found)
         screen.setup();
 
-    axp192Init();
-
     screen.print("Started...\n");
 
-    // Init GPS
-    gps.setup();
+    readFromRTC(); // read the main CPU RTC at first (in case we can't get GPS time)
+
+    // Init GPS - first try ublox
+    gps = new UBloxGPS();
+    if (!gps->setup()) {
+        // Some boards might have only the TX line from the GPS connected, in that case, we can't configure it at all.  Just
+        // assume NEMA at 9600 baud.
+        DEBUG_MSG("ERROR: No UBLOX GPS found, hoping that NEMA might work\n");
+        delete gps;
+        gps = new NEMAGPS();
+        gps->setup();
+    }
 
     service.init();
 
-#ifndef NO_ESP32
-    // MUST BE AFTER service.init, so we have our radio config settings (from nodedb init)
-    radio = new MeshRadio();
-    router.addInterface(&radio->radioIf);
+    realRouter.setup(); // required for our periodic task (kinda skanky FIXME)
+
+#ifdef SX1262_ANT_SW
+    // make analog PA vs not PA switch on SX1262 eval board work properly
+    pinMode(SX1262_ANT_SW, OUTPUT);
+    digitalWrite(SX1262_ANT_SW, 1);
 #endif
 
+    // Init our SPI controller
+#ifdef NRF52_SERIES
+    SPI.begin();
+#else
+    // ESP32
+    SPI.begin(SCK_GPIO, MISO_GPIO, MOSI_GPIO, NSS_GPIO);
+    SPI.setFrequency(4000000);
+#endif
+
+    // MUST BE AFTER service.init, so we have our radio config settings (from nodedb init)
+    RadioInterface *rIf =
+#if defined(RF95_IRQ_GPIO)
+        // new CustomRF95(); old Radiohead based driver
+        new RF95Interface(NSS_GPIO, RF95_IRQ_GPIO, RESET_GPIO, SPI);
+#elif defined(SX1262_CS)
+        new SX1262Interface(SX1262_CS, SX1262_DIO1, SX1262_RESET, SX1262_BUSY, SPI);
+#else
+        new SimRadio();
+#endif
+    radio = new MeshRadio(rIf);
+    router.addInterface(&radio->radioIf);
+
     if (radio && !radio->init())
         recordCriticalError(ErrNoRadio);
 
@@ -299,19 +244,6 @@ void setup()
     setCPUFast(false); // 80MHz is fine for our slow peripherals
 }
 
-uint32_t ledBlinker()
-{
-    static bool ledOn;
-    ledOn ^= 1;
-
-    setLed(ledOn);
-
-    // have a very sparse duty cycle of LED being on, unless charging, then blink 0.5Hz square wave rate to indicate that
-    return powerStatus.charging ? 1000 : (ledOn ? 2 : 1000);
-}
-
-Periodic ledPeriodic(ledBlinker);
-
 #if 0
 // Turn off for now
 
@@ -330,60 +262,28 @@ uint32_t axpDebugRead()
 }
 
 Periodic axpDebugOutput(axpDebugRead);
+axpDebugOutput.setup();
 #endif
 
 void loop()
 {
     uint32_t msecstosleep = 1000 * 30; // How long can we sleep before we again need to service the main loop?
 
-    powerFSM.run_machine();
-    gps.loop();
+    gps->loop(); // FIXME, remove from main, instead block on read
     router.loop();
+    powerFSM.run_machine();
     service.loop();
 
-    ledPeriodic.loop();
+    periodicScheduler.loop();
     // axpDebugOutput.loop();
 
-#ifndef NO_ESP32
-    loopBLE();
+#ifdef DEBUG_PORT
+    DEBUG_PORT.loop(); // Send/receive protobufs over the serial port
 #endif
 
-    // for debug printing
-    // radio.radioIf.canSleep();
-
-#ifdef PMU_IRQ
-    if (pmu_irq) {
-        pmu_irq = false;
-        axp.readIRQ();
-
-        DEBUG_MSG("pmu irq!\n");
-
-        if (axp.isChargingIRQ()) {
-            DEBUG_MSG("Battery start charging\n");
-        }
-        if (axp.isChargingDoneIRQ()) {
-            DEBUG_MSG("Battery fully charged\n");
-        }
-        if (axp.isVbusRemoveIRQ()) {
-            DEBUG_MSG("USB unplugged\n");
-        }
-        if (axp.isVbusPlugInIRQ()) {
-            DEBUG_MSG("USB plugged In\n");
-        }
-        if (axp.isBattPlugInIRQ()) {
-            DEBUG_MSG("Battery inserted\n");
-        }
-        if (axp.isBattRemoveIRQ()) {
-            DEBUG_MSG("Battery removed\n");
-        }
-        if (axp.isPEKShortPressIRQ()) {
-            DEBUG_MSG("PEK short button press\n");
-        }
-
-        readPowerStatus();
-        axp.clearIRQ();
-    }
-#endif // T_BEAM_V10
+#ifndef NO_ESP32
+    esp32Loop();
+#endif
 
 #ifdef BUTTON_PIN
     // if user presses button for more than 3 secs, discard our network prefs and reboot (FIXME, use a debounce lib instead of
@@ -418,8 +318,7 @@ void loop()
     screen.debug()->setChannelNameStatus(channelSettings.name);
     screen.debug()->setPowerStatus(powerStatus);
     // TODO(#4): use something based on hdop to show GPS "signal" strength.
-    screen.debug()->setGPSStatus(gps.hasLock() ? "ok" : ":(");
-    screen.loop();
+    screen.debug()->setGPSStatus(gps->hasLock() ? "good" : "bad");
 
     // No GPS lock yet, let the OS put the main CPU in low power mode for 100ms (or until another interrupt comes in)
     // i.e. don't just keep spinning in loop as fast as we can.

src/main.h

@@ -12,3 +12,7 @@ extern meshtastic::Screen screen;
 
 // Return a human readable string of the form "Meshtastic_ab13"
 const char *getDeviceName();
+
+void getMacAddr(uint8_t *dmac);
+
+void nrf52Setup(), esp32Setup(), nrf52Loop(), esp32Loop();

src/mesh/FloodingRouter.cpp

@@ -0,0 +1,147 @@
+#include "FloodingRouter.h"
+#include "configuration.h"
+#include "mesh-pb-constants.h"
+
+/// We clear our old flood record five minute after we see the last of it
+#define FLOOD_EXPIRE_TIME (5 * 60 * 1000L)
+
+static bool supportFlooding = true; // Sometimes to simplify debugging we want jusT simple broadcast only
+
+FloodingRouter::FloodingRouter() : toResend(MAX_NUM_NODES)
+{
+    recentBroadcasts.reserve(MAX_NUM_NODES); // Prealloc the worst case # of records - to prevent heap fragmentation
+                                             // setup our periodic task
+}
+
+/**
+ * Send a packet on a suitable interface.  This routine will
+ * later free() the packet to pool.  This routine is not allowed to stall.
+ * If the txmit queue is full it might return an error
+ */
+ErrorCode FloodingRouter::send(MeshPacket *p)
+{
+    // We update our table of recent broadcasts, even for messages we send
+    if (supportFlooding)
+        wasSeenRecently(p);
+
+    return Router::send(p);
+}
+
+// Return a delay in msec before sending the next packet
+uint32_t getRandomDelay()
+{
+    return random(200, 10 * 1000L); // between 200ms and 10s
+}
+
+/**
+ * Now that our generalized packet send code has a random delay - I don't think we need to wait here
+ * But I'm leaving this bool until I rip the code out for good.
+ */
+bool needDelay = false;
+
+/**
+ * Called from loop()
+ * Handle any packet that is received by an interface on this node.
+ * Note: some packets may merely being passed through this node and will be forwarded elsewhere.
+ *
+ * Note: this method will free the provided packet
+ */
+void FloodingRouter::handleReceived(MeshPacket *p)
+{
+    if (supportFlooding) {
+        if (wasSeenRecently(p)) {
+            DEBUG_MSG("Ignoring incoming floodmsg, because we've already seen it\n");
+            packetPool.release(p);
+        } else {
+            if (p->to == NODENUM_BROADCAST) {
+                if (p->id != 0) {
+                    MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
+
+                    if (needDelay) {
+                        uint32_t delay = getRandomDelay();
+
+                        DEBUG_MSG("Rebroadcasting received floodmsg to neighbors in %u msec, fr=0x%x,to=0x%x,id=%d\n", delay,
+                                  p->from, p->to, p->id);
+
+                        toResend.enqueue(tosend);
+                        setPeriod(delay); // This will work even if we were already waiting a random delay
+                    } else {
+                        DEBUG_MSG("Rebroadcasting received floodmsg to neighbors, fr=0x%x,to=0x%x,id=%d\n", p->from, p->to,
+                                  p->id);
+                        // Note: we are careful to resend using the original senders node id
+                        // We are careful not to call our hooked version of send() - because we don't want to check this again
+                        Router::send(tosend);
+                    }
+                } else {
+                    DEBUG_MSG("Ignoring a simple (0 hop) broadcast\n");
+                }
+            }
+
+            // handle the packet as normal
+            Router::handleReceived(p);
+        }
+    } else
+        Router::handleReceived(p);
+}
+
+void FloodingRouter::doTask()
+{
+    MeshPacket *p = toResend.dequeuePtr(0);
+
+    if (p) {
+        DEBUG_MSG("Sending delayed message!\n");
+        // Note: we are careful to resend using the original senders node id
+        // We are careful not to call our hooked version of send() - because we don't want to check this again
+        Router::send(p);
+    }
+
+    if (toResend.isEmpty())
+        disable(); // no more work right now
+    else {
+        setPeriod(getRandomDelay());
+    }
+}
+
+/**
+ * Update recentBroadcasts and return true if we have already seen this packet
+ */
+bool FloodingRouter::wasSeenRecently(const MeshPacket *p)
+{
+    if (p->to != NODENUM_BROADCAST)
+        return false; // Not a broadcast, so we don't care
+
+    if (p->id == 0) {
+        DEBUG_MSG("Ignoring message with zero id\n");
+        return false; // Not a floodable message ID, so we don't care
+    }
+
+    uint32_t now = millis();
+    for (int i = 0; i < recentBroadcasts.size();) {
+        BroadcastRecord &r = recentBroadcasts[i];
+
+        if ((now - r.rxTimeMsec) >= FLOOD_EXPIRE_TIME) {
+            // DEBUG_MSG("Deleting old broadcast record %d\n", i);
+            recentBroadcasts.erase(recentBroadcasts.begin() + i); // delete old record
+        } else {
+            if (r.id == p->id && r.sender == p->from) {
+                DEBUG_MSG("Found existing broadcast record for fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
+
+                // Update the time on this record to now
+                r.rxTimeMsec = now;
+                return true;
+            }
+
+            i++;
+        }
+    }
+
+    // Didn't find an existing record, make one
+    BroadcastRecord r;
+    r.id = p->id;
+    r.sender = p->from;
+    r.rxTimeMsec = now;
+    recentBroadcasts.push_back(r);
+    DEBUG_MSG("Adding broadcast record for fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
+
+    return false;
+}

src/mesh/FloodingRouter.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "PeriodicTask.h"
 #include "Router.h"
 #include <vector>
 
@@ -35,11 +36,19 @@ struct BroadcastRecord {
   Any entries in recentBroadcasts that are older than X seconds (longer than the
   max time a flood can take) will be discarded.
  */
-class FloodingRouter : public Router
+class FloodingRouter : public Router, public PeriodicTask
 {
   private:
+    /** FIXME: really should be a std::unordered_set with the key being sender,id.
+     * This would make checking packets in wasSeenRecently faster.
+     */
     std::vector<BroadcastRecord> recentBroadcasts;
 
+    /**
+     * Packets we've received that we need to resend after a short delay
+     */
+    PointerQueue<MeshPacket> toResend;
+
   public:
     /**
      * Constructor
@@ -64,6 +73,8 @@ class FloodingRouter : public Router
      */
     virtual void handleReceived(MeshPacket *p);
 
+    virtual void doTask();
+
   private:
     /**
      * Update recentBroadcasts and return true if we have already seen this packet

src/mesh/MeshRadio.cpp

@@ -24,7 +24,7 @@ separated by 2.16 MHz with respect to the adjacent channels. Channel zero starts
 /// Sometimes while debugging it is useful to set this false, to disable rf95 accesses
 bool useHardware = true;
 
-MeshRadio::MeshRadio() // , manager(radioIf)
+MeshRadio::MeshRadio(RadioInterface *rIf) : radioIf(*rIf) // , manager(radioIf)
 {
     myNodeInfo.num_channels = NUM_CHANNELS;
 
@@ -54,19 +54,18 @@ bool MeshRadio::init()
     delay(10);
 #endif
 
-    radioIf.setThisAddress(
-        nodeDB.getNodeNum()); // Note: we must do this here, because the nodenum isn't inited at constructor time.
+    // we now expect interfaces to operate in promiscous mode
+    // radioIf.setThisAddress(nodeDB.getNodeNum()); // Note: we must do this here, because the nodenum isn't inited at constructor
+    // time.
+
+    applySettings();
 
     if (!radioIf.init()) {
         DEBUG_MSG("LoRa radio init failed\n");
-        DEBUG_MSG("Uncomment '#define SERIAL_DEBUG' in RH_RF95.cpp for detailed debug info\n");
         return false;
     }
 
-    // not needed - defaults on
-    // rf95.setPayloadCRC(true);
-
-    reloadConfig();
+    // No need to call this now, init is supposed to do same.  reloadConfig();
 
     return true;
 }
@@ -87,39 +86,28 @@ unsigned long hash(char *str)
     return hash;
 }
 
-int MeshRadio::reloadConfig(void *unused)
+/**
+ * Pull our channel settings etc... from protobufs to the dumb interface settings
+ */
+void MeshRadio::applySettings()
 {
-    radioIf.setModeIdle(); // Need to be idle before doing init
-
     // Set up default configuration
     // No Sync Words in LORA mode.
-    radioIf.setModemConfig(
-        (RH_RF95::ModemConfigChoice)channelSettings.modem_config); // Radio default
-                                                                   //    setModemConfig(Bw125Cr48Sf4096); // slow and reliable?
-    // rf95.setPreambleLength(8);           // Default is 8
+    radioIf.modemConfig = (ModemConfigChoice)channelSettings.modem_config;
 
     // Defaults after init are 434.0MHz, modulation GFSK_Rb250Fd250, +13dbM
     int channel_num = hash(channelSettings.name) % NUM_CHANNELS;
-    float center_freq = CH0 + CH_SPACING * channel_num;
-    if (!radioIf.setFrequency(center_freq)) {
-        DEBUG_MSG("setFrequency failed\n");
-        assert(0); // fixme panic
-    }
-
-    // Defaults after init are 434.0MHz, 13dBm, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on
-
-    // The default transmitter power is 13dBm, using PA_BOOST.
-    // If you are using RFM95/96/97/98 modules which uses the PA_BOOST transmitter pin, then
-    // you can set transmitter powers from 5 to 23 dBm:
-    // FIXME - can we do this?  It seems to be in the Heltec board.
-    radioIf.setTxPower(channelSettings.tx_power, false);
+    radioIf.freq = CH0 + CH_SPACING * channel_num;
+    radioIf.power = channelSettings.tx_power;
 
     DEBUG_MSG("Set radio: name=%s, config=%u, ch=%d, txpower=%d\n", channelSettings.name, channelSettings.modem_config,
               channel_num, channelSettings.tx_power);
+}
 
-    // Done with init tell radio to start receiving
-    radioIf.setModeRx();
+int MeshRadio::reloadConfig(void *unused)
+{
+    applySettings();
+    radioIf.reconfigure();
 
     return 0;
 }
-

src/mesh/MeshRadio.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#include "CustomRF95.h"
 #include "MemoryPool.h"
 #include "MeshTypes.h"
 #include "Observer.h"
 #include "PointerQueue.h"
+#include "RadioInterface.h"
 #include "configuration.h"
 #include "mesh.pb.h"
 
@@ -55,28 +55,27 @@
 #define CH_SPACING CH_SPACING_JP
 #define NUM_CHANNELS NUM_CHANNELS_JP
 #else
-#error "HW_VERSION not set"
+// HW version not set - assume US
+#define CH0 CH0_US
+#define CH_SPACING CH_SPACING_US
+#define NUM_CHANNELS NUM_CHANNELS_US
 #endif
 
 /**
  * A raw low level interface to our mesh.  Only understands nodenums and bytes (not protobufs or node ids)
+ * FIXME - REMOVE THIS CLASS
  */
 class MeshRadio
 {
   public:
     // Kinda ugly way of selecting different radio implementations, but soon this MeshRadio class will be going away
     // entirely.  At that point we can make things pretty.
-#ifdef RF95_IRQ_GPIO
-    CustomRF95
-        radioIf; // the raw radio interface - for now I'm leaving public - because this class is shrinking to be almost nothing
-#else
-    SimRadio radioIf;
-#endif
+    RadioInterface &radioIf;
 
     /** 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
      */
-    MeshRadio();
+    MeshRadio(RadioInterface *rIf);
 
     bool init();
 
@@ -101,4 +100,9 @@ class MeshRadio
         radioIf.sleep();
         return 0;
     }
+
+    /**
+     * Pull our channel settings etc... from protobufs to the dumb interface settings
+     */
+    void applySettings();
 };

src/mesh/MeshService.cpp

@@ -48,11 +48,27 @@ MeshService service;
 
 #define NUM_PACKET_ID 255 // 0 is consider invalid
 
+static uint32_t sendOwnerCb()
+{
+    service.sendOurOwner();
+
+    return radioConfig.preferences.send_owner_interval * radioConfig.preferences.position_broadcast_secs * 1000;
+}
+
+static Periodic sendOwnerPeriod(sendOwnerCb);
+
 /// Generate a unique packet id
 // FIXME, move this someplace better
 PacketId generatePacketId()
 {
-    static uint32_t i;
+    static uint32_t i; // Note: trying to keep this in noinit didn't help for working across reboots
+    static bool didInit = false;
+
+    if (!didInit) {
+        didInit = true;
+        i = random(0, NUM_PACKET_ID +
+                          1); // pick a random initial sequence number at boot (to prevent repeated reboots always starting at 0)
+    }
 
     i++;
     return (i % NUM_PACKET_ID) + 1; // return number between 1 and 255
@@ -65,13 +81,11 @@ MeshService::MeshService() : toPhoneQueue(MAX_RX_TOPHONE)
 
 void MeshService::init()
 {
+    sendOwnerPeriod.setup();
     nodeDB.init();
 
-    gpsObserver.observe(&gps);
+    gpsObserver.observe(gps);
     packetReceivedObserver.observe(&router.notifyPacketReceived);
-
-    // No need to call this here, our periodic task will fire quite soon
-    // sendOwnerPeriod();
 }
 
 void MeshService::sendOurOwner(NodeNum dest, bool wantReplies)
@@ -139,7 +153,7 @@ void MeshService::handleIncomingPosition(const MeshPacket *mp)
             tv.tv_sec = secs;
             tv.tv_usec = 0;
 
-            gps.perhapsSetRTC(&tv);
+            perhapsSetRTC(&tv);
         }
     } else {
         DEBUG_MSG("Ignoring incoming packet - not a position\n");
@@ -151,7 +165,7 @@ int MeshService::handleFromRadio(const MeshPacket *mp)
     powerFSM.trigger(EVENT_RECEIVED_PACKET); // Possibly keep the node from sleeping
 
     // If it is a position packet, perhaps set our clock (if we don't have a GPS of our own, otherwise wait for that to work)
-    if (!gps.isConnected)
+    if (!gps->isConnected)
         handleIncomingPosition(mp);
     else {
         DEBUG_MSG("Ignoring incoming time, because we have a GPS\n");
@@ -187,15 +201,6 @@ int MeshService::handleFromRadio(const MeshPacket *mp)
     return 0;
 }
 
-uint32_t sendOwnerCb()
-{
-    service.sendOurOwner();
-
-    return radioConfig.preferences.send_owner_interval * radioConfig.preferences.position_broadcast_secs * 1000;
-}
-
-Periodic sendOwnerPeriod(sendOwnerCb);
-
 /// Do idle processing (mostly processing messages which have been queued from the radio)
 void MeshService::loop()
 {
@@ -203,9 +208,6 @@ void MeshService::loop()
         fromNumChanged.notifyObservers(fromNum);
         oldFromNum = fromNum;
     }
-
-    // occasionally send our owner info
-    sendOwnerPeriod.loop();
 }
 
 /// The radioConfig object just changed, call this to force the hw to change to the new settings
@@ -217,46 +219,34 @@ void MeshService::reloadConfig()
     nodeDB.saveToDisk();
 }
 
-/// Given a ToRadio buffer parse it and properly handle it (setup radio, owner or send packet into the mesh)
-void MeshService::handleToRadio(std::string s)
+/**
+ *  Given a ToRadio buffer parse it and properly handle it (setup radio, owner or send packet into the mesh)
+ * Called by PhoneAPI.handleToRadio.  Note: p is a scratch buffer, this function is allowed to write to it but it can not keep a
+ * reference
+ */
+void MeshService::handleToRadio(MeshPacket &p)
 {
-    static ToRadio r; // this is a static scratch object, any data must be copied elsewhere before returning
+    handleIncomingPosition(&p); // If it is a position packet, perhaps set our clock
 
-    if (pb_decode_from_bytes((const uint8_t *)s.c_str(), s.length(), ToRadio_fields, &r)) {
-        switch (r.which_variant) {
-        case ToRadio_packet_tag: {
-            // If our phone is sending a position, see if we can use it to set our RTC
-            MeshPacket &p = r.variant.packet;
-            handleIncomingPosition(&p); // If it is a position packet, perhaps set our clock
+    if (p.from == 0) // If the phone didn't set a sending node ID, use ours
+        p.from = nodeDB.getNodeNum();
 
-            if (p.from == 0) // If the phone didn't set a sending node ID, use ours
-                p.from = nodeDB.getNodeNum();
+    if (p.id == 0)
+        p.id = generatePacketId(); // If the phone didn't supply one, then pick one
 
-            if (p.id == 0)
-                p.id = generatePacketId(); // If the phone didn't supply one, then pick one
+    p.rx_time = getValidTime(); // Record the time the packet arrived from the phone
+                                // (so we update our nodedb for the local node)
 
-            p.rx_time = gps.getValidTime(); // Record the time the packet arrived from the phone
-                                            // (so we update our nodedb for the local node)
+    // Send the packet into the mesh
 
-            // Send the packet into the mesh
+    sendToMesh(packetPool.allocCopy(p));
 
-            sendToMesh(packetPool.allocCopy(p));
-
-            bool loopback = false; // if true send any packet the phone sends back itself (for testing)
-            if (loopback) {
-                // no need to copy anymore because handle from radio assumes it should _not_ delete
-                // packetPool.allocCopy(r.variant.packet);
-                handleFromRadio(&p);
-                // handleFromRadio will tell the phone a new packet arrived
-            }
-            break;
-        }
-        default:
-            DEBUG_MSG("Error: unexpected ToRadio variant\n");
-            break;
-        }
-    } else {
-        DEBUG_MSG("Error: ignoring malformed toradio\n");
+    bool loopback = false; // if true send any packet the phone sends back itself (for testing)
+    if (loopback) {
+        // no need to copy anymore because handle from radio assumes it should _not_ delete
+        // packetPool.allocCopy(r.variant.packet);
+        handleFromRadio(&p);
+        // handleFromRadio will tell the phone a new packet arrived
     }
 }
 
@@ -268,7 +258,7 @@ void MeshService::sendToMesh(MeshPacket *p)
     // nodes shouldn't trust it anyways) Note: for now, we allow a device with a local GPS to include the time, so that gpsless
     // devices can get time.
     if (p->has_payload && p->payload.has_position) {
-        if (!gps.isConnected) {
+        if (!gps->isConnected) {
             DEBUG_MSG("Stripping time %u from position send\n", p->payload.position.time);
             p->payload.position.time = 0;
         } else
@@ -276,9 +266,10 @@ void MeshService::sendToMesh(MeshPacket *p)
     }
 
     // If the phone sent a packet just to us, don't send it out into the network
-    if (p->to == nodeDB.getNodeNum())
+    if (p->to == nodeDB.getNodeNum()) {
         DEBUG_MSG("Dropping locally processed message\n");
-    else {
+        releaseToPool(p);
+    } else {
         // Note: We might return !OK if our fifo was full, at that point the only option we have is to drop it
         if (router.send(p) != ERRNO_OK) {
             DEBUG_MSG("No radio was able to send packet, discarding...\n");
@@ -295,7 +286,7 @@ MeshPacket *MeshService::allocForSending()
     p->from = nodeDB.getNodeNum();
     p->to = NODENUM_BROADCAST;
     p->id = generatePacketId();
-    p->rx_time = gps.getValidTime(); // Just in case we process the packet locally - make sure it has a valid timestamp
+    p->rx_time = getValidTime(); // Just in case we process the packet locally - make sure it has a valid timestamp
 
     return p;
 }
@@ -324,13 +315,13 @@ void MeshService::sendOurPosition(NodeNum dest, bool wantReplies)
     p->payload.has_position = true;
     p->payload.position = node->position;
     p->payload.want_response = wantReplies;
-    p->payload.position.time = gps.getValidTime(); // This nodedb timestamp might be stale, so update it if our clock is valid.
+    p->payload.position.time = getValidTime(); // This nodedb timestamp might be stale, so update it if our clock is valid.
     sendToMesh(p);
 }
 
 int MeshService::onGPSChanged(void *unused)
 {
-    DEBUG_MSG("got gps notify\n");
+    // DEBUG_MSG("got gps notify\n");
 
     // Update our local node info with our position (even if we don't decide to update anyone else)
     MeshPacket *p = allocForSending();
@@ -338,12 +329,12 @@ int MeshService::onGPSChanged(void *unused)
 
     Position &pos = p->payload.position;
     // !zero or !zero lat/long means valid
-    if (gps.latitude != 0 || gps.longitude != 0) {
-        if (gps.altitude != 0)
-            pos.altitude = gps.altitude;
-        pos.latitude = gps.latitude;
-        pos.longitude = gps.longitude;
-        pos.time = gps.getValidTime();
+    if (gps->latitude != 0 || gps->longitude != 0) {
+        if (gps->altitude != 0)
+            pos.altitude = gps->altitude;
+        pos.latitude_i = gps->latitude;
+        pos.longitude_i = gps->longitude;
+        pos.time = getValidTime();
     }
 
     // We limit our GPS broadcasts to a max rate

src/mesh/MeshService.h

@@ -54,8 +54,12 @@ class MeshService
     /// Allows the bluetooth handler to free packets after they have been sent
     void releaseToPool(MeshPacket *p) { packetPool.release(p); }
 
-    /// Given a ToRadio buffer (from bluetooth) parse it and properly handle it (setup radio, owner or send packet into the mesh)
-    void handleToRadio(std::string s);
+    /**
+     *  Given a ToRadio buffer parse it and properly handle it (setup radio, owner or send packet into the mesh)
+     * Called by PhoneAPI.handleToRadio.  Note: p is a scratch buffer, this function is allowed to write to it but it can not keep
+     * a reference
+     */
+    void handleToRadio(MeshPacket &p);
 
     /// The radioConfig object just changed, call this to force the hw to change to the new settings
     void reloadConfig();

src/mesh/MeshTypes.h

@@ -11,6 +11,7 @@ typedef uint8_t PacketId; // A packet sequence number
 
 #define NODENUM_BROADCAST 255
 #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
 
 typedef int ErrorCode;

src/mesh/NodeDB.cpp

@@ -83,6 +83,7 @@ void NodeDB::resetRadioConfig()
     /*
     radioConfig.preferences.screen_on_secs = 30;
     radioConfig.preferences.wait_bluetooth_secs = 30;
+    radioConfig.preferences.position_broadcast_secs = 15;
     */
 }
 
@@ -245,7 +246,7 @@ const NodeInfo *NodeDB::readNextInfo()
 /// Given a node, return how many seconds in the past (vs now) that we last heard from it
 uint32_t sinceLastSeen(const NodeInfo *n)
 {
-    uint32_t now = gps.getTime();
+    uint32_t now = getTime();
 
     uint32_t last_seen = n->position.time;
     int delta = (int)(now - last_seen);
@@ -288,6 +289,8 @@ void NodeDB::updateFrom(const MeshPacket &mp)
             info->position.time = mp.rx_time;
         }
 
+        info->snr = mp.rx_snr; // keep the most recent SNR we received for this node.
+
         if (p.has_position) {
             // we carefully preserve the old time, because we always trust our local timestamps more
             uint32_t oldtime = info->position.time;
@@ -300,7 +303,8 @@ void NodeDB::updateFrom(const MeshPacket &mp)
         if (p.has_data) {
             // Keep a copy of the most recent text message.
             if (p.data.typ == Data_Type_CLEAR_TEXT) {
-                DEBUG_MSG("Received text msg from=0%0x, msg=%.*s\n", mp.from, p.data.payload.size, p.data.payload.bytes);
+                DEBUG_MSG("Received text msg from=0x%0x, id=%d, msg=%.*s\n", mp.from, mp.id, p.data.payload.size,
+                          p.data.payload.bytes);
                 if (mp.to == NODENUM_BROADCAST || mp.to == nodeDB.getNodeNum()) {
                     // We only store/display messages destined for us.
                     devicestate.rx_text_message = mp;

src/mesh/PhoneAPI.cpp

@@ -0,0 +1,237 @@
+#include "PhoneAPI.h"
+#include "MeshService.h"
+#include "NodeDB.h"
+#include <assert.h>
+
+PhoneAPI::PhoneAPI()
+{
+    assert(FromRadio_size <= MAX_TO_FROM_RADIO_SIZE);
+    assert(ToRadio_size <= MAX_TO_FROM_RADIO_SIZE);
+}
+
+void PhoneAPI::init()
+{
+    observe(&service.fromNumChanged);
+}
+
+/**
+ * Handle a ToRadio protobuf
+ */
+void PhoneAPI::handleToRadio(const uint8_t *buf, size_t bufLength)
+{
+    if (pb_decode_from_bytes(buf, bufLength, ToRadio_fields, &toRadioScratch)) {
+        switch (toRadioScratch.which_variant) {
+        case ToRadio_packet_tag: {
+            // If our phone is sending a position, see if we can use it to set our RTC
+            MeshPacket &p = toRadioScratch.variant.packet;
+            service.handleToRadio(p);
+            break;
+        }
+        case ToRadio_want_config_id_tag:
+            config_nonce = toRadioScratch.variant.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
+            break;
+
+        case ToRadio_set_owner_tag:
+            DEBUG_MSG("Client is setting owner\n");
+            handleSetOwner(toRadioScratch.variant.set_owner);
+            break;
+
+        case ToRadio_set_radio_tag:
+            DEBUG_MSG("Client is setting radio\n");
+            handleSetRadio(toRadioScratch.variant.set_radio);
+            break;
+
+        default:
+            DEBUG_MSG("Error: unexpected ToRadio variant\n");
+            break;
+        }
+    } else {
+        DEBUG_MSG("Error: ignoring malformed toradio\n");
+    }
+}
+
+/**
+ * Get the next packet we want to send to the phone, or NULL if no such packet is available.
+ *
+ * We assume buf is at least FromRadio_size bytes long.
+ *
+ * Our sending states progress in the following sequence (the client app ASSUMES THIS SEQUENCE, DO NOT CHANGE IT):
+ *      STATE_SEND_MY_INFO, // send our my info record
+        STATE_SEND_RADIO,
+        STATE_SEND_NODEINFO, // states progress in this order as the device sends to to the client
+        STATE_SEND_COMPLETE_ID,
+        STATE_SEND_PACKETS // send packets or debug strings
+ */
+size_t PhoneAPI::getFromRadio(uint8_t *buf)
+{
+    if (!available())
+        return false;
+
+    // In case we send a FromRadio packet
+    memset(&fromRadioScratch, 0, sizeof(fromRadioScratch));
+
+    // Advance states as needed
+    switch (state) {
+    case STATE_SEND_NOTHING:
+        break;
+
+    case STATE_SEND_MY_INFO:
+        fromRadioScratch.which_variant = FromRadio_my_info_tag;
+        fromRadioScratch.variant.my_info = myNodeInfo;
+        state = STATE_SEND_RADIO;
+        break;
+
+    case STATE_SEND_RADIO:
+        fromRadioScratch.which_variant = FromRadio_radio_tag;
+        fromRadioScratch.variant.radio = radioConfig;
+        state = STATE_SEND_NODEINFO;
+        break;
+
+    case STATE_SEND_NODEINFO: {
+        const NodeInfo *info = nodeInfoForPhone;
+        nodeInfoForPhone = NULL; // We just consumed a nodeinfo, will need a new one next time
+
+        if (info) {
+            DEBUG_MSG("Sending nodeinfo: num=0x%x, lastseen=%u, id=%s, name=%s\n", info->num, info->position.time, info->user.id,
+                      info->user.long_name);
+            fromRadioScratch.which_variant = FromRadio_node_info_tag;
+            fromRadioScratch.variant.node_info = *info;
+            // Stay in current state until done sending nodeinfos
+        } else {
+            DEBUG_MSG("Done sending nodeinfos\n");
+            state = STATE_SEND_COMPLETE_ID;
+            // Go ahead and send that ID right now
+            return getFromRadio(buf);
+        }
+        break;
+    }
+
+    case STATE_SEND_COMPLETE_ID:
+        fromRadioScratch.which_variant = FromRadio_config_complete_id_tag;
+        fromRadioScratch.variant.config_complete_id = config_nonce;
+        config_nonce = 0;
+        state = STATE_SEND_PACKETS;
+        break;
+
+    case STATE_LEGACY: // Treat as the same as send packets
+    case STATE_SEND_PACKETS:
+        // Do we have a message from the mesh?
+        if (packetForPhone) {
+            // Encapsulate as a FromRadio packet
+            fromRadioScratch.which_variant = FromRadio_packet_tag;
+            fromRadioScratch.variant.packet = *packetForPhone;
+
+            service.releaseToPool(packetForPhone); // we just copied the bytes, so don't need this buffer anymore
+            packetForPhone = NULL;
+        }
+        break;
+
+    default:
+        assert(0); // unexpected state - FIXME, make an error code and reboot
+    }
+
+    // Do we have a message from the mesh?
+    if (fromRadioScratch.which_variant != 0) {
+        // Encapsulate as a FromRadio packet
+        DEBUG_MSG("encoding toPhone packet to phone variant=%d", fromRadioScratch.which_variant);
+        size_t numbytes = pb_encode_to_bytes(buf, FromRadio_size, FromRadio_fields, &fromRadioScratch);
+        DEBUG_MSG(", %d bytes\n", numbytes);
+        return numbytes;
+    }
+
+    DEBUG_MSG("no FromRadio packet available\n");
+    return 0;
+}
+
+/**
+ * Return true if we have data available to send to the phone
+ */
+bool PhoneAPI::available()
+{
+    switch (state) {
+    case STATE_SEND_NOTHING:
+        return false;
+
+    case STATE_SEND_MY_INFO:
+        return true;
+
+    case STATE_SEND_NODEINFO:
+        if (!nodeInfoForPhone)
+            nodeInfoForPhone = nodeDB.readNextInfo();
+        return true; // Always say we have something, because we might need to advance our state machine
+
+    case STATE_SEND_RADIO:
+        return true;
+
+    case STATE_SEND_COMPLETE_ID:
+        return true;
+
+    case STATE_LEGACY: // Treat as the same as send packets
+    case STATE_SEND_PACKETS:
+        // Try to pull a new packet from the service (if we haven't already)
+        if (!packetForPhone)
+            packetForPhone = service.getForPhone();
+        return !!packetForPhone;
+
+    default:
+        assert(0); // unexpected state - FIXME, make an error code and reboot
+    }
+
+    return false;
+}
+
+//
+// The following routines are only public for now - until the rev1 bluetooth API is removed
+//
+
+void PhoneAPI::handleSetOwner(const User &o)
+{
+    int changed = 0;
+
+    if (*o.long_name) {
+        changed |= strcmp(owner.long_name, o.long_name);
+        strcpy(owner.long_name, o.long_name);
+    }
+    if (*o.short_name) {
+        changed |= strcmp(owner.short_name, o.short_name);
+        strcpy(owner.short_name, o.short_name);
+    }
+    if (*o.id) {
+        changed |= strcmp(owner.id, o.id);
+        strcpy(owner.id, o.id);
+    }
+
+    if (changed) // If nothing really changed, don't broadcast on the network or write to flash
+        service.reloadOwner();
+}
+
+void PhoneAPI::handleSetRadio(const RadioConfig &r)
+{
+    radioConfig = r;
+
+    service.reloadConfig();
+}
+
+/**
+ * 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) {}
+
+/// If the mesh service tells us fromNum has changed, tell the phone
+int PhoneAPI::onNotify(uint32_t newValue)
+{
+    if (state == STATE_SEND_PACKETS || state == STATE_LEGACY) {
+        DEBUG_MSG("Telling client we have new packets %u\n", newValue);
+        onNowHasData(newValue);
+    } else
+        DEBUG_MSG("(Client not yet interested in packets)\n");
+
+    return 0;
+}

src/mesh/PhoneAPI.h

@@ -0,0 +1,101 @@
+#pragma once
+
+#include "Observer.h"
+#include "mesh-pb-constants.h"
+#include "mesh.pb.h"
+#include <string>
+
+// Make sure that we never let our packets grow too large for one BLE packet
+#define MAX_TO_FROM_RADIO_SIZE 512
+
+/**
+ * Provides our protobuf based API which phone/PC clients can use to talk to our device
+ * over UDP, bluetooth or serial.
+ *
+ * Subclass to customize behavior for particular type of transport (BLE, UDP, TCP, serial)
+ *
+ * Eventually there should be once instance of this class for each live connection (because it has a bit of state
+ * for that connection)
+ */
+class PhoneAPI
+    : public Observer<uint32_t> // FIXME, we shouldn't be inheriting from Observer, instead use CallbackObserver as a member
+{
+    enum State {
+        STATE_LEGACY,       // Temporary default state - until Android apps are all updated, uses the old BLE API
+        STATE_SEND_NOTHING, // (Eventual) Initial state, don't send anything until the client starts asking for config
+        STATE_SEND_MY_INFO, // send our my info record
+        STATE_SEND_RADIO,
+        // STATE_SEND_OWNER, no need to send Owner specially, it is just part of the nodedb
+        STATE_SEND_NODEINFO, // states progress in this order as the device sends to to the client
+        STATE_SEND_COMPLETE_ID,
+        STATE_SEND_PACKETS // send packets or debug strings
+    };
+
+    State state = STATE_LEGACY;
+
+    /**
+     * Each packet sent to the phone has an incrementing count
+     */
+    uint32_t fromRadioNum = 0;
+
+    /// We temporarily keep the packet here between the call to available and getFromRadio.  We will free it after the phone
+    /// downloads it
+    MeshPacket *packetForPhone = NULL;
+
+    /// We temporarily keep the nodeInfo here between the call to available and getFromRadio
+    const NodeInfo *nodeInfoForPhone = NULL;
+
+    ToRadio toRadioScratch; // this is a static scratch object, any data must be copied elsewhere before returning
+
+    /// Use to ensure that clients don't get confused about old messages from the radio
+    uint32_t config_nonce = 0;
+
+  public:
+    PhoneAPI();
+
+    /// Do late init that can't happen at constructor time
+    virtual void init();
+
+    /**
+     * Handle a ToRadio protobuf
+     */
+    virtual void handleToRadio(const uint8_t *buf, size_t len);
+
+    /**
+     * Get the next packet we want to send to the phone
+     *
+     * We assume buf is at least FromRadio_size bytes long.
+     * Returns number of bytes in the FromRadio packet (or 0 if no packet available)
+     */
+    size_t getFromRadio(uint8_t *buf);
+
+    /**
+     * Return true if we have data available to send to the phone
+     */
+    bool available();
+
+    //
+    // The following routines are only public for now - until the rev1 bluetooth API is removed
+    //
+
+    void handleSetOwner(const User &o);
+    void handleSetRadio(const RadioConfig &r);
+
+  protected:
+    /// Our fromradio packet while it is being assembled
+    FromRadio fromRadioScratch;
+
+    /**
+     * Subclasses can use this as a hook to provide custom notifications for their transport (i.e. bluetooth notifies)
+     */
+    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
+     */
+    void handleToRadioPacket(MeshPacket *p);
+
+    /// If the mesh service tells us fromNum has changed, tell the phone
+    virtual int onNotify(uint32_t newValue);
+};

src/mesh/RF95Interface.cpp

@@ -0,0 +1,126 @@
+#include "RF95Interface.h"
+#include "MeshRadio.h" // kinda yucky, but we need to know which region we are in
+#include "RadioLibRF95.h"
+#include <configuration.h>
+
+#define MAX_POWER 17
+// if we use 20 we are limited to 1% duty cycle or hw might overheat.  For continuous operation set a limit of 17
+
+RF95Interface::RF95Interface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, SPIClass &spi)
+    : RadioLibInterface(cs, irq, rst, 0, spi)
+{
+    // FIXME - we assume devices never get destroyed
+}
+
+/// Initialise the Driver transport hardware and software.
+/// Make sure the Driver is properly configured before calling init().
+/// \return true if initialisation succeeded.
+bool RF95Interface::init()
+{
+    RadioLibInterface::init();
+
+    applyModemConfig();
+    if (power > MAX_POWER) // This chip has lower power limits than some
+        power = MAX_POWER;
+
+    iface = lora = new RadioLibRF95(&module);
+    int res = lora->begin(freq, bw, sf, cr, syncWord, power, currentLimit, preambleLength);
+    DEBUG_MSG("LORA init result %d\n", res);
+
+    if (res == ERR_NONE)
+        res = lora->setCRC(SX126X_LORA_CRC_ON);
+
+    if (res == ERR_NONE)
+        startReceive(); // start receiving
+
+    return res == ERR_NONE;
+}
+
+void INTERRUPT_ATTR RF95Interface::disableInterrupt()
+{
+    lora->clearDio0Action();
+}
+
+bool RF95Interface::reconfigure()
+{
+    applyModemConfig();
+
+    // set mode to standby
+    setStandby();
+
+    // configure publicly accessible settings
+    int err = lora->setSpreadingFactor(sf);
+    assert(err == ERR_NONE);
+
+    err = lora->setBandwidth(bw);
+    assert(err == ERR_NONE);
+
+    err = lora->setCodingRate(cr);
+    assert(err == ERR_NONE);
+
+    err = lora->setSyncWord(syncWord);
+    assert(err == ERR_NONE);
+
+    err = lora->setCurrentLimit(currentLimit);
+    assert(err == ERR_NONE);
+
+    err = lora->setPreambleLength(preambleLength);
+    assert(err == ERR_NONE);
+
+    err = lora->setFrequency(freq);
+    assert(err == ERR_NONE);
+
+    if (power > MAX_POWER) // This chip has lower power limits than some
+        power = MAX_POWER;
+    err = lora->setOutputPower(power);
+    assert(err == ERR_NONE);
+
+    startReceive(); // restart receiving
+
+    return ERR_NONE;
+}
+
+/**
+ * Add SNR data to received messages
+ */
+void RF95Interface::addReceiveMetadata(MeshPacket *mp)
+{
+    mp->rx_snr = lora->getSNR();
+}
+
+void RF95Interface::setStandby()
+{
+    int err = lora->standby();
+    assert(err == ERR_NONE);
+
+    isReceiving = false; // If we were receiving, not any more
+    disableInterrupt();
+    completeSending(); // If we were sending, not anymore
+}
+
+void RF95Interface::startReceive()
+{
+    setStandby();
+    int err = lora->startReceive();
+    assert(err == ERR_NONE);
+
+    isReceiving = true;
+
+    // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register bits
+    enableInterrupt(isrRxLevel0);
+}
+
+/** Could we send right now (i.e. either not actively receving or transmitting)? */
+bool RF95Interface::isActivelyReceiving()
+{
+    return lora->isReceiving();
+}
+
+bool RF95Interface::sleep()
+{
+    // put chipset into sleep mode
+    disableInterrupt();
+    lora->sleep();
+
+    return true;
+}

src/mesh/RF95Interface.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "MeshRadio.h" // kinda yucky, but we need to know which region we are in
+#include "RadioLibInterface.h"
+#include "RadioLibRF95.h"
+
+/**
+ * Our new not radiohead adapter for RF95 style radios
+ */
+class RF95Interface : public RadioLibInterface
+{
+    RadioLibRF95 *lora; // Either a RFM95 or RFM96 depending on what was stuffed on this board
+
+  public:
+    RF95Interface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, SPIClass &spi);
+
+    /// Initialise the Driver transport hardware and software.
+    /// Make sure the Driver is properly configured before calling init().
+    /// \return true if initialisation succeeded.
+    virtual bool init();
+
+    /// Apply any radio provisioning changes
+    /// Make sure the Driver is properly configured before calling init().
+    /// \return true if initialisation succeeded.
+    virtual bool reconfigure();
+
+    /// Prepare hardware for sleep.  Call this _only_ for deep sleep, not needed for light sleep.
+    virtual bool sleep();
+
+  protected:
+    /**
+     * Glue functions called from ISR land
+     */
+    virtual void disableInterrupt();
+
+    /**
+     * Enable a particular ISR callback glue function
+     */
+    virtual void enableInterrupt(void (*callback)()) { lora->setDio0Action(callback); }
+
+    /** are we actively receiving a packet (only called during receiving state) */
+    virtual bool isActivelyReceiving();
+
+    /**
+     * Start waiting to receive a message
+     */
+    virtual void startReceive();
+
+    /**
+     * Add SNR data to received messages
+     */
+    virtual void addReceiveMetadata(MeshPacket *mp);
+
+    virtual void setStandby();
+};

src/mesh/RadioInterface.cpp

@@ -0,0 +1,68 @@
+
+#include "RadioInterface.h"
+#include "NodeDB.h"
+#include "assert.h"
+#include "configuration.h"
+#include <assert.h>
+#include <pb_decode.h>
+#include <pb_encode.h>
+
+// 1kb was too small
+#define RADIO_STACK_SIZE 4096
+
+RadioInterface::RadioInterface() : txQueue(MAX_TX_QUEUE)
+{
+    assert(sizeof(PacketHeader) == 4); // make sure the compiler did what we expected
+}
+
+bool RadioInterface::init()
+{
+    // we want this thread to run at very high priority, because it is effectively running as a user space ISR 
+    start("radio", RADIO_STACK_SIZE, configMAX_PRIORITIES - 1); // Start our worker thread
+
+    return true;
+}
+
+ErrorCode SimRadio::send(MeshPacket *p)
+{
+    DEBUG_MSG("SimRadio.send\n");
+    packetPool.release(p);
+    return ERRNO_OK;
+}
+
+void RadioInterface::deliverToReceiver(MeshPacket *p)
+{
+    assert(rxDest);
+    assert(rxDest->enqueue(p, 0)); // NOWAIT - fixme, if queue is full, delete older messages
+}
+
+/***
+ * given a packet set sendingPacket and decode the protobufs into radiobuf.  Returns # of payload bytes to send
+ */
+size_t RadioInterface::beginSending(MeshPacket *p)
+{
+    assert(!sendingPacket);
+
+    // DEBUG_MSG("sending queued packet on mesh (txGood=%d,rxGood=%d,rxBad=%d)\n", rf95.txGood(), rf95.rxGood(), rf95.rxBad());
+    assert(p->has_payload);
+
+    lastTxStart = millis();
+
+    PacketHeader *h = (PacketHeader *)radiobuf;
+
+    h->from = p->from;
+    h->to = p->to;
+    h->flags = 0;
+    h->id = p->id;
+
+    // if the sender nodenum is zero, that means uninitialized
+    assert(h->from);
+
+    size_t numbytes = pb_encode_to_bytes(radiobuf + sizeof(PacketHeader), sizeof(radiobuf), SubPacket_fields, &p->payload) +
+                      sizeof(PacketHeader);
+
+    assert(numbytes <= MAX_RHPACKETLEN);
+
+    sendingPacket = p;
+    return numbytes;
+}

src/mesh/RadioInterface.h

@@ -0,0 +1,120 @@
+#pragma once
+
+#include "MemoryPool.h"
+#include "MeshTypes.h"
+#include "PointerQueue.h"
+#include "WorkerThread.h"
+#include "mesh.pb.h"
+
+#define MAX_TX_QUEUE 16 // max number of packets which can be waiting for transmission
+
+#define MAX_RHPACKETLEN 256
+
+/**
+ * This structure has to exactly match the wire layout when sent over the radio link.  Used to keep compatibility
+ * wtih the old radiohead implementation.
+ */
+typedef struct {
+    uint8_t to, from, id, flags;
+} PacketHeader;
+
+typedef enum {
+    Bw125Cr45Sf128 = 0, ///< Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on. Default medium range
+    Bw500Cr45Sf128,     ///< Bw = 500 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on. Fast+short range
+    Bw31_25Cr48Sf512,   ///< Bw = 31.25 kHz, Cr = 4/8, Sf = 512chips/symbol, CRC on. Slow+long range
+    Bw125Cr48Sf4096,    ///< Bw = 125 kHz, Cr = 4/8, Sf = 4096chips/symbol, CRC on. Slow+long range
+} ModemConfigChoice;
+
+/**
+ * Basic operations all radio chipsets must implement.
+ *
+ * This defines the SOLE API for talking to radios (because soon we will have alternate radio implementations)
+ */
+class RadioInterface : protected NotifiedWorkerThread
+{
+    friend class MeshRadio; // for debugging we let that class touch pool
+    PointerQueue<MeshPacket> *rxDest = NULL;
+
+  protected:
+    MeshPacket *sendingPacket = NULL; // The packet we are currently sending
+    PointerQueue<MeshPacket> txQueue;
+    uint32_t lastTxStart = 0L;
+
+    /**
+     * A temporary buffer used for sending/receving packets, sized to hold the biggest buffer we might need
+     * */
+    uint8_t radiobuf[MAX_RHPACKETLEN];
+
+    /**
+     * Enqueue a received packet for the registered receiver
+     */
+    void deliverToReceiver(MeshPacket *p);
+
+  public:
+    float freq = 915.0; // FIXME, init all these params from user setings
+    int8_t power = 17;
+    ModemConfigChoice modemConfig;
+
+    /** 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();
+
+    /**
+     * 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)
+     *
+     * This method must be used before putting the CPU into deep or light sleep.
+     */
+    virtual bool canSleep() { return true; }
+
+    /// Prepare hardware for sleep.  Call this _only_ for deep sleep, not needed for light sleep.
+    virtual bool sleep() { return true; }
+
+    /**
+     * Send a packet (possibly by enquing in a private fifo).  This routine will
+     * later free() the packet to pool.  This routine is not allowed to stall.
+     * If the txmit queue is full it might return an error
+     */
+    virtual ErrorCode send(MeshPacket *p) = 0;
+
+    // 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();
+
+    /// Apply any radio provisioning changes
+    /// Make sure the Driver is properly configured before calling init().
+    /// \return true if initialisation succeeded.
+    virtual bool reconfigure() = 0;
+
+  protected:
+    /***
+     * given a packet set sendingPacket and decode the protobufs into radiobuf.  Returns # of bytes to send (including the
+     * PacketHeader & payload).
+     *
+     * Used as the first step of
+     */
+    size_t beginSending(MeshPacket *p);
+
+    virtual void loop() {} // Idle processing
+};
+
+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; }
+};

src/mesh/RadioLibInterface.cpp

@@ -0,0 +1,326 @@
+#include "RadioLibInterface.h"
+#include "MeshTypes.h"
+#include "OSTimer.h"
+#include "mesh-pb-constants.h"
+#include <NodeDB.h> // FIXME, this class shouldn't need to look into nodedb
+#include <configuration.h>
+#include <pb_decode.h>
+#include <pb_encode.h>
+
+// FIXME, we default to 4MHz SPI, SPI mode 0, check if the datasheet says it can really do that
+static SPISettings spiSettings(4000000, MSBFIRST, SPI_MODE0);
+
+RadioLibInterface::RadioLibInterface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy,
+                                     SPIClass &spi, PhysicalLayer *_iface)
+    : module(cs, irq, rst, busy, spi, spiSettings), iface(_iface)
+{
+    assert(!instance); // We assume only one for now
+    instance = this;
+}
+
+#ifndef NO_ESP32
+// ESP32 doesn't use that flag
+#define YIELD_FROM_ISR(x) portYIELD_FROM_ISR()
+#else
+#define YIELD_FROM_ISR(x) portYIELD_FROM_ISR(x)
+#endif
+
+void INTERRUPT_ATTR RadioLibInterface::isrLevel0Common(PendingISR cause)
+{
+    instance->disableInterrupt();
+
+    instance->pending = cause;
+    BaseType_t xHigherPriorityTaskWoken;
+    instance->notifyFromISR(&xHigherPriorityTaskWoken, cause, eSetValueWithOverwrite);
+
+    /* Force a context switch if xHigherPriorityTaskWoken is now set to pdTRUE.
+    The macro used to do this is dependent on the port and may be called
+    portEND_SWITCHING_ISR. */
+    YIELD_FROM_ISR(xHigherPriorityTaskWoken);
+}
+
+void INTERRUPT_ATTR RadioLibInterface::isrRxLevel0()
+{
+    isrLevel0Common(ISR_RX);
+}
+
+void INTERRUPT_ATTR RadioLibInterface::isrTxLevel0()
+{
+    isrLevel0Common(ISR_TX);
+}
+
+/** Our ISR code currently needs this to find our active instance
+ */
+RadioLibInterface *RadioLibInterface::instance;
+
+/**
+ * Convert our modemConfig enum into wf, sf, etc...
+ */
+void RadioLibInterface::applyModemConfig()
+{
+    switch (modemConfig) {
+    case Bw125Cr45Sf128: ///< Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on. Default medium range
+        bw = 125;
+        cr = 5;
+        sf = 7;
+        break;
+    case Bw500Cr45Sf128: ///< Bw = 500 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on. Fast+short range
+        bw = 500;
+        cr = 5;
+        sf = 7;
+        break;
+    case Bw31_25Cr48Sf512: ///< Bw = 31.25 kHz, Cr = 4/8, Sf = 512chips/symbol, CRC on. Slow+long range
+        bw = 31.25;
+        cr = 8;
+        sf = 9;
+        break;
+    case Bw125Cr48Sf4096:
+        bw = 125;
+        cr = 8;
+        sf = 12;
+        break;
+    default:
+        assert(0); // Unknown enum
+    }
+}
+
+/** Could we send right now (i.e. either not actively receving or transmitting)? */
+bool RadioLibInterface::canSendImmediately()
+{
+    // We wait _if_ we are partially though receiving a packet (rather than just merely waiting for one).
+    // To do otherwise would be doubly bad because not only would we drop the packet that was on the way in,
+    // we almost certainly guarantee no one outside will like the packet we are sending.
+    bool busyTx = sendingPacket != NULL;
+    bool busyRx = isReceiving && isActivelyReceiving();
+
+    if (busyTx || busyRx) {
+        if (busyTx)
+            DEBUG_MSG("Can not send yet, busyTx\n");
+        if (busyRx)
+            DEBUG_MSG("Can not send yet, busyRx\n");
+        return false;
+    } else
+        return true;
+}
+
+/// Send a packet (possibly by enquing in a private fifo).  This routine will
+/// later free() the packet to pool.  This routine is not allowed to stall because it is called from
+/// bluetooth comms code.  If the txmit queue is empty it might return an error
+ErrorCode RadioLibInterface::send(MeshPacket *p)
+{
+    DEBUG_MSG("enqueuing for send on mesh fr=0x%x,to=0x%x,id=%d (txGood=%d,rxGood=%d,rxBad=%d)\n", p->from, p->to, p->id, txGood,
+              rxGood, rxBad);
+    ErrorCode res = txQueue.enqueue(p, 0) ? ERRNO_OK : ERRNO_UNKNOWN;
+
+    if (res != ERRNO_OK) { // we weren't able to queue it, so we must drop it to prevent leaks
+        packetPool.release(p);
+        return res;
+    }
+
+    // We want all sending/receiving to be done by our daemon thread, We use a delay here because this packet might have been sent
+    // in response to a packet we just received.  So we want to make sure the other side has had a chance to reconfigure its radio
+    startTransmitTimer(true);
+
+    return res;
+}
+
+bool RadioLibInterface::canSleep()
+{
+    bool res = txQueue.isEmpty();
+    if (!res) // only print debug messages if we are vetoing sleep
+        DEBUG_MSG("radio wait to sleep, txEmpty=%d\n", txQueue.isEmpty());
+
+    return res;
+}
+
+/** At the low end we want to pick a delay large enough that anyone who just completed sending (some other node)
+ * has had enough time to switch their radio back into receive mode.
+ */
+#define MIN_TX_WAIT_MSEC 100
+
+/**
+ * At the high end, this value is used to spread node attempts across time so when they are replying to a packet
+ * they don't both check that the airwaves are clear at the same moment.  As long as they are off by some amount
+ * one of the two will be first to start transmitting and the other will see that.  I bet 500ms is more than enough
+ * to guarantee this.
+ */
+#define MAX_TX_WAIT_MSEC 2000 // stress test would still fail occasionally with 1000
+
+/** radio helper thread callback.
+
+We never immediately transmit after any operation (either rx or tx).  Instead we should start receiving and
+wait a random delay of 50 to 200 ms to make sure we are not stomping on someone else.  The 50ms delay at the beginning ensures all
+possible listeners have had time to finish processing the previous packet and now have their radio in RX state.  The up to 200ms
+random delay gives a chance for all possible senders to have high odds of detecting that someone else started transmitting first
+and then they will wait until that packet finishes.
+
+NOTE: the large flood rebroadcast delay might still be needed even with this approach.  Because we might not be able to hear other
+transmitters that we are potentially stomping on.  Requires further thought.
+
+FIXME, the MIN_TX_WAIT_MSEC and MAX_TX_WAIT_MSEC values should be tuned via logic analyzer later.
+*/
+void RadioLibInterface::loop()
+{
+    pending = ISR_NONE;
+
+    switch (notification) {
+    case ISR_TX:
+        handleTransmitInterrupt();
+        startReceive();
+        startTransmitTimer();
+        break;
+    case ISR_RX:
+        handleReceiveInterrupt();
+        startReceive();
+        startTransmitTimer();
+        break;
+    case TRANSMIT_DELAY_COMPLETED:
+        // If we are not currently in receive mode, then restart the timer and try again later (this can happen if the main thread
+        // has placed the unit into standby)  FIXME, how will this work if the chipset is in sleep mode?
+        if (!txQueue.isEmpty()) {
+            if (!canSendImmediately()) {
+                startTransmitTimer(); // try again in a little while
+            } else {
+                // Send any outgoing packets we have ready
+                MeshPacket *txp = txQueue.dequeuePtr(0);
+                assert(txp);
+                startSend(txp);
+            }
+        }
+        break;
+    default:
+        assert(0); // We expected to receive a valid notification from the ISR
+    }
+}
+
+#ifndef NO_ESP32
+#define USE_HW_TIMER
+#endif
+
+void IRAM_ATTR RadioLibInterface::timerCallback(void *p1, uint32_t p2)
+{
+    RadioLibInterface *t = (RadioLibInterface *)p1;
+
+    t->timerRunning = false;
+
+    // We use without overwrite, so that if there is already an interrupt pending to be handled, that gets handle properly (the
+    // ISR handler will restart our timer)
+#ifndef USE_HW_TIMER
+    t->notify(TRANSMIT_DELAY_COMPLETED, eSetValueWithoutOverwrite);
+#else
+    BaseType_t xHigherPriorityTaskWoken;
+    instance->notifyFromISR(&xHigherPriorityTaskWoken, TRANSMIT_DELAY_COMPLETED, eSetValueWithoutOverwrite);
+
+    /* Force a context switch if xHigherPriorityTaskWoken is now set to pdTRUE.
+    The macro used to do this is dependent on the port and may be called
+    portEND_SWITCHING_ISR. */
+    YIELD_FROM_ISR(xHigherPriorityTaskWoken);
+#endif
+}
+
+void RadioLibInterface::startTransmitTimer(bool withDelay)
+{
+    // If we have work to do and the timer wasn't already scheduled, schedule it now
+    if (!timerRunning && !txQueue.isEmpty()) {
+        timerRunning = true;
+        uint32_t delay =
+            !withDelay ? 0 : random(MIN_TX_WAIT_MSEC, MAX_TX_WAIT_MSEC); // See documentation for loop() wrt these values
+                                                                         // DEBUG_MSG("xmit timer %d\n", delay);
+#ifdef USE_HW_TIMER
+        bool okay = scheduleHWCallback(timerCallback, this, 0, delay);
+#else
+        bool okay = scheduleOSCallback(timerCallback, this, 0, delay);
+#endif
+        assert(okay);
+    }
+}
+
+void RadioLibInterface::handleTransmitInterrupt()
+{
+    // DEBUG_MSG("handling lora TX interrupt\n");
+    assert(sendingPacket); // Were we sending? - FIXME, this was null coming out of light sleep due to RF95 ISR!
+
+    completeSending();
+}
+
+void RadioLibInterface::completeSending()
+{
+    if (sendingPacket) {
+        txGood++;
+        DEBUG_MSG("Completed sending to=0x%x, id=%u\n", sendingPacket->to, sendingPacket->id);
+
+        // We are done sending that packet, release it
+        packetPool.release(sendingPacket);
+        sendingPacket = NULL;
+        // DEBUG_MSG("Done with send\n");
+    }
+}
+
+void RadioLibInterface::handleReceiveInterrupt()
+{
+    assert(isReceiving);
+    isReceiving = false;
+
+    // read the number of actually received bytes
+    size_t length = iface->getPacketLength();
+
+    int state = iface->readData(radiobuf, length);
+    if (state != ERR_NONE) {
+        DEBUG_MSG("ignoring received packet due to error=%d\n", state);
+        rxBad++;
+    } else {
+        // Skip the 4 headers that are at the beginning of the rxBuf
+        int32_t payloadLen = length - sizeof(PacketHeader);
+        const uint8_t *payload = radiobuf + sizeof(PacketHeader);
+
+        // check for short packets
+        if (payloadLen < 0) {
+            DEBUG_MSG("ignoring received packet too short\n");
+            rxBad++;
+        } else {
+            const PacketHeader *h = (PacketHeader *)radiobuf;
+            uint8_t ourAddr = nodeDB.getNodeNum();
+
+            rxGood++;
+            if (h->to != 255 && h->to != ourAddr) {
+                DEBUG_MSG("ignoring packet not sent to us\n");
+            } else {
+                MeshPacket *mp = packetPool.allocZeroed();
+
+                SubPacket *p = &mp->payload;
+
+                mp->from = h->from;
+                mp->to = h->to;
+                mp->id = h->id;
+                addReceiveMetadata(mp);
+
+                if (!pb_decode_from_bytes(payload, payloadLen, SubPacket_fields, p)) {
+                    DEBUG_MSG("Invalid protobufs in received mesh packet, discarding.\n");
+                    packetPool.release(mp);
+                    // rxBad++; not really a hw error
+                } else {
+                    // parsing was successful, queue for our recipient
+                    mp->has_payload = true;
+                    DEBUG_MSG("Lora RX interrupt from=0x%x, id=%u\n", mp->from, mp->id);
+
+                    deliverToReceiver(mp);
+                }
+            }
+        }
+    }
+}
+
+/** start an immediate transmit */
+void RadioLibInterface::startSend(MeshPacket *txp)
+{
+    DEBUG_MSG("Starting low level send from=0x%x, id=%u!\n", txp->from, txp->id);
+    setStandby(); // Cancel any already in process receives
+
+    size_t numbytes = beginSending(txp);
+
+    int res = iface->startTransmit(radiobuf, numbytes);
+    assert(res == ERR_NONE);
+
+    // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register bits
+    enableInterrupt(isrTxLevel0);
+}

src/mesh/RadioLibInterface.h

@@ -0,0 +1,133 @@
+#pragma once
+
+#include "RadioInterface.h"
+
+#include <RadioLib.h>
+
+// ESP32 has special rules about ISR code
+#ifdef ARDUINO_ARCH_ESP32
+#define INTERRUPT_ATTR IRAM_ATTR
+#else
+#define INTERRUPT_ATTR
+#endif
+
+class RadioLibInterface : public RadioInterface
+{
+    /// Used as our notification from the ISR
+    enum PendingISR { ISR_NONE = 0, ISR_RX, ISR_TX, TRANSMIT_DELAY_COMPLETED };
+
+    volatile PendingISR pending = ISR_NONE;
+    volatile bool timerRunning = false;
+
+    /** Our ISR code currently needs this to find our active instance
+     */
+    static RadioLibInterface *instance;
+
+    /**
+     * Raw ISR handler that just calls our polymorphic method
+     */
+    static void isrTxLevel0(), isrLevel0Common(PendingISR code);
+
+    /**
+     * Debugging counts
+     */
+    uint32_t rxBad = 0, rxGood = 0, txGood = 0;
+
+  protected:
+    float bw = 125;
+    uint8_t sf = 9;
+    uint8_t cr = 7;
+
+    /**
+     * FIXME, use a meshtastic sync word, but hashed with the Channel name.  Currently picking the same default
+     * the RF95 used (0x14). Note: do not use 0x34 - that is reserved for lorawan
+     */
+    uint8_t syncWord = SX126X_SYNC_WORD_PRIVATE;
+
+    float currentLimit = 100;     // FIXME
+    uint16_t preambleLength = 32; // 8 is default, but FIXME use longer to increase the amount of sleep time when receiving
+
+    Module module; // The HW interface to the radio
+
+    /**
+     * provides lowest common denominator RadioLib API
+     */
+    PhysicalLayer *iface;
+
+    /// are _trying_ to receive a packet currently (note - we might just be waiting for one)
+    bool isReceiving;
+
+    /**
+     * Glue functions called from ISR land
+     */
+    virtual void disableInterrupt() = 0;
+
+    /**
+     * Enable a particular ISR callback glue function
+     */
+    virtual void enableInterrupt(void (*)()) = 0;
+
+  public:
+    RadioLibInterface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy, SPIClass &spi,
+                      PhysicalLayer *iface = NULL);
+
+    virtual ErrorCode send(MeshPacket *p);
+
+    /**
+     * Return true if we think the board can go to sleep (i.e. our tx queue is empty, we are not sending or receiving)
+     *
+     * This method must be used before putting the CPU into deep or light sleep.
+     */
+    virtual bool canSleep();
+
+  private:
+    /** start an immediate transmit */
+    void startSend(MeshPacket *txp);
+
+    /** if we have something waiting to send, start a short random timer so we can come check for collision before actually doing
+     * the transmit
+     *
+     * If the timer was already running, we just wait for that one to occur.
+     * */
+    void startTransmitTimer(bool withDelay = true);
+
+    void handleTransmitInterrupt();
+    void handleReceiveInterrupt();
+
+    static void timerCallback(void *p1, uint32_t p2);
+
+  protected:
+    /**
+     * Convert our modemConfig enum into wf, sf, etc...
+     */
+    void applyModemConfig();
+
+    /** Could we send right now (i.e. either not actively receiving or transmitting)? */
+    virtual bool canSendImmediately();
+
+    /** are we actively receiving a packet (only called during receiving state) */
+    virtual bool isActivelyReceiving() = 0;
+
+    /**
+     * Start waiting to receive a message
+     */
+    virtual void startReceive() = 0;
+
+    /**
+     * Raw ISR handler that just calls our polymorphic method
+     */
+    static void isrRxLevel0();
+
+    /**
+     * If a send was in progress finish it and return the buffer to the pool */
+    void completeSending();
+
+    /**
+     * Add SNR data to received messages
+     */
+    virtual void addReceiveMetadata(MeshPacket *mp) = 0;
+
+    virtual void loop(); // Idle processing
+
+    virtual void setStandby() = 0;
+};

src/mesh/RadioLibRF95.cpp

@@ -0,0 +1,68 @@
+#include "RadioLibRF95.h"
+
+#define RF95_CHIP_VERSION 0x12
+#define RF95_ALT_VERSION 0x11 // Supposedly some versions of the chip have id 0x11
+
+RadioLibRF95::RadioLibRF95(Module *mod) : SX1278(mod) {}
+
+int16_t RadioLibRF95::begin(float freq, float bw, uint8_t sf, uint8_t cr, uint8_t syncWord, int8_t power, uint8_t currentLimit,
+                            uint16_t preambleLength, uint8_t gain)
+{
+    // execute common part
+    int16_t state = SX127x::begin(RF95_CHIP_VERSION, syncWord, currentLimit, preambleLength);
+    if (state != ERR_NONE)
+        state = SX127x::begin(RF95_ALT_VERSION, syncWord, currentLimit, preambleLength);
+    RADIOLIB_ASSERT(state);
+
+    // configure settings not accessible by API
+    state = config();
+    RADIOLIB_ASSERT(state);
+
+    // configure publicly accessible settings
+    state = setFrequency(freq);
+    RADIOLIB_ASSERT(state);
+
+    state = setBandwidth(bw);
+    RADIOLIB_ASSERT(state);
+
+    state = setSpreadingFactor(sf);
+    RADIOLIB_ASSERT(state);
+
+    state = setCodingRate(cr);
+    RADIOLIB_ASSERT(state);
+
+    state = setOutputPower(power);
+    RADIOLIB_ASSERT(state);
+
+    state = setGain(gain);
+
+    return (state);
+}
+
+int16_t RadioLibRF95::setFrequency(float freq)
+{
+    // RADIOLIB_CHECK_RANGE(freq, 862.0, 1020.0, ERR_INVALID_FREQUENCY);
+
+    // set frequency
+    return (SX127x::setFrequencyRaw(freq));
+}
+
+#define RH_RF95_MODEM_STATUS_CLEAR 0x10
+#define RH_RF95_MODEM_STATUS_HEADER_INFO_VALID 0x08
+#define RH_RF95_MODEM_STATUS_RX_ONGOING 0x04
+#define RH_RF95_MODEM_STATUS_SIGNAL_SYNCHRONIZED 0x02
+#define RH_RF95_MODEM_STATUS_SIGNAL_DETECTED 0x01
+
+bool RadioLibRF95::isReceiving()
+{
+    // 0x0b == Look for header info valid, signal synchronized or signal detected
+    uint8_t reg = readReg(SX127X_REG_MODEM_STAT);
+    // Serial.printf("reg %x\n", reg);
+    return (reg & (RH_RF95_MODEM_STATUS_SIGNAL_DETECTED | RH_RF95_MODEM_STATUS_SIGNAL_SYNCHRONIZED |
+                   RH_RF95_MODEM_STATUS_HEADER_INFO_VALID)) != 0;
+}
+
+uint8_t RadioLibRF95::readReg(uint8_t addr)
+{
+    return _mod->SPIreadRegister(addr);
+}

src/mesh/RadioLibRF95.h

@@ -0,0 +1,73 @@
+#pragma once
+#include <RadioLib.h>
+
+/*!
+  \class RFM95
+
+  \brief Derived class for %RFM95 modules. Overrides some methods from SX1278 due to different parameter ranges.
+*/
+class RadioLibRF95: public SX1278 {
+  public:
+
+    // constructor
+
+    /*!
+      \brief Default constructor. Called from Arduino sketch when creating new LoRa instance.
+
+      \param mod Instance of Module that will be used to communicate with the %LoRa chip.
+    */
+    RadioLibRF95(Module* mod);
+
+    // basic methods
+
+    /*!
+      \brief %LoRa modem initialization method. Must be called at least once from Arduino sketch to initialize the module.
+
+      \param freq Carrier frequency in MHz. Allowed values range from 868.0 MHz to 915.0 MHz.
+
+      \param bw %LoRa link bandwidth in kHz. Allowed values are 10.4, 15.6, 20.8, 31.25, 41.7, 62.5, 125, 250 and 500 kHz.
+
+      \param sf %LoRa link spreading factor. Allowed values range from 6 to 12.
+
+      \param cr %LoRa link coding rate denominator. Allowed values range from 5 to 8.
+
+      \param syncWord %LoRa sync word. Can be used to distinguish different networks. Note that value 0x34 is reserved for LoRaWAN networks.
+
+      \param power Transmission output power in dBm. Allowed values range from 2 to 17 dBm.
+
+      \param currentLimit Trim value for OCP (over current protection) in mA. Can be set to multiplies of 5 in range 45 to 120 mA and to multiples of 10 in range 120 to 240 mA.
+      Set to 0 to disable OCP (not recommended).
+
+      \param preambleLength Length of %LoRa transmission preamble in symbols. The actual preamble length is 4.25 symbols longer than the set number.
+      Allowed values range from 6 to 65535.
+
+      \param gain Gain of receiver LNA (low-noise amplifier). Can be set to any integer in range 1 to 6 where 1 is the highest gain.
+      Set to 0 to enable automatic gain control (recommended).
+
+      \returns \ref status_codes
+    */
+    int16_t begin(float freq = 915.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, uint8_t syncWord = SX127X_SYNC_WORD, int8_t power = 17, uint8_t currentLimit = 100, uint16_t preambleLength = 8, uint8_t gain = 0);
+
+    // configuration methods
+
+    /*!
+      \brief Sets carrier frequency. Allowed values range from 868.0 MHz to 915.0 MHz.
+
+      \param freq Carrier frequency to be set in MHz.
+
+      \returns \ref status_codes
+    */
+    int16_t setFrequency(float freq);
+
+    // Return true if we are actively receiving a message currently
+    bool isReceiving();
+
+    /// For debugging
+    uint8_t readReg(uint8_t addr); 
+
+#ifndef RADIOLIB_GODMODE
+  private:
+#endif
+
+};
+

src/mesh/Router.cpp

@@ -35,9 +35,6 @@ Router::Router() : fromRadioQueue(MAX_RX_FROMRADIO) {}
  */
 void Router::loop()
 {
-    if (iface)
-        iface->loop();
-
     MeshPacket *mp;
     while ((mp = fromRadioQueue.dequeuePtr(0)) != NULL) {
         handleReceived(mp);
@@ -47,13 +44,18 @@ void Router::loop()
 /**
  * Send a packet on a suitable interface.  This routine will
  * later free() the packet to pool.  This routine is not allowed to stall.
- * If the txmit queue is full it might return an error
+ * If the txmit queue is full it might return an error.  
  */
 ErrorCode Router::send(MeshPacket *p)
 {
-    assert(iface);
-    DEBUG_MSG("Sending packet via interface fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
-    return iface->send(p);
+    if (iface) {
+        // DEBUG_MSG("Sending packet via interface fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
+        return iface->send(p);
+    } else {
+        DEBUG_MSG("Dropping packet - no interfaces - fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
+        packetPool.release(p);
+        return ERRNO_NO_INTERFACES;
+    }
 }
 
 #include "GPS.h"
@@ -66,7 +68,7 @@ void Router::handleReceived(MeshPacket *p)
 {
     // FIXME, this class shouldn't EVER need to know about the GPS, move getValidTime() into a non gps dependent function
     // Also, we should set the time from the ISR and it should have msec level resolution
-    p->rx_time = gps.getValidTime(); // store the arrival timestamp for the phone
+    p->rx_time = getValidTime(); // store the arrival timestamp for the phone
 
     DEBUG_MSG("Notifying observers of received packet fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
     notifyPacketReceived.notifyObservers(p);

src/mesh/Router.h

@@ -6,7 +6,6 @@
 #include "PointerQueue.h"
 #include "RadioInterface.h"
 #include "mesh.pb.h"
-#include <RH_RF95.h>
 
 /**
  * A mesh aware router that supports multiple interfaces.

src/mesh/SX1262Interface.cpp

@@ -0,0 +1,117 @@
+#include "SX1262Interface.h"
+#include <configuration.h>
+
+SX1262Interface::SX1262Interface(RADIOLIB_PIN_TYPE cs, RADIOLIB_PIN_TYPE irq, RADIOLIB_PIN_TYPE rst, RADIOLIB_PIN_TYPE busy,
+                                 SPIClass &spi)
+    : RadioLibInterface(cs, irq, rst, busy, spi, &lora), lora(&module)
+{
+}
+
+/// Initialise the Driver transport hardware and software.
+/// Make sure the Driver is properly configured before calling init().
+/// \return true if initialisation succeeded.
+bool SX1262Interface::init()
+{
+    RadioLibInterface::init();
+
+    float tcxoVoltage = 0;        // None - we use an XTAL
+    bool useRegulatorLDO = false; // Seems to depend on the connection to pin 9/DCC_SW - if an inductor DCDC?
+
+    applyModemConfig();
+    if (power > 22) // This chip has lower power limits than some
+        power = 22;
+    int res = lora.begin(freq, bw, sf, cr, syncWord, power, currentLimit, preambleLength, tcxoVoltage, useRegulatorLDO);
+    DEBUG_MSG("LORA init result %d\n", res);
+
+    if (res == ERR_NONE)
+        res = lora.setCRC(SX126X_LORA_CRC_ON);
+
+    if (res == ERR_NONE)
+        startReceive(); // start receiving
+
+    return res == ERR_NONE;
+}
+
+bool SX1262Interface::reconfigure()
+{
+    applyModemConfig();
+
+    // set mode to standby
+    setStandby();
+
+    // configure publicly accessible settings
+    int err = lora.setSpreadingFactor(sf);
+    assert(err == ERR_NONE);
+
+    err = lora.setBandwidth(bw);
+    assert(err == ERR_NONE);
+
+    err = lora.setCodingRate(cr);
+    assert(err == ERR_NONE);
+
+    err = lora.setSyncWord(syncWord);
+    assert(err == ERR_NONE);
+
+    err = lora.setCurrentLimit(currentLimit);
+    assert(err == ERR_NONE);
+
+    err = lora.setPreambleLength(preambleLength);
+    assert(err == ERR_NONE);
+
+    err = lora.setFrequency(freq);
+    assert(err == ERR_NONE);
+
+    if (power > 22) // This chip has lower power limits than some
+        power = 22;
+    err = lora.setOutputPower(power);
+    assert(err == ERR_NONE);
+
+    startReceive(); // restart receiving
+
+    return ERR_NONE;
+}
+
+void SX1262Interface::setStandby()
+{
+    int err = lora.standby();
+    assert(err == ERR_NONE);
+
+    isReceiving = false; // If we were receiving, not any more
+    disableInterrupt();
+    completeSending(); // If we were sending, not anymore
+}
+
+/**
+ * Add SNR data to received messages
+ */
+void SX1262Interface::addReceiveMetadata(MeshPacket *mp)
+{
+    mp->rx_snr = lora.getSNR();
+}
+
+void SX1262Interface::startReceive()
+{
+    setStandby();
+    int err = lora.startReceive();
+    assert(err == ERR_NONE);
+
+    isReceiving = true;
+
+    // Must be done AFTER, starting transmit, because startTransmit clears (possibly stale) interrupt pending register bits
+    enableInterrupt(isrRxLevel0);
+}
+
+/** Could we send right now (i.e. either not actively receving or transmitting)? */
+bool SX1262Interface::isActivelyReceiving()
+{
+    return lora.getPacketLength() > 0;
+}
+
+bool SX1262Interface::sleep()
+{
+    // put chipset into sleep mode
+    disableInterrupt();
+    lora.sleep();
+
+    return true;
+}

src/mesh/SX1262Interface.h

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

src/mesh/StreamAPI.cpp

@@ -0,0 +1,91 @@
+#include "StreamAPI.h"
+#include "configuration.h"
+
+#define START1 0x94
+#define START2 0xc3
+#define HEADER_LEN 4
+
+void StreamAPI::loop()
+{
+    writeStream();
+    readStream();
+}
+
+/**
+ * Read any rx chars from the link and call handleToRadio
+ */
+void StreamAPI::readStream()
+{
+    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
+
+        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
+            uint16_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 (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
+            }
+        }
+    }
+}
+
+/**
+ * call getFromRadio() and deliver encapsulated packets to the Stream
+ */
+void StreamAPI::writeStream()
+{
+    if (canWrite) {
+        uint32_t len;
+        do {
+            // Send every packet we can
+            len = getFromRadio(txBuf + HEADER_LEN);
+            emitTxBuffer(len);
+        } while (len);
+    }
+}
+
+/**
+ * Send the current txBuffer over our stream
+ */
+void StreamAPI::emitTxBuffer(size_t len)
+{
+    if (len != 0) {
+        txBuf[0] = START1;
+        txBuf[1] = START2;
+        txBuf[2] = (len >> 8) & 0xff;
+        txBuf[3] = len & 0xff;
+
+        stream->write(txBuf, len + HEADER_LEN);
+    }
+}
+
+void StreamAPI::emitRebooted()
+{
+    // In case we send a FromRadio packet
+    memset(&fromRadioScratch, 0, sizeof(fromRadioScratch));
+    fromRadioScratch.which_variant = FromRadio_rebooted_tag;
+    fromRadioScratch.variant.rebooted = true;
+
+    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

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "PhoneAPI.h"
+#include "Stream.h"
+
+// A To/FromRadio packet + our 32 bit header
+#define MAX_STREAM_BUF_SIZE (MAX_TO_FROM_RADIO_SIZE + sizeof(uint32_t))
+
+/**
+ * A version of our 'phone' API that talks over a Stream.  So therefore well suited to use with serial links
+ * or TCP connections.
+ *
+ * ## Wire encoding
+
+When sending protobuf packets over serial or TCP each packet is preceded by uint32 sent in network byte order (big endian).
+The upper 16 bits must be 0x94C3. The lower 16 bits are packet length (this encoding gives room to eventually allow quite large
+packets).
+
+Implementations validate length against the maximum possible size of a BLE packet (our lowest common denominator) of 512 bytes. If
+the length provided is larger than that we assume the packet is corrupted and begin again looking for 0x4403 framing.
+
+The packets flowing towards the device are ToRadio protobufs, the packets flowing from the device are FromRadio protobufs.
+The 0x94C3 marker can be used as framing to (eventually) resync if packets are corrupted over the wire.
+
+Note: the 0x94C3 framing was chosen to prevent confusion with the 7 bit ascii character set. It also doesn't collide with any
+valid utf8 encoding. This makes it a bit easier to start a device outputting regular debug output on its serial port and then only
+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
+{
+    /**
+     * The stream we read/write from
+     */
+    Stream *stream;
+
+    uint8_t rxBuf[MAX_STREAM_BUF_SIZE];
+    size_t rxPtr = 0;
+
+  public:
+    StreamAPI(Stream *_stream) : 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();
+
+  private:
+    /**
+     * Read any rx chars from the link and call handleToRadio
+     */
+    void readStream();
+
+    /**
+     * call getFromRadio() and deliver encapsulated packets to the Stream
+     */
+    void writeStream();
+
+  protected:
+    /**
+     * Send a FromRadio.rebooted = true packet to the phone
+     */
+    void emitRebooted();
+    
+    /**
+     * Send the current txBuffer over our stream
+     */
+    void emitTxBuffer(size_t len);
+
+    /// Are we allowed to write packets to our output stream (subclasses can turn this off - i.e. SerialConsole)
+    bool canWrite = true;
+
+    /// Subclasses can use this scratch buffer if they wish
+    uint8_t txBuf[MAX_STREAM_BUF_SIZE];
+};

src/mesh/mesh.pb.c

@@ -42,6 +42,9 @@ PB_BIND(MyNodeInfo, MyNodeInfo, AUTO)
 PB_BIND(DeviceState, DeviceState, 4)
 
 
+PB_BIND(DebugString, DebugString, 2)
+
+
 PB_BIND(FromRadio, FromRadio, 2)
 
 
@@ -52,11 +55,3 @@ PB_BIND(ToRadio, ToRadio, 2)
 
 
 
-#ifndef PB_CONVERT_DOUBLE_FLOAT
-/* On some platforms (such as AVR), double is really float.
- * To be able to encode/decode double on these platforms, you need.
- * to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line.
- */
-PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
-#endif
-

src/mesh/mesh.pb.h

@@ -19,7 +19,7 @@ typedef enum _Constants {
 } Constants;
 
 typedef enum _Data_Type {
-    Data_Type_SIGNAL_OPAQUE = 0,
+    Data_Type_OPAQUE = 0,
     Data_Type_CLEAR_TEXT = 1,
     Data_Type_CLEAR_READACK = 2
 } Data_Type;
@@ -49,6 +49,10 @@ typedef struct _Data {
     Data_payload_t payload;
 } Data;
 
+typedef struct _DebugString {
+    char message[256];
+} DebugString;
+
 typedef struct _MyNodeInfo {
     int32_t my_node_num;
     bool has_gps;
@@ -62,11 +66,11 @@ typedef struct _MyNodeInfo {
 } MyNodeInfo;
 
 typedef struct _Position {
-    double latitude;
-    double longitude;
     int32_t altitude;
     int32_t battery_level;
     uint32_t time;
+    int32_t latitude_i;
+    int32_t longitude_i;
 } Position;
 
 typedef struct _RadioConfig_UserPreferences {
@@ -98,8 +102,7 @@ typedef struct _NodeInfo {
     User user;
     bool has_position;
     Position position;
-    int32_t snr;
-    int32_t frequency_error;
+    float snr;
 } NodeInfo;
 
 typedef struct _RadioConfig {
@@ -125,8 +128,8 @@ typedef struct _MeshPacket {
     bool has_payload;
     SubPacket payload;
     uint32_t rx_time;
-    int32_t rx_snr;
     uint32_t id;
+    float rx_snr;
 } MeshPacket;
 
 typedef struct _DeviceState {
@@ -150,6 +153,12 @@ typedef struct _FromRadio {
     pb_size_t which_variant;
     union {
         MeshPacket packet;
+        MyNodeInfo my_info;
+        NodeInfo node_info;
+        RadioConfig radio;
+        DebugString debug_string;
+        uint32_t config_complete_id;
+        bool rebooted;
     } variant;
 } FromRadio;
 
@@ -157,6 +166,9 @@ typedef struct _ToRadio {
     pb_size_t which_variant;
     union {
         MeshPacket packet;
+        uint32_t want_config_id;
+        RadioConfig set_radio;
+        User set_owner;
     } variant;
 } ToRadio;
 
@@ -166,7 +178,7 @@ typedef struct _ToRadio {
 #define _Constants_MAX Constants_Unused
 #define _Constants_ARRAYSIZE ((Constants)(Constants_Unused+1))
 
-#define _Data_Type_MIN Data_Type_SIGNAL_OPAQUE
+#define _Data_Type_MIN Data_Type_OPAQUE
 #define _Data_Type_MAX Data_Type_CLEAR_READACK
 #define _Data_Type_ARRAYSIZE ((Data_Type)(Data_Type_CLEAR_READACK+1))
 
@@ -185,9 +197,10 @@ typedef struct _ToRadio {
 #define ChannelSettings_init_default             {0, _ChannelSettings_ModemConfig_MIN, {0}, ""}
 #define RadioConfig_init_default                 {false, RadioConfig_UserPreferences_init_default, false, ChannelSettings_init_default}
 #define RadioConfig_UserPreferences_init_default {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-#define NodeInfo_init_default                    {0, false, User_init_default, false, Position_init_default, 0, 0}
+#define NodeInfo_init_default                    {0, false, User_init_default, false, Position_init_default, 0}
 #define MyNodeInfo_init_default                  {0, 0, 0, "", "", "", 0, 0, 0}
 #define DeviceState_init_default                 {false, RadioConfig_init_default, false, MyNodeInfo_init_default, false, User_init_default, 0, {NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default, NodeInfo_init_default}, 0, {MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default, MeshPacket_init_default}, false, MeshPacket_init_default, 0}
+#define DebugString_init_default                 {""}
 #define FromRadio_init_default                   {0, 0, {MeshPacket_init_default}}
 #define ToRadio_init_default                     {0, {MeshPacket_init_default}}
 #define Position_init_zero                       {0, 0, 0, 0, 0}
@@ -199,9 +212,10 @@ typedef struct _ToRadio {
 #define ChannelSettings_init_zero                {0, _ChannelSettings_ModemConfig_MIN, {0}, ""}
 #define RadioConfig_init_zero                    {false, RadioConfig_UserPreferences_init_zero, false, ChannelSettings_init_zero}
 #define RadioConfig_UserPreferences_init_zero    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
-#define NodeInfo_init_zero                       {0, false, User_init_zero, false, Position_init_zero, 0, 0}
+#define NodeInfo_init_zero                       {0, false, User_init_zero, false, Position_init_zero, 0}
 #define MyNodeInfo_init_zero                     {0, 0, 0, "", "", "", 0, 0, 0}
 #define DeviceState_init_zero                    {false, RadioConfig_init_zero, false, MyNodeInfo_init_zero, false, User_init_zero, 0, {NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero, NodeInfo_init_zero}, 0, {MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero, MeshPacket_init_zero}, false, MeshPacket_init_zero, 0}
+#define DebugString_init_zero                    {""}
 #define FromRadio_init_zero                      {0, 0, {MeshPacket_init_zero}}
 #define ToRadio_init_zero                        {0, {MeshPacket_init_zero}}
 
@@ -213,6 +227,7 @@ typedef struct _ToRadio {
 #define ChannelSettings_name_tag                 5
 #define Data_typ_tag                             1
 #define Data_payload_tag                         2
+#define DebugString_message_tag                  1
 #define MyNodeInfo_my_node_num_tag               1
 #define MyNodeInfo_has_gps_tag                   2
 #define MyNodeInfo_num_channels_tag              3
@@ -222,8 +237,8 @@ typedef struct _ToRadio {
 #define MyNodeInfo_error_code_tag                7
 #define MyNodeInfo_error_address_tag             8
 #define MyNodeInfo_error_count_tag               9
-#define Position_latitude_tag                    1
-#define Position_longitude_tag                   2
+#define Position_latitude_i_tag                  7
+#define Position_longitude_i_tag                 8
 #define Position_altitude_tag                    3
 #define Position_battery_level_tag               4
 #define Position_time_tag                        6
@@ -247,8 +262,7 @@ typedef struct _ToRadio {
 #define NodeInfo_num_tag                         1
 #define NodeInfo_user_tag                        2
 #define NodeInfo_position_tag                    3
-#define NodeInfo_snr_tag                         5
-#define NodeInfo_frequency_error_tag             6
+#define NodeInfo_snr_tag                         7
 #define RadioConfig_preferences_tag              1
 #define RadioConfig_channel_settings_tag         2
 #define SubPacket_position_tag                   1
@@ -259,8 +273,8 @@ typedef struct _ToRadio {
 #define MeshPacket_to_tag                        2
 #define MeshPacket_payload_tag                   3
 #define MeshPacket_rx_time_tag                   4
-#define MeshPacket_rx_snr_tag                    5
 #define MeshPacket_id_tag                        6
+#define MeshPacket_rx_snr_tag                    7
 #define DeviceState_radio_tag                    1
 #define DeviceState_my_node_tag                  2
 #define DeviceState_owner_tag                    3
@@ -269,16 +283,25 @@ typedef struct _ToRadio {
 #define DeviceState_version_tag                  8
 #define DeviceState_rx_text_message_tag          7
 #define FromRadio_packet_tag                     2
+#define FromRadio_my_info_tag                    3
+#define FromRadio_node_info_tag                  4
+#define FromRadio_radio_tag                      6
+#define FromRadio_debug_string_tag               7
+#define FromRadio_config_complete_id_tag         8
+#define FromRadio_rebooted_tag                   9
 #define FromRadio_num_tag                        1
 #define ToRadio_packet_tag                       1
+#define ToRadio_want_config_id_tag               100
+#define ToRadio_set_radio_tag                    101
+#define ToRadio_set_owner_tag                    102
 
 /* Struct field encoding specification for nanopb */
 #define Position_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, DOUBLE,   latitude,          1) \
-X(a, STATIC,   SINGULAR, DOUBLE,   longitude,         2) \
 X(a, STATIC,   SINGULAR, INT32,    altitude,          3) \
 X(a, STATIC,   SINGULAR, INT32,    battery_level,     4) \
-X(a, STATIC,   SINGULAR, UINT32,   time,              6)
+X(a, STATIC,   SINGULAR, UINT32,   time,              6) \
+X(a, STATIC,   SINGULAR, SINT32,   latitude_i,        7) \
+X(a, STATIC,   SINGULAR, SINT32,   longitude_i,       8)
 #define Position_CALLBACK NULL
 #define Position_DEFAULT NULL
 
@@ -317,8 +340,8 @@ X(a, STATIC,   SINGULAR, INT32,    from,              1) \
 X(a, STATIC,   SINGULAR, INT32,    to,                2) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  payload,           3) \
 X(a, STATIC,   SINGULAR, UINT32,   rx_time,           4) \
-X(a, STATIC,   SINGULAR, SINT32,   rx_snr,            5) \
-X(a, STATIC,   SINGULAR, UINT32,   id,                6)
+X(a, STATIC,   SINGULAR, UINT32,   id,                6) \
+X(a, STATIC,   SINGULAR, FLOAT,    rx_snr,            7)
 #define MeshPacket_CALLBACK NULL
 #define MeshPacket_DEFAULT NULL
 #define MeshPacket_payload_MSGTYPE SubPacket
@@ -360,8 +383,7 @@ X(a, STATIC,   SINGULAR, BOOL,     promiscuous_mode, 101)
 X(a, STATIC,   SINGULAR, INT32,    num,               1) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  user,              2) \
 X(a, STATIC,   OPTIONAL, MESSAGE,  position,          3) \
-X(a, STATIC,   SINGULAR, INT32,    snr,               5) \
-X(a, STATIC,   SINGULAR, INT32,    frequency_error,   6)
+X(a, STATIC,   SINGULAR, FLOAT,    snr,               7)
 #define NodeInfo_CALLBACK NULL
 #define NodeInfo_DEFAULT NULL
 #define NodeInfo_user_MSGTYPE User
@@ -397,18 +419,38 @@ X(a, STATIC,   SINGULAR, UINT32,   version,           8)
 #define DeviceState_receive_queue_MSGTYPE MeshPacket
 #define DeviceState_rx_text_message_MSGTYPE MeshPacket
 
+#define DebugString_FIELDLIST(X, a) \
+X(a, STATIC,   SINGULAR, STRING,   message,           1)
+#define DebugString_CALLBACK NULL
+#define DebugString_DEFAULT NULL
+
 #define FromRadio_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   num,               1) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (variant,packet,variant.packet),   2)
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,packet,variant.packet),   2) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,my_info,variant.my_info),   3) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,node_info,variant.node_info),   4) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,radio,variant.radio),   6) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,debug_string,variant.debug_string),   7) \
+X(a, STATIC,   ONEOF,    UINT32,   (variant,config_complete_id,variant.config_complete_id),   8) \
+X(a, STATIC,   ONEOF,    BOOL,     (variant,rebooted,variant.rebooted),   9)
 #define FromRadio_CALLBACK NULL
 #define FromRadio_DEFAULT NULL
 #define FromRadio_variant_packet_MSGTYPE MeshPacket
+#define FromRadio_variant_my_info_MSGTYPE MyNodeInfo
+#define FromRadio_variant_node_info_MSGTYPE NodeInfo
+#define FromRadio_variant_radio_MSGTYPE RadioConfig
+#define FromRadio_variant_debug_string_MSGTYPE DebugString
 
 #define ToRadio_FIELDLIST(X, a) \
-X(a, STATIC,   ONEOF,    MESSAGE,  (variant,packet,variant.packet),   1)
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,packet,variant.packet),   1) \
+X(a, STATIC,   ONEOF,    UINT32,   (variant,want_config_id,variant.want_config_id), 100) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,set_radio,variant.set_radio), 101) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (variant,set_owner,variant.set_owner), 102)
 #define ToRadio_CALLBACK NULL
 #define ToRadio_DEFAULT NULL
 #define ToRadio_variant_packet_MSGTYPE MeshPacket
+#define ToRadio_variant_set_radio_MSGTYPE RadioConfig
+#define ToRadio_variant_set_owner_MSGTYPE User
 
 extern const pb_msgdesc_t Position_msg;
 extern const pb_msgdesc_t Data_msg;
@@ -422,6 +464,7 @@ extern const pb_msgdesc_t RadioConfig_UserPreferences_msg;
 extern const pb_msgdesc_t NodeInfo_msg;
 extern const pb_msgdesc_t MyNodeInfo_msg;
 extern const pb_msgdesc_t DeviceState_msg;
+extern const pb_msgdesc_t DebugString_msg;
 extern const pb_msgdesc_t FromRadio_msg;
 extern const pb_msgdesc_t ToRadio_msg;
 
@@ -438,24 +481,26 @@ extern const pb_msgdesc_t ToRadio_msg;
 #define NodeInfo_fields &NodeInfo_msg
 #define MyNodeInfo_fields &MyNodeInfo_msg
 #define DeviceState_fields &DeviceState_msg
+#define DebugString_fields &DebugString_msg
 #define FromRadio_fields &FromRadio_msg
 #define ToRadio_fields &ToRadio_msg
 
 /* Maximum encoded size of messages (where known) */
-#define Position_size                            46
+#define Position_size                            40
 #define Data_size                                256
 #define User_size                                72
 /* RouteDiscovery_size depends on runtime parameters */
-#define SubPacket_size                           383
-#define MeshPacket_size                          426
+#define SubPacket_size                           377
+#define MeshPacket_size                          419
 #define ChannelSettings_size                     44
 #define RadioConfig_size                         120
 #define RadioConfig_UserPreferences_size         72
-#define NodeInfo_size                            155
+#define NodeInfo_size                            132
 #define MyNodeInfo_size                          85
-#define DeviceState_size                         19502
-#define FromRadio_size                           435
-#define ToRadio_size                             429
+#define DeviceState_size                         18535
+#define DebugString_size                         258
+#define FromRadio_size                           428
+#define ToRadio_size                             422
 
 #ifdef __cplusplus
 } /* extern "C" */

src/nrf52/NRF52Bluetooth.cpp

@@ -0,0 +1,241 @@
+#include "NRF52Bluetooth.h"
+#include "configuration.h"
+#include "main.h"
+#include <bluefruit.h>
+
+/* HRM Service Definitions
+ * Heart Rate Monitor Service:  0x180D
+ * Heart Rate Measurement Char: 0x2A37
+ * Body Sensor Location Char:   0x2A38
+ */
+BLEService hrms = BLEService(UUID16_SVC_HEART_RATE);
+BLECharacteristic hrmc = BLECharacteristic(UUID16_CHR_HEART_RATE_MEASUREMENT);
+BLECharacteristic bslc = BLECharacteristic(UUID16_CHR_BODY_SENSOR_LOCATION);
+
+BLEDis bledis; // DIS (Device Information Service) helper class instance
+BLEBas blebas; // BAS (Battery Service) helper class instance
+BLEDfu bledfu; // DFU software update helper service
+
+uint8_t bps = 0;
+
+void connect_callback(uint16_t conn_handle)
+{
+    // Get the reference to current connection
+    BLEConnection *connection = Bluefruit.Connection(conn_handle);
+
+    char central_name[32] = {0};
+    connection->getPeerName(central_name, sizeof(central_name));
+
+    DEBUG_MSG("Connected to %s\n", central_name);
+}
+
+/**
+ * Callback invoked when a connection is dropped
+ * @param conn_handle connection where this event happens
+ * @param reason is a BLE_HCI_STATUS_CODE which can be found in ble_hci.h
+ */
+void disconnect_callback(uint16_t conn_handle, uint8_t reason)
+{
+    (void)conn_handle;
+    (void)reason;
+
+    DEBUG_MSG("Disconnected, reason = 0x%x\n", reason);
+}
+
+void cccd_callback(uint16_t conn_hdl, BLECharacteristic *chr, uint16_t cccd_value)
+{
+    // Display the raw request packet
+    DEBUG_MSG("CCCD Updated: %u\n", cccd_value);
+
+    // Check the characteristic this CCCD update is associated with in case
+    // this handler is used for multiple CCCD records.
+    if (chr->uuid == hrmc.uuid) {
+        if (chr->notifyEnabled(conn_hdl)) {
+            DEBUG_MSG("Heart Rate Measurement 'Notify' enabled\n");
+        } else {
+            DEBUG_MSG("Heart Rate Measurement 'Notify' disabled\n");
+        }
+    }
+}
+
+void startAdv(void)
+{
+    // Advertising packet
+    Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
+    Bluefruit.Advertising.addTxPower();
+
+    // Include HRM Service UUID
+    Bluefruit.Advertising.addService(hrms);
+
+    // Include Name
+    Bluefruit.Advertising.addName();
+
+    /* Start Advertising
+     * - Enable auto advertising if disconnected
+     * - Interval:  fast mode = 20 ms, slow mode = 152.5 ms
+     * - Timeout for fast mode is 30 seconds
+     * - Start(timeout) with timeout = 0 will advertise forever (until connected)
+     *
+     * For recommended advertising interval
+     * https://developer.apple.com/library/content/qa/qa1931/_index.html
+     */
+    Bluefruit.Advertising.restartOnDisconnect(true);
+    Bluefruit.Advertising.setInterval(32, 244); // in unit of 0.625 ms
+    Bluefruit.Advertising.setFastTimeout(30);   // number of seconds in fast mode
+    Bluefruit.Advertising.start(0);             // 0 = Don't stop advertising after n seconds
+}
+
+void setupHRM(void)
+{
+    // Configure the Heart Rate Monitor service
+    // See: https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.service.heart_rate.xml
+    // Supported Characteristics:
+    // Name                         UUID    Requirement Properties
+    // ---------------------------- ------  ----------- ----------
+    // Heart Rate Measurement       0x2A37  Mandatory   Notify
+    // Body Sensor Location         0x2A38  Optional    Read
+    // Heart Rate Control Point     0x2A39  Conditional Write       <-- Not used here
+    hrms.begin();
+
+    // Note: You must call .begin() on the BLEService before calling .begin() on
+    // any characteristic(s) within that service definition.. Calling .begin() on
+    // a BLECharacteristic will cause it to be added to the last BLEService that
+    // was 'begin()'ed!
+
+    // Configure the Heart Rate Measurement characteristic
+    // See:
+    // https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.characteristic.heart_rate_measurement.xml
+    // Properties = Notify
+    // Min Len    = 1
+    // Max Len    = 8
+    //    B0      = UINT8  - Flag (MANDATORY)
+    //      b5:7  = Reserved
+    //      b4    = RR-Internal (0 = Not present, 1 = Present)
+    //      b3    = Energy expended status (0 = Not present, 1 = Present)
+    //      b1:2  = Sensor contact status (0+1 = Not supported, 2 = Supported but contact not detected, 3 = Supported and
+    //      detected) b0    = Value format (0 = UINT8, 1 = UINT16)
+    //    B1      = UINT8  - 8-bit heart rate measurement value in BPM
+    //    B2:3    = UINT16 - 16-bit heart rate measurement value in BPM
+    //    B4:5    = UINT16 - Energy expended in joules
+    //    B6:7    = UINT16 - RR Internal (1/1024 second resolution)
+    hrmc.setProperties(CHR_PROPS_NOTIFY);
+    hrmc.setPermission(SECMODE_OPEN, SECMODE_NO_ACCESS);
+    hrmc.setFixedLen(2);
+    hrmc.setCccdWriteCallback(cccd_callback); // Optionally capture CCCD updates
+    hrmc.begin();
+    uint8_t hrmdata[2] = {0b00000110, 0x40}; // Set the characteristic to use 8-bit values, with the sensor connected and detected
+    hrmc.write(hrmdata, 2);
+
+    // Configure the Body Sensor Location characteristic
+    // See:
+    // https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.characteristic.body_sensor_location.xml
+    // Properties = Read
+    // Min Len    = 1
+    // Max Len    = 1
+    //    B0      = UINT8 - Body Sensor Location
+    //      0     = Other
+    //      1     = Chest
+    //      2     = Wrist
+    //      3     = Finger
+    //      4     = Hand
+    //      5     = Ear Lobe
+    //      6     = Foot
+    //      7:255 = Reserved
+    bslc.setProperties(CHR_PROPS_READ);
+    bslc.setPermission(SECMODE_OPEN, SECMODE_NO_ACCESS);
+    bslc.setFixedLen(1);
+    bslc.begin();
+    bslc.write8(2); // Set the characteristic to 'Wrist' (2)
+}
+
+void NRF52Bluetooth::setup()
+{
+    // Initialise the Bluefruit module
+    DEBUG_MSG("Initialise the Bluefruit nRF52 module\n");
+    Bluefruit.begin();
+
+    // Set the advertised device name (keep it short!)
+    Bluefruit.setName(getDeviceName()); // FIXME
+
+    // Set the connect/disconnect callback handlers
+    Bluefruit.Periph.setConnectCallback(connect_callback);
+    Bluefruit.Periph.setDisconnectCallback(disconnect_callback);
+
+    // Configure and Start the Device Information Service
+    DEBUG_MSG("Configuring the Device Information Service\n");
+    bledis.setManufacturer("meshtastic.org");
+    bledis.setModel("NRF52-meshtastic"); // FIXME
+    bledis.begin();
+
+    // Start the BLE Battery Service and set it to 100%
+    DEBUG_MSG("Configuring the Battery Service\n");
+    blebas.begin();
+    blebas.write(42); // FIXME, report real power levels
+
+    bledfu.begin(); // Install the DFU helper
+
+    // Setup the Heart Rate Monitor service using
+    // BLEService and BLECharacteristic classes
+    DEBUG_MSG("Configuring the Heart Rate Monitor Service\n");
+    setupHRM();
+
+    // Setup the advertising packet(s)
+    DEBUG_MSG("Setting up the advertising payload(s)\n");
+    startAdv();
+
+    DEBUG_MSG("Advertising\n");
+}
+
+/*
+void loop()
+{
+  digitalToggle(LED_RED);
+
+  if ( Bluefruit.connected() ) {
+    uint8_t hrmdata[2] = { 0b00000110, bps++ };           // Sensor connected, increment BPS value
+
+    // Note: We use .notify instead of .write!
+    // If it is connected but CCCD is not enabled
+    // The characteristic's value is still updated although notification is not sent
+    if ( hrmc.notify(hrmdata, sizeof(hrmdata)) ){
+      Serial.print("Heart Rate Measurement updated to: "); Serial.println(bps);
+    }else{
+      Serial.println("ERROR: Notify not set in the CCCD or not connected!");
+    }
+  }
+
+  // Only send update once per second
+  delay(1000);
+}
+*/
+
+/*
+examples of advanced characteristics. use setReadAuthorizeCallback to prepare data for reads by others
+
+err_t BLEDfu::begin(void)
+{
+  // Invoke base class begin()
+  VERIFY_STATUS( BLEService::begin() );
+
+  // No need to keep packet & revision characteristics
+  BLECharacteristic chr_packet(UUID128_CHR_DFU_PACKET);
+  chr_packet.setTempMemory();
+  chr_packet.setProperties(CHR_PROPS_WRITE_WO_RESP);
+  chr_packet.setMaxLen(20);
+  VERIFY_STATUS( chr_packet.begin() );
+
+  _chr_control.setProperties(CHR_PROPS_WRITE | CHR_PROPS_NOTIFY);
+  _chr_control.setMaxLen(23);
+  _chr_control.setWriteAuthorizeCallback(bledfu_control_wr_authorize_cb);
+  VERIFY_STATUS( _chr_control.begin() );
+
+  BLECharacteristic chr_revision(UUID128_CHR_DFU_REVISON);
+  chr_revision.setTempMemory();
+  chr_revision.setProperties(CHR_PROPS_READ);
+  chr_revision.setFixedLen(2);
+  VERIFY_STATUS( chr_revision.begin());
+  chr_revision.write16(DFU_REV_APPMODE);
+
+  return ERROR_NONE;
+}
+*/

src/nrf52/NRF52Bluetooth.h

@@ -0,0 +1,8 @@
+#pragma once
+
+class NRF52Bluetooth
+{
+  public:
+    void setup();
+};
+