Merge pull request #113 from geeksville/master

Make new (optional) serial protobuf API work

.gitignore

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

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,21 @@ 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
 }
 
 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.2
+export VERSION=0.6.0

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": "ppr",
+    "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

@@ -36,8 +36,9 @@ 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/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 +46,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 
+## 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.  
+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
 
@@ -107,4 +95,4 @@ Implements the standard BLE contract for this service (has software version, har
 
 ### BatteryLevelService
 
-Implements the standard BLE contract service, provides battery level in a way that most client devices should automatically understand (i.e. it should show in the bluetooth devices screen automatically)
+Implements the standard BLE contract service, provides battery level in a way that most client devices should automatically understand (i.e. it should show in the bluetooth devices screen automatically)

docs/software/nrf52-TODO.md

@@ -0,0 +1,141 @@
+# NRF52 TODO
+
+## Initial work items
+
+Minimum items needed to make sure hardware is good.
+
+- 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
+- switch to RadioLab? test it with current radio. https://github.com/jgromes/RadioLib
+- use "variants" to get all gpio bindings
+- plug in correct variants for the real board
+- Use the PMU driver on real hardware
+- add a NEMA based GPS driver to test GPS
+- Use new radio driver on real hardware - possibly start with https://os.mbed.com/teams/Semtech/code/SX126xLib/
+- 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.
+
+- 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'
+
+- 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)
+
+## Things to do 'someday'
+
+Nice ideas worth considering someday...
+
+- 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
+
+```
+
+/*
+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: 
+  onExit:
 
-* running dark (DARK) - Everything is on except screen
+- running dark (DARK) - Everything is on except screen
   onEntry: setBluetoothOn(true)
-  onExit: 
+  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.

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?
-	 
-	BLECharacteristic *m_pnpCharacteristic = m_deviceInfoService->createCharacteristic(ESP_GATT_UUID_PNP_ID, BLECharacteristic::PROPERTY_READ);
+    /*
+           * Mandatory characteristic for device info service?
 
-    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);
+          BLECharacteristic *m_pnpCharacteristic = m_deviceInfoService->createCharacteristic(ESP_GATT_UUID_PNP_ID,
+      BLECharacteristic::PROPERTY_READ);
 
-  // m_manufacturerCharacteristic = m_deviceInfoService->createCharacteristic((uint16_t) 0x2a29, BLECharacteristic::PROPERTY_READ);
-  // m_manufacturerCharacteristic->setValue(name);
+      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);
 
-  /* add these later?
-    ESP_GATT_UUID_SYSTEM_ID
-    */
+    // m_manufacturerCharacteristic = m_deviceInfoService->createCharacteristic((uint16_t) 0x2a29,
+    // BLECharacteristic::PROPERTY_READ); m_manufacturerCharacteristic->setValue(name);
 
-  // caller must call service->start();
-  return deviceInfoService;
+    /* add these later?
+      ESP_GATT_UUID_SYSTEM_ID
+      */
+
+    // 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/rf95 -Isrc/mesh -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/SX126x-Arduino.git
+  Ticker ; Needed for SX126x-Arduino on ESP32
 
 ; 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,25 @@ 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_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}
-monitor_port = /dev/ttyACM1
+  UC1701
+  https://github.com/meshtastic/BQ25703A.git
+monitor_port = /dev/ttyACM1
+
+; Set initial breakpoint (defaults to main)
+debug_init_break =
+;debug_init_break = tbreak loop
+;debug_init_break = tbreak Reset_Handler

src/GPS.cpp

@@ -9,7 +9,7 @@
 HardwareSerial _serial_gps(GPS_SERIAL_NUM);
 #else
 // Assume NRF52
-// Uart _serial_gps(GPS_SERIAL_NUM);
+HardwareSerial &_serial_gps = Serial1;
 #endif
 
 bool timeSetFromGPS; // We try to set our time from GPS each time we wake from sleep
@@ -27,10 +27,15 @@ GPS::GPS() : PeriodicTask() {}
 
 void GPS::setup()
 {
+    PeriodicTask::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);
+#else
+    _serial_gps.begin(GPS_BAUDRATE);
+#endif
     // _serial_gps.setRxBufferSize(1024); // the default is 256
     // ublox.enableDebugging(Serial);
 
@@ -43,7 +48,7 @@ void GPS::setup()
         isConnected = ublox.begin(_serial_gps);
 
     if (isConnected) {
-        DEBUG_MSG("Connected to GPS successfully, TXpin=%d\n", GPS_TX_PIN);
+        DEBUG_MSG("Connected to GPS successfully\n");
 
         bool factoryReset = false;
         bool ok;
@@ -81,7 +86,6 @@ void GPS::setup()
         // checkUblox cyclically)
         ublox.assumeAutoPVT(true, true);
     }
-#endif
 }
 
 void GPS::readFromRTC()
@@ -114,12 +118,6 @@ void GPS::perhapsSetRTC(const struct timeval *tv)
 
 #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;
@@ -145,7 +143,6 @@ void GPS::prepareSleep()
 
 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) {
@@ -207,7 +204,6 @@ The Unix epoch (or Unix time or POSIX time or Unix timestamp) is the number of s
         }
     } 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

src/GPS.h

@@ -29,7 +29,6 @@ class GPS : public PeriodicTask, public Observable<void *>
 
     void setup();
 
-    virtual void loop();
 
     virtual void doTask();
 

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

@@ -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,36 @@
+#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();
+}
+
+/**
+ * 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,24 @@
+#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);
+};
+
+extern SerialConsole console;

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,41 @@ 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
+#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
+
+// -----------------------------------------------------------------------------
+// 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:
@@ -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;
@@ -50,4 +51,183 @@ void setBluetoothEnable(bool on)
             // heap_trace_dump();
         }
     }
+}
+
+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()
+{
+#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/main.cpp

@@ -27,11 +27,13 @@
 #include "NodeDB.h"
 #include "Periodic.h"
 #include "PowerFSM.h"
+#include "Router.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 +43,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 +75,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 +91,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 +105,28 @@ 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);
 
 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 +143,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 +158,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,14 +167,18 @@ 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
@@ -283,11 +186,11 @@ void setup()
 
     service.init();
 
-#ifndef NO_ESP32
+    realRouter.setup(); // required for our periodic task (kinda skanky FIXME)
+
     // MUST BE AFTER service.init, so we have our radio config settings (from nodedb init)
     radio = new MeshRadio();
     router.addInterface(&radio->radioIf);
-#endif
 
     if (radio && !radio->init())
         recordCriticalError(ErrNoRadio);
@@ -299,19 +202,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 +220,27 @@ 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();
     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
@@ -419,7 +276,6 @@ void loop()
     screen.debug()->setPowerStatus(powerStatus);
     // TODO(#4): use something based on hdop to show GPS "signal" strength.
     screen.debug()->setGPSStatus(gps.hasLock() ? "ok" : ":(");
-    screen.loop();
 
     // 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/MeshRadio.h

@@ -55,7 +55,10 @@
 #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
 
 /**

src/mesh/MeshService.cpp

@@ -48,6 +48,15 @@ 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()
@@ -65,6 +74,7 @@ MeshService::MeshService() : toPhoneQueue(MAX_RX_TOPHONE)
 
 void MeshService::init()
 {
+    sendOwnerPeriod.setup();
     nodeDB.init();
 
     gpsObserver.observe(&gps);
@@ -184,15 +194,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()
 {
@@ -200,9 +201,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
@@ -214,46 +212,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 = gps.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
     }
 }
 

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/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;
+
+    /// Our fromradio packet while it is being assembled
+    FromRadio fromRadioScratch;
+
+    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:
+    /**
+     * Subclasses can use this as a hook to provide custom notifications for their transport (i.e. bluetooth notifies)
+     */
+    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/StreamAPI.cpp

@@ -0,0 +1,71 @@
+#include "StreamAPI.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);
+            if (len != 0) {
+                txBuf[0] = START1;
+                txBuf[1] = START2;
+                txBuf[2] = (len >> 8) & 0xff;
+                txBuf[3] = len & 0xff;
+
+                stream->write(txBuf, len + HEADER_LEN);
+            }
+        } while (len);
+    }
+}

src/mesh/StreamAPI.h

@@ -0,0 +1,66 @@
+#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;
+
+    uint8_t txBuf[MAX_STREAM_BUF_SIZE];
+
+  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:
+    /// Are we allowed to write packets to our output stream (subclasses can turn this off - i.e. SerialConsole)
+    bool canWrite = true;
+};

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)
 
 

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;
@@ -150,6 +154,11 @@ 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;
     } 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))
 
@@ -188,6 +200,7 @@ typedef struct _ToRadio {
 #define NodeInfo_init_default                    {0, false, User_init_default, false, Position_init_default, 0, 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}
@@ -202,6 +215,7 @@ typedef struct _ToRadio {
 #define NodeInfo_init_zero                       {0, false, User_init_zero, false, Position_init_zero, 0, 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
@@ -269,8 +284,16 @@ 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_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) \
@@ -397,18 +420,37 @@ 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)
 #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,6 +481,7 @@ 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
 
@@ -454,6 +498,7 @@ extern const pb_msgdesc_t ToRadio_msg;
 #define NodeInfo_size                            155
 #define MyNodeInfo_size                          85
 #define DeviceState_size                         19502
+#define DebugString_size                         258
 #define FromRadio_size                           435
 #define ToRadio_size                             429
 

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();
+};
+

src/nrf52/PmuBQ25703A.cpp

@@ -0,0 +1,97 @@
+#include "PmuBQ25703A.h"
+#include <assert.h>
+
+// Default address for device. Note, it is without read/write bit. When read with analyser,
+// this will appear 1 bit shifted to the left
+#define BQ25703ADevaddr 0xD6
+
+const byte Lorro_BQ25703A::BQ25703Aaddr = BQ25703ADevaddr;
+
+void PmuBQ25703A::init()
+{
+    // Set the watchdog timer to not have a timeout
+    regs.chargeOption0.set_WDTMR_ADJ(0);
+    assert(writeRegEx(regs.chargeOption0)); // FIXME, instead log a critical hw failure and reboot
+    delay(15);                              // FIXME, why are these delays required? - check datasheet
+
+    // Set the ADC on IBAT and PSYS to record values
+    // When changing bitfield values, call the writeRegEx function
+    // This is so you can change all the bits you want before sending out the byte.
+    regs.chargeOption1.set_EN_IBAT(1);
+    regs.chargeOption1.set_EN_PSYS(1);
+    assert(writeRegEx(regs.chargeOption1));
+    delay(15);
+
+    // Set ADC to make continuous readings. (uses more power)
+    regs.aDCOption.set_ADC_CONV(1);
+    // Set individual ADC registers to read. All have default off.
+    regs.aDCOption.set_EN_ADC_VBUS(1);
+    regs.aDCOption.set_EN_ADC_PSYS(1);
+    regs.aDCOption.set_EN_ADC_IDCHG(1);
+    regs.aDCOption.set_EN_ADC_ICHG(1);
+    regs.aDCOption.set_EN_ADC_VSYS(1);
+    regs.aDCOption.set_EN_ADC_VBAT(1);
+    // Once bits have been twiddled, send bytes to device
+    assert(writeRegEx(regs.aDCOption));
+    delay(15);
+}
+
+/*
+
+
+//Initialise the device and library
+Lorro_BQ25703A BQ25703A;
+
+//Instantiate with reference to global set
+extern Lorro_BQ25703A::Regt BQ25703Areg;
+
+uint32_t previousMillis;
+uint16_t loopInterval = 1000;
+
+void setup() {
+
+  Serial.begin(115200);
+
+
+}
+
+void loop() {
+
+  uint32_t currentMillis = millis();
+
+  if( currentMillis - previousMillis > loopInterval ){
+    previousMillis = currentMillis;
+
+    Serial.print( "Voltage of VBUS: " );
+    Serial.print( BQ25703Areg.aDCVBUSPSYS.get_VBUS() );
+    Serial.println( "mV" );
+    delay( 15 );
+
+    Serial.print( "System power usage: " );
+    Serial.print( BQ25703Areg.aDCVBUSPSYS.get_sysPower() );
+    Serial.println( "W" );
+    delay( 15 );
+
+    Serial.print( "Voltage of VBAT: " );
+    Serial.print( BQ25703Areg.aDCVSYSVBAT.get_VBAT() );
+    Serial.println( "mV" );
+    delay( 15 );
+
+    Serial.print( "Voltage of VSYS: " );
+    Serial.print( BQ25703Areg.aDCVSYSVBAT.get_VSYS() );
+    Serial.println( "mV" );
+    delay( 15 );
+
+    Serial.print( "Charging current: " );
+    Serial.print( BQ25703Areg.aDCIBAT.get_ICHG() );
+    Serial.println( "mA" );
+    delay( 15 );
+
+    Serial.print( "Voltage of VSYS: " );
+    Serial.print( BQ25703Areg.aDCIBAT.get_IDCHG() );
+    Serial.println( "mA" );
+    delay( 15 );
+
+  }
+
+}*/

src/nrf52/PmuBQ25703A.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <Lorro_BQ25703A.h>
+
+class PmuBQ25703A : private Lorro_BQ25703A
+{
+    Lorro_BQ25703A::Regt regs;
+
+  public:
+    /**
+     * Configure the PMU for our board
+     */
+    void init();
+
+    // Methods to have a common API with AXP192
+    bool isBatteryConnect() { return true; } // FIXME
+    bool isVBUSPlug() { return true; }
+    bool isChargeing() { return true; } // FIXME, intentional misspelling
+
+    /// battery voltage in mV
+    int getBattVoltage() { return 3200; }
+};

src/nrf52/main-bare.cpp

@@ -0,0 +1,2 @@
+#include "target_specific.h"
+

src/nrf52/main-nrf52.cpp

@@ -0,0 +1,70 @@
+#include "NRF52Bluetooth.h"
+#include "configuration.h"
+#include <assert.h>
+#include <ble_gap.h>
+#include <memory.h>
+#include <nrf52840.h>
+
+// #define USE_SOFTDEVICE
+
+static inline void debugger_break(void)
+{
+    __asm volatile("bkpt #0x01\n\t"
+                   "mov pc, lr\n\t");
+}
+
+// handle standard gcc assert failures
+void __attribute__((noreturn)) __assert_func(const char *file, int line, const char *func, const char *failedexpr)
+{
+    DEBUG_MSG("assert failed %s: %d, %s, test=%s\n", file, line, func, failedexpr);
+    debugger_break();
+    while (1)
+        ; // FIXME, reboot!
+}
+
+void getMacAddr(uint8_t *dmac)
+{
+    ble_gap_addr_t addr;
+
+#ifdef USE_SOFTDEVICE
+    uint32_t res = sd_ble_gap_addr_get(&addr);
+    assert(res == NRF_SUCCESS);
+    memcpy(dmac, addr.addr, 6);
+#else
+    const uint8_t *src = (const uint8_t *)NRF_FICR->DEVICEADDR;
+    dmac[5] = src[0];
+    dmac[4] = src[1];
+    dmac[3] = src[2];
+    dmac[2] = src[3];
+    dmac[1] = src[4];
+    dmac[0] = src[5] | 0xc0; // MSB high two bits get set elsewhere in the bluetooth stack
+#endif
+}
+
+NRF52Bluetooth *nrf52Bluetooth;
+
+static bool bleOn = false;
+void setBluetoothEnable(bool on)
+{
+    if (on != bleOn) {
+        if (on) {
+            if (!nrf52Bluetooth) {
+                nrf52Bluetooth = new NRF52Bluetooth();
+                nrf52Bluetooth->setup();
+            }
+        } else {
+            DEBUG_MSG("FIXME: implement BLE disable\n");
+        }
+        bleOn = on;
+    }
+}
+
+#include "PmuBQ25703A.h"
+
+PmuBQ25703A pmu;
+
+void nrf52Setup()
+{
+    // Not yet on board
+    // pmu.init();
+}

src/power.h

@@ -16,3 +16,5 @@ struct PowerStatus {
 };
 
 } // namespace meshtastic
+
+extern meshtastic::PowerStatus powerStatus;

src/rf95/CustomRF95.cpp

@@ -20,7 +20,7 @@ bool CustomRF95::canSleep()
 
     bool res = (_mode == RHModeInitialising || _mode == RHModeIdle || _mode == RHModeRx) && !isRx && txQueue.isEmpty();
     if (!res) // only print debug messages if we are vetoing sleep
-        DEBUG_MSG("canSleep, mode=%d, isRx=%d, txEmpty=%d, txGood=%d\n", _mode, isRx, txQueue.isEmpty(), _txGood);
+        DEBUG_MSG("radio wait to sleep, mode=%d, isRx=%d, txEmpty=%d, txGood=%d\n", _mode, isRx, txQueue.isEmpty(), _txGood);
 
     return res;
 }
@@ -78,13 +78,12 @@ void CustomRF95::handleInterrupt()
 {
     RH_RF95::handleInterrupt();
 
-    BaseType_t higherPriWoken = false;
     if (_mode == RHModeIdle) // We are now done sending or receiving
     {
         if (sendingPacket) // Were we sending?
         {
             // We are done sending that packet, release it
-            packetPool.releaseFromISR(sendingPacket, &higherPriWoken);
+            packetPool.release(sendingPacket);
             sendingPacket = NULL;
             // DEBUG_MSG("Done with send\n");
         }
@@ -123,43 +122,35 @@ void CustomRF95::handleInterrupt()
             }
 
             if (!pb_decode_from_bytes(payload, payloadLen, SubPacket_fields, p)) {
-                packetPool.releaseFromISR(mp, &higherPriWoken);
+                packetPool.release(mp);
             } else {
                 // parsing was successful, queue for our recipient
                 mp->has_payload = true;
 
-                deliverToReceiverISR(mp, &higherPriWoken);
+                deliverToReceiver(mp);
             }
 
             clearRxBuf(); // This message accepted and cleared
         }
 
-        higherPriWoken |= handleIdleISR();
+        handleIdleISR();
     }
-
-    // If we call this _IT WILL NOT RETURN_
-    if (higherPriWoken)
-        portYIELD_FROM_ISR();
 }
 
 /** The ISR doesn't have any good work to do, give a new assignment.
  *
  * Return true if a higher pri task has woken
  */
-bool CustomRF95::handleIdleISR()
+void CustomRF95::handleIdleISR()
 {
-    BaseType_t higherPriWoken = false;
-
     // First send any outgoing packets we have ready
-    MeshPacket *txp = txQueue.dequeuePtrFromISR(0);
+    MeshPacket *txp = txQueue.dequeuePtr(0);
     if (txp)
         startSend(txp);
     else {
         // Nothing to send, let's switch back to receive mode
         setModeRx();
     }
-
-    return higherPriWoken;
 }
 
 /// This routine might be called either from user space or ISR
@@ -197,6 +188,8 @@ void CustomRF95::startSend(MeshPacket *txp)
 
 void CustomRF95::loop()
 {
+    RH_RF95::loop();
+
     // It should never take us more than 30 secs to send a packet, if it does, we have a bug, FIXME, move most of this
     // into CustomRF95
     uint32_t now = millis();

src/rf95/CustomRF95.h

@@ -52,5 +52,5 @@ class CustomRF95 : public RH_RF95, public RadioInterface
     void startSend(MeshPacket *txp);
 
     /// Return true if a higher pri task has woken
-    bool handleIdleISR();
+    void handleIdleISR();
 };

src/rf95/FloodingRouter.cpp

@@ -5,9 +5,10 @@
 /// We clear our old flood record five minute after we see the last of it
 #define FLOOD_EXPIRE_TIME (5 * 60 * 1000L)
 
-FloodingRouter::FloodingRouter()
+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
 }
 
 /**
@@ -23,6 +24,12 @@ ErrorCode FloodingRouter::send(MeshPacket *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
+}
+
 /**
  * Called from loop()
  * Handle any packet that is received by an interface on this node.
@@ -38,12 +45,14 @@ void FloodingRouter::handleReceived(MeshPacket *p)
     } else {
         if (p->to == NODENUM_BROADCAST) {
             if (p->id != 0) {
-                DEBUG_MSG("Rebroadcasting received floodmsg to neighbors fr=0x%x,to=0x%x,id=%d\n", p->from, p->to, p->id);
-                // FIXME, wait a random delay
+                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);
 
                 MeshPacket *tosend = packetPool.allocCopy(*p);
-                // Note: we are careful to resend using the original senders node id
-                Router::send(tosend); // We are careful not to call our hooked version of send()
+                toResend.enqueue(tosend);
+                setPeriod(delay); // This will work even if we were already waiting a random delay
             } else {
                 DEBUG_MSG("Ignoring a simple (0 hop) broadcast\n");
             }
@@ -54,6 +63,24 @@ void FloodingRouter::handleReceived(MeshPacket *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
  */

src/rf95/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/rf95/RH_RF95.cpp

@@ -34,16 +34,12 @@ bool RH_RF95::init()
     if (!RHSPIDriver::init())
         return false;
 
-    // Determine the interrupt number that corresponds to the interruptPin
-    int interruptNumber = digitalPinToInterrupt(_interruptPin);
-    if (interruptNumber == NOT_AN_INTERRUPT)
-        return false;
 #ifdef RH_ATTACHINTERRUPT_TAKES_PIN_NUMBER
     interruptNumber = _interruptPin;
 #endif
 
     // Tell the low level SPI interface we will use SPI within this interrupt
-    spiUsingInterrupt(interruptNumber);
+    // spiUsingInterrupt(interruptNumber);
 
     // No way to check the device type :-(
 
@@ -114,18 +110,40 @@ bool RH_RF95::init()
             return false; // Too many devices, not enough interrupt vectors
     }
     _deviceForInterrupt[_myInterruptIndex] = this;
+
+    return enableInterrupt();
+}
+
+// If on a platform without level trigger definitions, just use RISING and suck it up.
+#ifndef ONHIGH
+#define ONHIGH RISING
+#endif
+
+bool RH_RF95::enableInterrupt()
+{
+    // Determine the interrupt number that corresponds to the interruptPin
+    int interruptNumber = digitalPinToInterrupt(_interruptPin);
+    if (interruptNumber == NOT_AN_INTERRUPT)
+        return false;
+
     if (_myInterruptIndex == 0)
-        attachInterrupt(interruptNumber, isr0, RISING);
+        attachInterrupt(interruptNumber, isr0, ONHIGH);
     else if (_myInterruptIndex == 1)
-        attachInterrupt(interruptNumber, isr1, RISING);
+        attachInterrupt(interruptNumber, isr1, ONHIGH);
     else if (_myInterruptIndex == 2)
-        attachInterrupt(interruptNumber, isr2, RISING);
+        attachInterrupt(interruptNumber, isr2, ONHIGH);
     else
         return false; // Too many devices, not enough interrupt vectors
 
     return true;
 }
 
+void RH_INTERRUPT_ATTR RH_RF95::disableInterrupt()
+{
+    int interruptNumber = digitalPinToInterrupt(_interruptPin);
+    detachInterrupt(interruptNumber);
+}
+
 void RH_RF95::prepareDeepSleep()
 {
     // Determine the interrupt number that corresponds to the interruptPin
@@ -143,6 +161,13 @@ bool RH_RF95::isReceiving()
                                         RH_RF95_MODEM_STATUS_HEADER_INFO_VALID)) != 0;
 }
 
+void RH_INTERRUPT_ATTR RH_RF95::handleInterruptLevel0()
+{
+    disableInterrupt(); // Disable our interrupt until our helper thread can run (because the IRQ will remain asserted until we
+                        // talk to it via SPI)
+    pendingInterrupt = true;
+}
+
 // C++ level interrupt handler for this instance
 // LORA is unusual in that it has several interrupt lines, and not a single, combined one.
 // On MiniWirelessLoRa, only one of the several interrupt lines (DI0) from the RFM95 is usefuly
@@ -153,25 +178,29 @@ void RH_RF95::handleInterrupt()
     // Read the interrupt register
     uint8_t irq_flags = spiRead(RH_RF95_REG_12_IRQ_FLAGS);
 
+    // ack all interrupts
+    // note from radiohead author wrt old code (with IMO wrong fix)
+    // Sigh: on some processors, for some unknown reason, doing this only once does not actually
+    // clear the radio's interrupt flag. So we do it twice. Why? (kevinh - I think the root cause we want level
+    // triggered interrupts here - not edge.  Because edge allows us to miss handling secondard interrupts that occurred
+    // while this ISR was running.  Better to instead, configure the interrupts as level triggered and clear pending
+    // at the _beginning_ of the ISR.  If any interrupts occur while handling the ISR, the signal will remain asserted and
+    // our ISR will be reinvoked to handle that case)
+    spiWrite(RH_RF95_REG_12_IRQ_FLAGS, 0xff); // Clear all IRQ flags
+
     // Note: there can be substantial latency between ISR assertion and this function being run, therefore
     // multiple flags might be set.  Handle them all
 
     // Note: we are running the chip in continuous receive mode (currently, so RX_TIMEOUT shouldn't ever occur)
     bool haveRxError = irq_flags & (RH_RF95_RX_TIMEOUT | RH_RF95_PAYLOAD_CRC_ERROR);
-    if (haveRxError)
-    //    if (_mode == RHModeRx && irq_flags & (RH_RF95_RX_TIMEOUT | RH_RF95_PAYLOAD_CRC_ERROR))
-    {
+    if (haveRxError) {
         _rxBad++;
         clearRxBuf();
-    }
-
-    if ((irq_flags & RH_RF95_RX_DONE) && !haveRxError) {
+    } else if (irq_flags & RH_RF95_RX_DONE) {
         // Read the RegHopChannel register to check if CRC presence is signalled
         // in the header. If not it might be a stray (noise) packet.*
         uint8_t crc_present = spiRead(RH_RF95_REG_1C_HOP_CHANNEL) & RH_RF95_RX_PAYLOAD_CRC_IS_ON;
 
-        spiWrite(RH_RF95_REG_12_IRQ_FLAGS, 0xff); // Clear all IRQ flags, required before reading fifo (according to datasheet)
-
         if (!crc_present) {
             _rxBad++;
             clearRxBuf();
@@ -219,13 +248,14 @@ void RH_RF95::handleInterrupt()
         setModeIdle();
     }
 
-    // ack all interrupts, note - we did this already in the RX_DONE case above, and we don't want to do it twice
-    if (!(irq_flags & RH_RF95_RX_DONE)) {
-        // Sigh: on some processors, for some unknown reason, doing this only once does not actually
-        // clear the radio's interrupt flag. So we do it twice. Why?
-        // kevinh: turn this off until root cause is known, because it can cause missed interrupts!
-        // spiWrite(RH_RF95_REG_12_IRQ_FLAGS, 0xff); // Clear all IRQ flags
-        spiWrite(RH_RF95_REG_12_IRQ_FLAGS, 0xff); // Clear all IRQ flags
+    enableInterrupt(); // Let ISR run again
+}
+
+void RH_RF95::loop()
+{
+    while (pendingInterrupt) {
+        pendingInterrupt = false; // If the flag was set, it is _guaranteed_ the ISR won't be running, because it masked itself
+        handleInterrupt();
     }
 }
 
@@ -235,17 +265,17 @@ void RH_RF95::handleInterrupt()
 void RH_INTERRUPT_ATTR RH_RF95::isr0()
 {
     if (_deviceForInterrupt[0])
-        _deviceForInterrupt[0]->handleInterrupt();
+        _deviceForInterrupt[0]->handleInterruptLevel0();
 }
 void RH_INTERRUPT_ATTR RH_RF95::isr1()
 {
     if (_deviceForInterrupt[1])
-        _deviceForInterrupt[1]->handleInterrupt();
+        _deviceForInterrupt[1]->handleInterruptLevel0();
 }
 void RH_INTERRUPT_ATTR RH_RF95::isr2()
 {
     if (_deviceForInterrupt[2])
-        _deviceForInterrupt[2]->handleInterrupt();
+        _deviceForInterrupt[2]->handleInterruptLevel0();
 }
 
 // Check whether the latest received message is complete and uncorrupted

src/rf95/RH_RF95.h

@@ -806,12 +806,17 @@ class RH_RF95 : public RHSPIDriver
     /// Return true if we are currently receiving a packet
     bool isReceiving();
 
+    void loop(); // Perform idle processing
+
   protected:
     /// This is a low level function to handle the interrupts for one instance of RH_RF95.
     /// Called automatically by isr*()
     /// Should not need to be called by user code.
     virtual void handleInterrupt();
 
+    /// This is the only code called in ISR context, it just queues up our helper thread to run handleInterrupt();
+    void RH_INTERRUPT_ATTR handleInterruptLevel0();
+
     /// Examine the revceive buffer to determine whether the message is for this node
     void validateRxBuf();
 
@@ -846,6 +851,11 @@ class RH_RF95 : public RHSPIDriver
     /// Index of next interrupt number to use in _deviceForInterrupt
     static uint8_t _interruptCount;
 
+    bool enableInterrupt();  // enable our IRQ
+    void disableInterrupt(); // disable our IRQ
+
+    volatile bool pendingInterrupt = false;
+    
     /// The configured interrupt pin connected to this instance
     uint8_t _interruptPin;
 

src/rf95/RadioInterface.cpp

@@ -15,8 +15,8 @@ ErrorCode SimRadio::send(MeshPacket *p)
     return ERRNO_OK;
 }
 
-void RadioInterface::deliverToReceiverISR(MeshPacket *p, BaseType_t *higherPriWoken)
+void RadioInterface::deliverToReceiver(MeshPacket *p)
 {
     assert(rxDest);
-    assert(rxDest->enqueueFromISR(p, higherPriWoken)); // NOWAIT - fixme, if queue is full, delete older messages
+    assert(rxDest->enqueue(p, 0)); // NOWAIT - fixme, if queue is full, delete older messages
 }

src/rf95/RadioInterface.h

@@ -24,7 +24,7 @@ class RadioInterface
     /**
      * Enqueue a received packet for the registered receiver
      */
-    void deliverToReceiverISR(MeshPacket *p, BaseType_t *higherPriWoken);
+    void deliverToReceiver(MeshPacket *p);
 
   public:
     /** pool is the pool we will alloc our rx packets from
@@ -39,6 +39,16 @@ class RadioInterface
 
     virtual void loop() {} // Idle processing
 
+    /**
+     * 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.
+     */
+    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.

src/rf95/Router.cpp

@@ -51,9 +51,13 @@ void Router::loop()
  */
 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);
+        return ERRNO_NO_INTERFACES;
+    }
 }
 
 #include "GPS.h"

src/screen.cpp

@@ -315,16 +315,16 @@ static void drawNodeInfo(OLEDDisplay *display, OLEDDisplayUiState *state, int16_
     const char *username = node->has_user ? node->user.long_name : "Unknown Name";
 
     static char signalStr[20];
-    snprintf(signalStr, sizeof(signalStr), "Signal: %d", node->snr);
+    snprintf(signalStr, sizeof(signalStr), "Signal: %ld", node->snr);
 
     uint32_t agoSecs = sinceLastSeen(node);
     static char lastStr[20];
     if (agoSecs < 120) // last 2 mins?
-        snprintf(lastStr, sizeof(lastStr), "%d seconds ago", agoSecs);
+        snprintf(lastStr, sizeof(lastStr), "%lu seconds ago", agoSecs);
     else if (agoSecs < 120 * 60) // last 2 hrs
-        snprintf(lastStr, sizeof(lastStr), "%d minutes ago", agoSecs / 60);
+        snprintf(lastStr, sizeof(lastStr), "%lu minutes ago", agoSecs / 60);
     else
-        snprintf(lastStr, sizeof(lastStr), "%d hours ago", agoSecs / 60 / 60);
+        snprintf(lastStr, sizeof(lastStr), "%lu hours ago", agoSecs / 60 / 60);
 
     static float simRadian;
     simRadian += 0.1; // For testing, have the compass spin unless both
@@ -384,7 +384,6 @@ void _screen_header()
     if (!disp)
         return;
 
-
     // Message count
     //snprintf(buffer, sizeof(buffer), "#%03d", ttn_get_count() % 1000);
     //display->setTextAlignment(TEXT_ALIGN_LEFT);
@@ -402,7 +401,7 @@ void _screen_header()
 }
 #endif
 
-Screen::Screen(uint8_t address, uint8_t sda, uint8_t scl) : cmdQueue(32), dispdev(address, sda, scl), ui(&dispdev) {}
+Screen::Screen(uint8_t address, int sda, int scl) : cmdQueue(32), dispdev(address, sda, scl), ui(&dispdev) {}
 
 void Screen::handleSetOn(bool on)
 {
@@ -423,6 +422,8 @@ void Screen::handleSetOn(bool on)
 
 void Screen::setup()
 {
+    PeriodicTask::setup();
+
     // We don't set useDisplay until setup() is called, because some boards have a declaration of this object but the device
     // is never found when probing i2c and therefore we don't call setup and never want to do (invalid) accesses to this device.
     useDisplay = true;
@@ -593,7 +594,7 @@ void Screen::handleStartBluetoothPinScreen(uint32_t pin)
 
     static FrameCallback btFrames[] = {drawFrameBluetooth};
 
-    snprintf(btPIN, sizeof(btPIN), "%06d", pin);
+    snprintf(btPIN, sizeof(btPIN), "%06lu", pin);
 
     ui.disableAllIndicators();
     ui.setFrames(btFrames, 1);

src/screen.h

@@ -89,7 +89,7 @@ class DebugInfo
 class Screen : public PeriodicTask
 {
   public:
-    Screen(uint8_t address, uint8_t sda, uint8_t scl);
+    Screen(uint8_t address, int sda = -1, int scl = -1);
 
     Screen(const Screen &) = delete;
     Screen &operator=(const Screen &) = delete;

src/sleep.cpp

@@ -3,7 +3,6 @@
 #include "MeshRadio.h"
 #include "MeshService.h"
 #include "NodeDB.h"
-#include "Periodic.h"
 #include "configuration.h"
 #include "error.h"
 
@@ -135,7 +134,7 @@ static void waitEnterSleep()
 
     uint32_t now = millis();
     while (!doPreflightSleep()) {
-        delay(10); // Kinda yucky - wait until radio says say we can shutdown (finished in process sends/receives)
+        delay(100); // Kinda yucky - wait until radio says say we can shutdown (finished in process sends/receives)
 
         if (millis() - now > 30 * 1000) { // If we wait too long just report an error and go to sleep
             recordCriticalError(ErrSleepEnterWait);

variants/pca10056-rc-clock/variant.cpp

@@ -0,0 +1,49 @@
+/*
+  Copyright (c) 2014-2015 Arduino LLC.  All right reserved.
+  Copyright (c) 2016 Sandeep Mistry All right reserved.
+  Copyright (c) 2018, Adafruit Industries (adafruit.com)
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "variant.h"
+#include "wiring_constants.h"
+#include "wiring_digital.h"
+#include "nrf.h"
+
+const uint32_t g_ADigitalPinMap[] =
+{
+  // P0
+  0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 ,
+  8 , 9 , 10, 11, 12, 13, 14, 15,
+  16, 17, 18, 19, 20, 21, 22, 23,
+  24, 25, 26, 27, 28, 29, 30, 31,
+
+  // P1
+  32, 33, 34, 35, 36, 37, 38, 39,
+  40, 41, 42, 43, 44, 45, 46, 47
+};
+
+
+void initVariant()
+{
+  // LED1 & LED2
+  pinMode(PIN_LED1, OUTPUT);
+  ledOff(PIN_LED1);
+
+  pinMode(PIN_LED2, OUTPUT);
+  ledOff(PIN_LED2);;
+}
+

variants/pca10056-rc-clock/variant.h

@@ -0,0 +1,150 @@
+/*
+ Copyright (c) 2014-2015 Arduino LLC.  All right reserved.
+ Copyright (c) 2016 Sandeep Mistry All right reserved.
+ Copyright (c) 2018, Adafruit Industries (adafruit.com)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU Lesser General Public License for more details.
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef _VARIANT_PCA10056_
+#define _VARIANT_PCA10056_
+
+/** Master clock frequency */
+#define VARIANT_MCK (64000000ul)
+
+// This file is the same as the standard pac10056 variant, except that @geeksville broke the xtal on his devboard so
+// he has to use a RC clock.
+
+// #define USE_LFXO // Board uses 32khz crystal for LF
+#define USE_LFRC // Board uses RC for LF
+
+/*----------------------------------------------------------------------------
+ *        Headers
+ *----------------------------------------------------------------------------*/
+
+#include "WVariant.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// Number of pins defined in PinDescription array
+#define PINS_COUNT (48)
+#define NUM_DIGITAL_PINS (48)
+#define NUM_ANALOG_INPUTS (6)
+#define NUM_ANALOG_OUTPUTS (0)
+
+// LEDs
+#define PIN_LED1 (13)
+#define PIN_LED2 (14)
+
+#define LED_BUILTIN PIN_LED1
+#define LED_CONN PIN_LED2
+
+#define LED_RED PIN_LED1
+#define LED_BLUE PIN_LED2
+
+#define LED_STATE_ON 0 // State when LED is litted
+
+/*
+ * Buttons
+ */
+#define PIN_BUTTON1 11
+#define PIN_BUTTON2 12
+#define PIN_BUTTON3 24
+#define PIN_BUTTON4 25
+
+/*
+ * Analog pins
+ */
+#define PIN_A0 (3)
+#define PIN_A1 (4)
+#define PIN_A2 (28)
+#define PIN_A3 (29)
+#define PIN_A4 (30)
+#define PIN_A5 (31)
+#define PIN_A6 (0xff)
+#define PIN_A7 (0xff)
+
+static const uint8_t A0 = PIN_A0;
+static const uint8_t A1 = PIN_A1;
+static const uint8_t A2 = PIN_A2;
+static const uint8_t A3 = PIN_A3;
+static const uint8_t A4 = PIN_A4;
+static const uint8_t A5 = PIN_A5;
+static const uint8_t A6 = PIN_A6;
+static const uint8_t A7 = PIN_A7;
+#define ADC_RESOLUTION 14
+
+// Other pins
+#define PIN_AREF (2)
+#define PIN_NFC1 (9)
+#define PIN_NFC2 (10)
+
+static const uint8_t AREF = PIN_AREF;
+
+/*
+ * Serial interfaces
+ */
+
+// Arduino Header D0, D1
+#define PIN_SERIAL1_RX (33) // P1.01
+#define PIN_SERIAL1_TX (34) // P1.02
+
+// Connected to Jlink CDC
+#define PIN_SERIAL2_RX (8)
+#define PIN_SERIAL2_TX (6)
+
+/*
+ * SPI Interfaces
+ */
+#define SPI_INTERFACES_COUNT 1
+
+#define PIN_SPI_MISO (46)
+#define PIN_SPI_MOSI (45)
+#define PIN_SPI_SCK (47)
+
+static const uint8_t SS = 44;
+static const uint8_t MOSI = PIN_SPI_MOSI;
+static const uint8_t MISO = PIN_SPI_MISO;
+static const uint8_t SCK = PIN_SPI_SCK;
+
+/*
+ * Wire Interfaces
+ */
+#define WIRE_INTERFACES_COUNT 1
+
+#define PIN_WIRE_SDA (26)
+#define PIN_WIRE_SCL (27)
+
+// QSPI Pins
+#define PIN_QSPI_SCK 19
+#define PIN_QSPI_CS 17
+#define PIN_QSPI_IO0 20
+#define PIN_QSPI_IO1 21
+#define PIN_QSPI_IO2 22
+#define PIN_QSPI_IO3 23
+
+// On-board QSPI Flash
+#define EXTERNAL_FLASH_DEVICES MX25R6435F
+#define EXTERNAL_FLASH_USE_QSPI
+
+#ifdef __cplusplus
+}
+#endif
+
+/*----------------------------------------------------------------------------
+ *        Arduino objects - C++ only
+ *----------------------------------------------------------------------------*/
+
+#endif

variants/ppr/variant.cpp

@@ -0,0 +1,49 @@
+/*
+  Copyright (c) 2014-2015 Arduino LLC.  All right reserved.
+  Copyright (c) 2016 Sandeep Mistry All right reserved.
+  Copyright (c) 2018, Adafruit Industries (adafruit.com)
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include "variant.h"
+#include "wiring_constants.h"
+#include "wiring_digital.h"
+#include "nrf.h"
+
+const uint32_t g_ADigitalPinMap[] =
+{
+  // P0
+  0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 ,
+  8 , 9 , 10, 11, 12, 13, 14, 15,
+  16, 17, 18, 19, 20, 21, 22, 23,
+  24, 25, 26, 27, 28, 29, 30, 31,
+
+  // P1
+  32, 33, 34, 35, 36, 37, 38, 39,
+  40, 41, 42, 43, 44, 45, 46, 47
+};
+
+
+void initVariant()
+{
+  // LED1 & LED2
+  pinMode(PIN_LED1, OUTPUT);
+  ledOff(PIN_LED1);
+
+  pinMode(PIN_LED2, OUTPUT);
+  ledOff(PIN_LED2);;
+}
+

variants/ppr/variant.h

@@ -0,0 +1,138 @@
+/*
+ Copyright (c) 2014-2015 Arduino LLC.  All right reserved.
+ Copyright (c) 2016 Sandeep Mistry All right reserved.
+ Copyright (c) 2018, Adafruit Industries (adafruit.com)
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the GNU Lesser General Public License for more details.
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef _VARIANT_PCA10056_
+#define _VARIANT_PCA10056_
+
+/** Master clock frequency */
+#define VARIANT_MCK (64000000ul)
+
+// This file is the same as the standard pac10056 variant, except that @geeksville broke the xtal on his devboard so
+// he has to use a RC clock.
+
+// #define USE_LFXO // Board uses 32khz crystal for LF
+#define USE_LFRC // Board uses RC for LF
+
+/*----------------------------------------------------------------------------
+ *        Headers
+ *----------------------------------------------------------------------------*/
+
+#include "WVariant.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// Number of pins defined in PinDescription array
+#define PINS_COUNT (48)
+#define NUM_DIGITAL_PINS (48)
+#define NUM_ANALOG_INPUTS (6)
+#define NUM_ANALOG_OUTPUTS (0)
+
+// LEDs
+#define PIN_LED1 (13)
+#define PIN_LED2 (14)
+
+#define LED_BUILTIN PIN_LED1
+#define LED_CONN PIN_LED2
+
+#define LED_RED PIN_LED1
+#define LED_BLUE PIN_LED2
+
+#define LED_STATE_ON 0 // State when LED is litted
+
+/*
+ * Buttons
+ */
+#define PIN_BUTTON1 11
+#define PIN_BUTTON2 12
+#define PIN_BUTTON3 24
+#define PIN_BUTTON4 25
+
+/*
+ * Analog pins
+ */
+#define PIN_A0 (3)
+#define PIN_A1 (4)
+#define PIN_A2 (28)
+#define PIN_A3 (29)
+#define PIN_A4 (30)
+#define PIN_A5 (31)
+#define PIN_A6 (0xff)
+#define PIN_A7 (0xff)
+
+static const uint8_t A0 = PIN_A0;
+static const uint8_t A1 = PIN_A1;
+static const uint8_t A2 = PIN_A2;
+static const uint8_t A3 = PIN_A3;
+static const uint8_t A4 = PIN_A4;
+static const uint8_t A5 = PIN_A5;
+static const uint8_t A6 = PIN_A6;
+static const uint8_t A7 = PIN_A7;
+#define ADC_RESOLUTION 14
+
+// Other pins
+#define PIN_AREF (2)
+#define PIN_NFC1 (9)
+#define PIN_NFC2 (10)
+
+static const uint8_t AREF = PIN_AREF;
+
+/*
+ * Serial interfaces
+ */
+
+// Arduino Header D0, D1
+#define PIN_SERIAL1_RX (33) // P1.01
+#define PIN_SERIAL1_TX (34) // P1.02
+
+// Connected to Jlink CDC
+#define PIN_SERIAL2_RX (8)
+#define PIN_SERIAL2_TX (6)
+
+/*
+ * SPI Interfaces
+ */
+#define SPI_INTERFACES_COUNT 1
+
+#define PIN_SPI_MISO (46)
+#define PIN_SPI_MOSI (45)
+#define PIN_SPI_SCK (47)
+
+static const uint8_t SS = 44;
+static const uint8_t MOSI = PIN_SPI_MOSI;
+static const uint8_t MISO = PIN_SPI_MISO;
+static const uint8_t SCK = PIN_SPI_SCK;
+
+/*
+ * Wire Interfaces
+ */
+#define WIRE_INTERFACES_COUNT 1
+
+#define PIN_WIRE_SDA (26)
+#define PIN_WIRE_SCL (27)
+
+#ifdef __cplusplus
+}
+#endif
+
+/*----------------------------------------------------------------------------
+ *        Arduino objects - C++ only
+ *----------------------------------------------------------------------------*/
+
+#endif