Merge branch 'dev'

set repeater/room server Lat & Lon to 0.0 as default

README.md

@@ -55,6 +55,11 @@ MeshCore is designed for use with:
 ## 📜 License
 MeshCore is open-source software released under the MIT License. You are free to use, modify, and distribute it for personal and commercial projects.
 
+## Contributing
+
+Please submit PR's using 'dev' as the base branch!
+For minor changes just submit your PR and I'll try to review it, but for anything more 'impactful' please open an Issue first and start a discussion. Is better to sound out what it is you want to achieve first, and try to come to a consensus on what the best approach is, especially when it impacts the structure or architecture of this codebase.
+
 ## 📞 Get Support
 
 Check out the GitHub Issues page to report bugs or request features.

arch/esp32/AsyncElegantOTA/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Ayush Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

arch/esp32/AsyncElegantOTA/keywords.txt

@@ -0,0 +1,2 @@
+AsyncElegantOTA	KEYWORD1
+begin	KEYWORD2

arch/esp32/AsyncElegantOTA/library.properties

@@ -0,0 +1,9 @@
+name=AsyncElegantOTA
+version=2.2.8
+author=Ayush Sharma
+category=Communication
+maintainer=Ayush Sharma <asrocks5@gmail.com>
+sentence=Perform OTAs for ESP8266 & ESP32 Asynchronously.
+paragraph=A User Interface Library which provides interactive elements for your Over the Air Updates on ESP8266/ESP32.
+url=https://github.com/ayushsharma82/AsyncElegantOTA
+architectures=esp8266,esp32

arch/esp32/AsyncElegantOTA/src/AsyncElegantOTA.cpp

@@ -0,0 +1,129 @@
+#include <AsyncElegantOTA.h>
+
+AsyncElegantOtaClass AsyncElegantOTA;
+
+void AsyncElegantOtaClass::setID(const char* id){
+    _id = id;
+}
+
+void AsyncElegantOtaClass::begin(AsyncWebServer *server, const char* username, const char* password){
+    _server = server;
+
+    if(strlen(username) > 0){
+        _authRequired = true;
+        _username = username;
+        _password = password;
+    }else{
+        _authRequired = false;
+        _username = "";
+        _password = "";
+    }
+
+    _server->on("/update/identity", HTTP_GET, [&](AsyncWebServerRequest *request){
+        if(_authRequired){
+            if(!request->authenticate(_username.c_str(), _password.c_str())){
+                return request->requestAuthentication();
+            }
+        }
+        #if defined(ESP8266)
+            request->send(200, "application/json", "{\"id\": \""+_id+"\", \"hardware\": \"ESP8266\"}");
+        #elif defined(ESP32)
+            request->send(200, "application/json", "{\"id\": \""+_id+"\", \"hardware\": \"ESP32\"}");
+        #endif
+    });
+
+    _server->on("/update", HTTP_GET, [&](AsyncWebServerRequest *request){
+        if(_authRequired){
+            if(!request->authenticate(_username.c_str(), _password.c_str())){
+                return request->requestAuthentication();
+            }
+        }
+        AsyncWebServerResponse *response = request->beginResponse_P(200, "text/html", ELEGANT_HTML, ELEGANT_HTML_SIZE);
+        response->addHeader("Content-Encoding", "gzip");
+        request->send(response);
+    });
+
+    _server->on("/update", HTTP_POST, [&](AsyncWebServerRequest *request) {
+        if(_authRequired){
+            if(!request->authenticate(_username.c_str(), _password.c_str())){
+                return request->requestAuthentication();
+            }
+        }
+        // the request handler is triggered after the upload has finished... 
+        // create the response, add header, and send response
+        AsyncWebServerResponse *response = request->beginResponse((Update.hasError())?500:200, "text/plain", (Update.hasError())?"FAIL":"OK");
+        response->addHeader("Connection", "close");
+        response->addHeader("Access-Control-Allow-Origin", "*");
+        request->send(response);
+        restart();
+    }, [&](AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final) {
+        //Upload handler chunks in data
+        if(_authRequired){
+            if(!request->authenticate(_username.c_str(), _password.c_str())){
+                return request->requestAuthentication();
+            }
+        }
+
+        if (!index) {
+            if(!request->hasParam("MD5", true)) {
+                return request->send(400, "text/plain", "MD5 parameter missing");
+            }
+
+            if(!Update.setMD5(request->getParam("MD5", true)->value().c_str())) {
+                return request->send(400, "text/plain", "MD5 parameter invalid");
+            }
+
+            #if defined(ESP8266)
+                int cmd = (filename == "filesystem") ? U_FS : U_FLASH;
+                Update.runAsync(true);
+                size_t fsSize = ((size_t) &_FS_end - (size_t) &_FS_start);
+                uint32_t maxSketchSpace = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
+                if (!Update.begin((cmd == U_FS)?fsSize:maxSketchSpace, cmd)){ // Start with max available size
+            #elif defined(ESP32)
+                int cmd = (filename == "filesystem") ? U_SPIFFS : U_FLASH;
+                if (!Update.begin(UPDATE_SIZE_UNKNOWN, cmd)) { // Start with max available size
+            #endif
+                Update.printError(Serial);
+                return request->send(400, "text/plain", "OTA could not begin");
+            }
+        }
+
+        // Write chunked data to the free sketch space
+        if(len){
+            if (Update.write(data, len) != len) {
+                return request->send(400, "text/plain", "OTA could not begin");
+            }
+        }
+            
+        if (final) { // if the final flag is set then this is the last frame of data
+            if (!Update.end(true)) { //true to set the size to the current progress
+                Update.printError(Serial);
+                return request->send(400, "text/plain", "Could not end OTA");
+            }
+        }else{
+            return;
+        }
+    });
+}
+
+// deprecated, keeping for backward compatibility
+void AsyncElegantOtaClass::loop() {
+}
+
+void AsyncElegantOtaClass::restart() {
+    yield();
+    delay(1000);
+    yield();
+    ESP.restart();
+}
+
+String AsyncElegantOtaClass::getID(){
+    String id = "";
+    #if defined(ESP8266)
+        id = String(ESP.getChipId());
+    #elif defined(ESP32)
+        id = String((uint32_t)ESP.getEfuseMac(), HEX);
+    #endif
+    id.toUpperCase();
+    return id;
+}

arch/esp32/AsyncElegantOTA/src/AsyncElegantOTA.h

@@ -0,0 +1,52 @@
+#ifndef AsyncElegantOTA_h
+#define AsyncElegantOTA_h
+
+#warning AsyncElegantOTA library is deprecated, Please consider moving to newer ElegantOTA library which now comes with an Async Mode. Learn More: https://docs.elegantota.pro/async-mode/ 
+
+#include "Arduino.h"
+#include "stdlib_noniso.h"
+
+#if defined(ESP8266)
+    #include "ESP8266WiFi.h"
+    #include "ESPAsyncTCP.h"
+    #include "flash_hal.h"
+    #include "FS.h"
+#elif defined(ESP32)
+    #include "WiFi.h"
+    #include "AsyncTCP.h"
+    #include "Update.h"
+    #include "esp_int_wdt.h"
+    #include "esp_task_wdt.h"
+#endif
+
+#include "Hash.h"
+#include "ESPAsyncWebServer.h"
+#include "FS.h"
+
+#include "elegantWebpage.h"
+
+
+class AsyncElegantOtaClass{
+
+    public:
+        void
+            setID(const char* id),
+            begin(AsyncWebServer *server, const char* username = "", const char* password = ""),
+            loop(),
+            restart();
+
+    private:
+        AsyncWebServer *_server;
+
+        String getID();
+
+        String _id = getID();
+        String _username = "";
+        String _password = "";
+        bool _authRequired = false;
+
+};
+
+extern AsyncElegantOtaClass AsyncElegantOTA;
+
+#endif

arch/esp32/AsyncElegantOTA/src/Hash.h

@@ -0,0 +1,38 @@
+/**
+ * @file Hash.h
+ * @date 20.05.2015
+ * @author Markus Sattler
+ *
+ * Copyright (c) 2015 Markus Sattler. All rights reserved.
+ * This file is part of the esp8266 core for Arduino environment.
+ *
+ * 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 HASH_H_
+#define HASH_H_
+
+//#define DEBUG_SHA1
+
+void sha1(const uint8_t* data, uint32_t size, uint8_t hash[20]);
+void sha1(const char* data, uint32_t size, uint8_t hash[20]);
+void sha1(const String& data, uint8_t hash[20]);
+
+String sha1(const uint8_t* data, uint32_t size);
+String sha1(const char* data, uint32_t size);
+String sha1(const String& data);
+
+#endif /* HASH_H_ */

boards/promicro_nrf52840.json

@@ -0,0 +1,78 @@
+{
+    "build": {
+      "arduino":{
+        "ldscript": "nrf52840_s140_v6.ld"
+      },
+      "core": "nRF5",
+      "cpu": "cortex-m4",
+      "extra_flags": "-DARDUINO_NRF52840_FEATHER -DNRF52840_XXAA",
+      "f_cpu": "64000000L",
+      "hwids": [
+        [ 
+          "0x239A",
+          "0x00B3"
+        ],
+        [
+          "0x239A",
+          "0x8029"
+        ],
+        [
+          "0x239A",
+          "0x0029"
+        ],
+        [
+          "0x239A",
+          "0x002A"
+        ],
+        [
+          "0x239A",
+          "0x802A"
+        ]
+      ],
+      "usb_product": "ProMicro NRF52840",
+      "mcu": "nrf52840",
+      "variant": "promicro_nrf52840",
+      "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",
+      "svd_path": "nrf52840.svd"
+    },
+    "frameworks": [
+      "arduino",
+      "zephyr"
+    ],
+    "name": "ProMicro NRF52840",
+    "upload": {
+      "maximum_ram_size": 248832,
+      "maximum_size": 815104,
+      "speed": 115200,
+      "protocol": "nrfutil",
+      "protocols": [
+        "jlink",
+        "nrfjprog",
+        "nrfutil",
+        "stlink"
+      ],
+      "use_1200bps_touch": true,
+      "require_upload_port": true,
+      "wait_for_upload_port": true
+    },
+    "url": "https://www.nologo.tech/en/product/otherboard/NRF52840.html",
+    "vendor": "Nologo"
+  }

boards/t-echo.json

@@ -1,62 +1,62 @@
 {
-	"build": {
-	  "arduino": {
-		"ldscript": "nrf52840_s140_v6.ld"
-	  },
-	  "core": "nRF5",
-	  "cpu": "cortex-m4",
-	  "extra_flags": "-DARDUINO_NRF52840_PCA10056 -DNRF52840_XXAA",
-	  "f_cpu": "64000000L",
-	  "hwids": [
-		[
-		  "0x239A",
-		  "0x8029"
-		]
-	  ],
-	  "usb_product": "NRF52 DK",
-	  "mcu": "nrf52840",
-	  "variant": "pca10056",
-	  "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": "LilyGo T-ECHO",
-	"upload": {
-	  "maximum_ram_size": 248832,
-	  "maximum_size": 815104,
-	  "require_upload_port": true,
-	  "speed": 115200,
-	  "protocol": "jlink",
-	  "protocols": [
-		"jlink",
-		"nrfjprog",
-		"stlink",
-		"cmsis-dap",
-		"blackmagic"
-	  ]
-	},
-	"url": "https://os.mbed.com/platforms/Nordic-nRF52840-DK/",
-	"vendor": "Nordic"
+  "build": {
+    "arduino": {
+    "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_PCA10056 -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [
+    [
+      "0x239A",
+      "0x8029"
+    ]
+    ],
+    "usb_product": "NRF52 DK",
+    "mcu": "nrf52840",
+    "variant": "pca10056",
+    "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": "LilyGo T-ECHO",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "require_upload_port": true,
+    "speed": 115200,
+    "protocol": "jlink",
+    "protocols": [
+    "jlink",
+    "nrfjprog",
+    "stlink",
+    "cmsis-dap",
+    "blackmagic"
+    ]
+  },
+  "url": "https://os.mbed.com/platforms/Nordic-nRF52840-DK/",
+  "vendor": "Nordic"
   }

boards/t3_s3_v1_x.json

@@ -1,45 +1,45 @@
 {
-    "build": {
-        "arduino": {
-            "ldscript": "esp32s3_out.ld",
-            "partitions": "default.csv",
-            "memory_type": "qio_qspi"
-        },
-        "core": "esp32",
-        "extra_flags": [
-            "-DARDUINO_LILYGO_T3_S3_V1_X",
-            "-DBOARD_HAS_PSRAM",
-            "-DARDUINO_USB_CDC_ON_BOOT=1",
-            "-DARDUINO_RUNNING_CORE=1",
-            "-DARDUINO_EVENT_RUNNING_CORE=1",
-            "-DARDUINO_USB_MODE=1"
-        ],
-        "f_cpu": "240000000L",
-        "f_flash": "80000000L",
-        "flash_mode": "qio",
-        "mcu": "esp32s3",
-        "variant": "esp32s3"
+  "build": {
+    "arduino": {
+      "ldscript": "esp32s3_out.ld",
+      "partitions": "default.csv",
+      "memory_type": "qio_qspi"
     },
-    "connectivity": [
-        "wifi"
+    "core": "esp32",
+    "extra_flags": [
+      "-DARDUINO_LILYGO_T3_S3_V1_X",
+      "-DBOARD_HAS_PSRAM",
+      "-DARDUINO_USB_CDC_ON_BOOT=1",
+      "-DARDUINO_RUNNING_CORE=1",
+      "-DARDUINO_EVENT_RUNNING_CORE=1",
+      "-DARDUINO_USB_MODE=1"
     ],
-    "debug": {
-        "openocd_target": "esp32s3.cfg"
-    },
-    "frameworks": [
-        "arduino",
-        "espidf"
-    ],
-    "name": "LilyGo T3-S3 Radio",
-    "upload": {
-        "flash_size": "4MB",
-        "maximum_ram_size": 327680,
-        "maximum_size": 4194304,
-        "use_1200bps_touch": true,
-        "wait_for_upload_port": true,
-        "require_upload_port": true,
-        "speed": 460800
-    },
-    "url": "https://www.lilygo.cc",
-    "vendor": "LilyGo"
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "mcu": "esp32s3",
+    "variant": "esp32s3"
+  },
+  "connectivity": [
+    "wifi"
+  ],
+  "debug": {
+    "openocd_target": "esp32s3.cfg"
+  },
+  "frameworks": [
+    "arduino",
+    "espidf"
+  ],
+  "name": "LilyGo T3-S3 Radio",
+  "upload": {
+    "flash_size": "4MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 4194304,
+    "use_1200bps_touch": true,
+    "wait_for_upload_port": true,
+    "require_upload_port": true,
+    "speed": 460800
+  },
+  "url": "https://www.lilygo.cc",
+  "vendor": "LilyGo"
 }

build.sh

@@ -58,7 +58,7 @@ build_firmware() {
   fi
 
   # build .uf2 for nrf52 boards
-  if [[ $1 == *"RAK_4631"* || $1 == *"t1000e"* || $1 == *"t114"* || $1 == *"T-Echo"* ]]; then
+  if [[ $1 == *"RAK_4631"* || $1 == *"t1000e"* || $1 == *"t114"* || $1 == *"T-Echo"* || $1 == *"Faketec"* || $1 == *"ProMicro"* ]]; then
     python bin/uf2conv/uf2conv.py .pio/build/$1/firmware.hex -c -o .pio/build/$1/firmware.uf2 -f 0xADA52840
   fi
 

docs/faq.md

@@ -1,10 +1,75 @@
-# MeshCore-FAQ
+**MeshCore-FAQ**<!-- omit from toc -->
 A list of frequently-asked questions and answers for MeshCore
 
-author: https://github.com/LitBomb
+The current version of this MeshCore FAQ is at https://github.com/ripplebiz/MeshCore/blob/main/docs/faq.md.  
+This MeshCore FAQ is also mirrored at https://github.com/LitBomb/MeshCore-FAQ and might have newer updates if pull requests on Scott's MeshCore repo are not approved yet.
+
+author: https://github.com/LitBomb<!-- omit from toc -->
 ---
 
-## Q: What is MeshCore?
+- [1. Introduction](#1-introduction)
+  - [1.1. Q: What is MeshCore?](#11-q-what-is-meshcore)
+  - [1.2. Q: What do you need to start using MeshCore?](#12-q-what-do-you-need-to-start-using-meshcore)
+    - [1.2.1. Hardware](#121-hardware)
+    - [1.2.2. Firmware](#122-firmware)
+    - [1.2.3. Companion Radio Firmware](#123-companion-radio-firmware)
+    - [1.2.4. Repeater](#124-repeater)
+    - [1.2.5. Room Server](#125-room-server)
+- [2. Initial Setup](#2-initial-setup)
+  - [2.1. Q: How many devices do I need to start using meshcore?](#21-q-how-many-devices-do-i-need-to-start-using-meshcore)
+  - [2.2. Q: Does MeshCore cost any money?](#22-q-does-meshcore-cost-any-money)
+  - [2.3. Q: What frequencies are supported by MeshCore?](#23-q-what-frequencies-are-supported-by-meshcore)
+  - [2.4. Q: What is an "advert" in MeshCore?](#24-q-what-is-an-advert-in-meshcore)
+  - [2.5. Q: Is there a hop limit?](#25-q-is-there-a-hop-limit)
+- [3. Server Administration](#3-server-administration)
+  - [3.1. Q: How do you configure a repeater or a room server?](#31-q-how-do-you-configure-a-repeater-or-a-room-server)
+  - [3.2. Q: Do I need to set the location for a repeater?](#32-q-do-i-need-to-set-the-location-for-a-repeater)
+  - [3.3. Q: What is the password to administer a repeater or a room server?](#33-q-what-is-the-password-to-administer-a-repeater-or-a-room-server)
+  - [3.4. Q: What is the password to join a room server?](#34-q-what-is-the-password-to-join-a-room-server)
+- [4. T-Deck Related](#4-t-deck-related)
+  - [4.1. Q: What are the steps to get a T-Deck into DFU (Device Firmware Update) mode?](#41-q-what-are-the-steps-to-get-a-t-deck-into-dfu-device-firmware-update-mode)
+  - [4.2. Q: Why is my T-Deck Plus not getting any satellite lock?](#42-q-why-is-my-t-deck-plus-not-getting-any-satellite-lock)
+  - [4.3. Q: Why is my OG (non-Plus) T-Deck not getting any satellite lock?](#43-q-why-is-my-og-non-plus-t-deck-not-getting-any-satellite-lock)
+  - [4.4. Q: What size of SD card does the T-Deck support?](#44-q-what-size-of-sd-card-does-the-t-deck-support)
+  - [4.5. Q: How do I get maps on T-Deck?](#45-q-how-do-i-get-maps-on-t-deck)
+  - [4.6. Q: Where do the map tiles go?](#46-q-where-do-the-map-tiles-go)
+  - [4.7. Q: How to unlock deeper map zoom and server management features on T-Deck?](#47-q-how-to-unlock-deeper-map-zoom-and-server-management-features-on-t-deck)
+  - [4.8. Q: How to decipher the diagnostics screen on T-Deck?](#48-q-how-to-decipher-the-diagnostics-screen-on-t-deck)
+  - [4.9. Q: The T-Deck sound is too loud?](#49-q-the-t-deck-sound-is-too-loud)
+  - [4.10. Q: Can you customize the sound?](#410-q-can-you-customize-the-sound)
+  - [4.11. Q: What is the 'Import from Clipboard' feature on the t-deck and is there a way to manually add nodes without having to receive adverts?](#411-q-what-is-the-import-from-clipboard-feature-on-the-t-deck-and-is-there-a-way-to-manually-add-nodes-without-having-to-receive-adverts)
+- [5. General](#5-general)
+  - [5.1. Q: What are BW, SF, and CR?](#51-q-what-are-bw-sf-and-cr)
+  - [5.2. Q: Do MeshCore clients repeat?](#52-q-do-meshcore-clients-repeat)
+  - [5.3. Q: What happens when a node learns a route via a mobile repeater, and that repeater is gone?](#53-q-what-happens-when-a-node-learns-a-route-via-a-mobile-repeater-and-that-repeater-is-gone)
+  - [5.4. Q: How does a node discovery a path to its destination and then use it to send messages in the future, instead of flooding every message it sends like Meshtastic?](#54-q-how-does-a-node-discovery-a-path-to-its-destination-and-then-use-it-to-send-messages-in-the-future-instead-of-flooding-every-message-it-sends-like-meshtastic)
+  - [5.5. Q: Do public channels always flood? Do private channels always flood?](#55-q-do-public-channels-always-flood-do-private-channels-always-flood)
+  - [5.6. Q: what is the public key for the default public channel?](#56-q-what-is-the-public-key-for-the-default-public-channel)
+  - [5.7. Q: Is MeshCore open source?](#57-q-is-meshcore-open-source)
+  - [5.8. Q: How can I support MeshCore?](#58-q-how-can-i-support-meshcore)
+  - [5.9. Q: How do I build MeshCore firmware from source?](#59-q-how-do-i-build-meshcore-firmware-from-source)
+  - [5.10. Q: Are there other MeshCore related open source projects?](#510-q-are-there-other-meshcore-related-open-source-projects)
+  - [5.11. Q: Does MeshCore support ATAK](#511-q-does-meshcore-support-atak)
+  - [5.12. Q: How do I add a node to the MeshCore Map](#512-q-how-do-i-add-a-node-to-the-meshcore-map)
+  - [5.13. Q: Can I use a Raspberry Pi to update a MeshCore radio?](#513-q-can-i-use-a-raspberry-pi-to-update-a-meshcore-radio)
+  - [5.14. Q: Are there are projects built around MeshCore?](#514-q-are-there-are-projects-built-around-meshcore)
+    - [5.14.1. meshcoremqtt](#5141-meshcoremqtt)
+    - [5.14.2. MeshCore for Home Assistant](#5142-meshcore-for-home-assistant)
+    - [5.14.3. Python MeshCore](#5143-python-meshcore)
+    - [5.14.4. meshcore-cli](#5144-meshcore-cli)
+    - [5.14.5. meshcore.js](#5145-meshcorejs)
+- [6. Troubleshooting](#6-troubleshooting)
+  - [6.1. Q: My client says another client or a repeater or a room server was last seen many, many days ago.](#61-q-my-client-says-another-client-or-a-repeater-or-a-room-server-was-last-seen-many-many-days-ago)
+  - [6.2. Q: A repeater or a client or a room server I expect to see on my discover list (on T-Deck) or contact list (on a smart device client) are not listed.](#62-q-a-repeater-or-a-client-or-a-room-server-i-expect-to-see-on-my-discover-list-on-t-deck-or-contact-list-on-a-smart-device-client-are-not-listed)
+  - [6.3. Q: How to connect to a repeater via BLE (bluetooth)?](#63-q-how-to-connect-to-a-repeater-via-ble-bluetooth)
+  - [6.4. Q: I can't connect via bluetooth, what is the bluetooth pairing code?](#64-q-i-cant-connect-via-bluetooth-what-is-the-bluetooth-pairing-code)
+  - [6.5. Q: My Heltec V3 keeps disconnecting from my smartphone.  It can't hold a solid Bluetooth connection.](#65-q-my-heltec-v3-keeps-disconnecting-from-my-smartphone--it-cant-hold-a-solid-bluetooth-connection)
+- [7. Other Questions:](#7-other-questions)
+  - [7.1. Q: How to  Update repeater and room server firmware over the air?](#71-q-how-to--update-repeater-and-room-server-firmware-over-the-air)
+
+## 1. Introduction
+
+### 1.1. Q: What is MeshCore?
 
 **A:** MeshCore is free and open source
 * MeshCore is the routing and firmware etc, available on GitHub under MIT license
@@ -19,26 +84,27 @@ These features are completely optional and aren't needed for the core messaging
 
 Anyone is able to build anything they like on top of MeshCore without paying anything.
 
-## Q: What do you need to start using MeshCore?
+### 1.2. Q: What do you need to start using MeshCore?
 **A:** Everything you need for MeshCore is available at:
  Main web site: [https://meshcore.co.uk/](https://meshcore.co.uk/)
  Firmware Flasher: https://flasher.meshcore.co.uk/
  Phone Client Applications: https://meshcore.co.uk/apps.html
  MeshCore Fimrware Github: https://github.com/ripplebiz/MeshCore
- 
+
  NOTE: Andy Kirby has a very useful [intro video](https://www.youtube.com/watch?v=t1qne8uJBAc) for beginners.
+ 
 
  You need LoRa hardware devices to run MeshCore firmware as clients or server (repeater and room server).
 
-### Hardware
+#### 1.2.1. Hardware
 To use MeshCore without using a phone as the client interface, you can run MeshCore on a T-Deck or T-Deck Plus. It is a complete off-grid secure communication solution.  
 
 MeshCore is also available on a variety of 868MHz and 915MHz LoRa devices. For example, RAK4631 devices (19003, 19007, 19026), Heltec V3, Xiao S3 WIO, Xiao C3, Heltec T114, Station G2, Seeed Studio T1000-E. More devices will be supported later.
 
-### Firmware
+#### 1.2.2. Firmware
 MeshCore has four firmware types that are not available on other LoRa systems. MeshCore has the following:
 
-#### Companion Radio Firmware
+#### 1.2.3. Companion Radio Firmware
 Companion radios are for connecting to the Android app or web app as a messenger client. There are two different companion radio firmware versions:
 
 1. **BLE Companion**  
@@ -50,12 +116,12 @@ Companion radios are for connecting to the Android app or web app as a messenger
    <https://meshcore.liamcottle.net/#/>  
    <https://client.meshcore.co.uk/tabs/devices>
 
-#### Repeater
+#### 1.2.4. Repeater
 Repeaters are used to extend the range of a MeshCore network. Repeater firmware runs on the same devices that run client firmware. A repeater's job is to forward MeshCore packets to the destination device. It does **not** forward or retransmit every packet it receives, unlike other LoRa mesh systems.  
 
 A repeater can be remotely administered using a T-Deck running the MeshCore firwmware with remote admistration features unlocked, or from a BLE Companion client connected to a smartphone running the MeshCore app.
 
-#### Room Server
+#### 1.2.5. Room Server
 A room server is a simple BBS server for sharing posts. T-Deck devices running MeshCore firmware or a BLE Companion client connected to a smartphone running the MeshCore app can connect to a room server. 
 
 room servers store message history on them, and push the stored messages to users.  Room servers allow roaming users to come back later and retrieve message history.  Contrast to channels, messages are either received  when it's sent, or not received and missed if the a room user is out of range.  You can think  of room servers like email servers where you can come back later and get your emails from your mail server 
@@ -70,18 +136,24 @@ A room server can also take on the repeater role.  To enable repeater role on a
 
 ---
 
-## Initial Setup
+## 2. Initial Setup
 
-### Q: How many devices do I need to start using meshcore?
+### 2.1. Q: How many devices do I need to start using meshcore?
 **A:** If you have one supported device, flash the BLE Companion firmware and use your device as a client.  You can connect to the device using the Android client via bluetooth (iOS client will be available later).  You can start communiating with other MeshCore users near you.
 
 If you have two supported devices, and there are not many MeshCore users near you, flash both of them to BLE Companion firmware so you can use your devices to communiate with your near-by friends and family.
 
 If you have two supported devices, and there are other MeshcCore users near by, you can flash one of your devices with BLE Companion firmware, and flash another supported device to repeater firmware.  Place the repeater high above ground o extend your MeshCore network's reach.
 
+After you flashed the latest firmware onto your repeater device, keep the device connected to your computer via USB serial, use the console feature on the web flasher and set the frequency for your region or country, so your client can remote administer the rpeater or room server over RF:
+
+`set freq {frequency}`
+
+The repeater and room server CLI reference is here: https://github.com/ripplebiz/MeshCore/wiki/Repeater-&-Room-Server-CLI-Reference
+
 If you have more supported devices, you can use your additional deivces with the room server firmware.  
 
-### Q: Does MeshCore cost any money?
+### 2.2. Q: Does MeshCore cost any money?
 
 **A:** All radio firmware versions (e.g. for Heltec V3, RAK, T-1000E, etc) are free and open source developed by Scott at Ripple Radios.  
 
@@ -90,19 +162,23 @@ The native Android and iOS client uses the freemium model and is developed by Li
 The T-Deck firmware is free to download and most features are available without cost.  To support the firmware developer, you can pay for a registration key to unlock your T-Deck for deeper map zoom and remote server administration over RF using the T-Deck.  You do not need to pay for the registration to use your T-Deck for direct messaging and connecting to repeaters and room servers. 
 
 
-### Q: What frequencies are supported by MeshCore?
+### 2.3. Q: What frequencies are supported by MeshCore?
 **A:** It supports the 868MHz range in the UK/EU and the 915MHz range in New Zealand, Australia, and the USA. Countries and regions in these two frequency ranges are also supported. The firmware and client allow users to set their preferred frequency.  
-- Australia and New Zealand are using **915.8MHz**
-- UK and EU are gravitating toward **867.5MHz**
-- There are discussions on discord for UK to move to 869.525MHz (https://discord.com/channels/826570251612323860/1330643963501351004/1342554454498742374)
-- USA is gravitating toward **910.525MHz**
+- Australia and New Zealand are on **915.8MHz**
+- UK and EU are on **869.525MHz**
+- Canada and USA are on **910.525MHz**
+- For other regions and countries, please check your local LoRa frequency
+
+In UK and EU, 867.5MHz is not allowed to use 250kHz bandwidth and it only allows 2.5% duty cycle for clients.  869.525Mhz allows an airtime of 10%, 250KHz bandwidth, and a higher EIRP, therefore MeshCore nodes can send more often and with more power. That is why this frequency is chosen for UK and EU.  This is also why Meshtastic also uses this frequency.  
+
+[Source]([https://](https://discord.com/channels/826570251612323860/1330643963501351004/1356540643853209641))
 
 the rest of the radio settings are the same for all frequencies:  
 - Spread Factor (SF): 10  
 - Coding Rate (CR): 5  
 - Bandwidth (BW): 250.00  
 
-### Q: What is an "advert" in MeshCore?
+### 2.4. Q: What is an "advert" in MeshCore?
 **A:** 
 Advert means to advertise yourself on the network. In Reticulum terms it would be to announce. In Meshtastic terms it would be the node sending it's node info.
 
@@ -115,7 +191,7 @@ MeshCore clients only advertise themselves when the user initiates it. A repeate
 
 `set advert.interval {minutes}`
 
-### Q: Is there a hop limit?
+### 2.5. Q: Is there a hop limit?
 
 **A:** Internally the firmware has maximum limit of 64 hops.  In real world settings it will be difficult to get close to the limit due to the environments and timing as packets travel further and further.  We want to hear how far your MeshCore conversations go. 
 
@@ -123,30 +199,43 @@ MeshCore clients only advertise themselves when the user initiates it. A repeate
 ---
 
 
-## Server Administration
+## 3. Server Administration
 
-### Q: How do you configure a repeater or a room server?
-**A:** One of these servers can be administered with one of the options below:
-- Connect the server device through a USB serial connection to a computer running Chrome on this site:  
-  <https://googlechromelabs.github.io/serial-terminal/>
-- A T-Deck running unlocked/registered MeshCore firmware. Remote server administration is enabled through registering your T-Deck with Ripple Radios. It is one of the ways to support MeshCore development. You can register your T-Deck at:  
-  <https://buymeacoffee.com/ripplebiz/e/249834>
-- MeshCore smart device clients may have the ability to remotely administer servers in the future.
+### 3.1. Q: How do you configure a repeater or a room server?
 
-### Q: Do I need to set the location for a repeater?
+**A:** - When MeshCore is flashed onto a LoRa device is for the first time, it is necessary to set the server device's frequency to make it utilize the frequency that is legal in your country or region.  
+
+Repeater or room server can be administered with one of the options below:
+  
+- After a repeater or room server firmware is flashed on to a LoRa device, go to <https://config.meshcore.dev> and use the web user interface to connect to the LoRa device via USB serial.  From there you can set the name of the server, its frequency and other related settings, location, passwords etc.
+
+![image](https://github.com/user-attachments/assets/bec28ff3-a7d6-4a1e-8602-cb6b290dd150)
+
+ 
+- Connect the server device using a USB cable to a computer running Chrome on https://flasher.meshcore.co.uk/, then use the `console` feature to connect to the device
+
+- Use a MeshCore smartphone clients  to remotely administer servers via LoRa.
+
+- A T-Deck running unlocked/registered MeshCore firmware. Remote server administration is enabled through registering your T-Deck with Ripple Radios. It is one of the ways to support MeshCore development. You can register your T-Deck at:
+
+<https://buymeacoffee.com/ripplebiz/e/249834>
+
+  
+
+### 3.2. Q: Do I need to set the location for a repeater?
 **A:** With location set for a repeater, it can show up on a MeshCore map in the future. Set location with the following commands:
 
 `set lat <GPS Lat> set long <GPS Lon>`
 
 You can get the latitude and longitude from Google Maps by right-clicking the location you are at on the map.
 
-### Q: What is the password to administer a repeater or a room server?
+### 3.3. Q: What is the password to administer a repeater or a room server?
 **A:** The default admin password to a repeater and room server is `password`. Use the following command to change the admin password:
 
 `password {new-password}`
 
 
-### Q: What is the password to join a room server?
+### 3.4. Q: What is the password to join a room server?
 **A:** The default guest password to a room server is `hello`. Use the following command to change the guest password:
 
 `set guest.password {guest-password}`
@@ -154,9 +243,9 @@ You can get the latitude and longitude from Google Maps by right-clicking the lo
 
 ---
 
-## T-Deck Related
+## 4. T-Deck Related
 
-### Q: What are the steps to get a T-Deck into DFU (Device Firmware Update) mode?
+### 4.1. Q: What are the steps to get a T-Deck into DFU (Device Firmware Update) mode?
 **A:**  
 1. Device off  
 2. Connect USB cable to device  
@@ -167,16 +256,20 @@ You can get the latitude and longitude from Google Maps by right-clicking the lo
 7. T-Deck in DFU mode now  
 8. At this point you can begin flashing using <https://flasher.meshcore.co.uk/>
 
-### Q: Why is my T-Deck Plus not getting any satellite lock?
+### 4.2. Q: Why is my T-Deck Plus not getting any satellite lock?
 **A:** For T-Deck Plus, the GPS baud rate should be set to **38400**. Also, a number of T-Deck Plus devices were found to have the GPS module installed upside down, with the GPS antenna facing down instead of up. If your T-Deck Plus still doesn't get any satellite lock after setting the baud rate to 38400, you might need to open up the device to check the GPS orientation.
 
-### Q: Why is my OG (non-Plus) T-Deck not getting any satellite lock?
+GPS on T-Deck is always enabled.  You can skip the "GPS clock sync" and the T-Deck will continue to try to get a GPS lock.  You can go to the `GPS Info` screen, you should see the `Sentences:` coutner increasing if the baud rate is correct.
+
+[Source]([https://](https://discord.com/channels/826570251612323860/1330643963501351004/1356609240302616689))
+
+### 4.3. Q: Why is my OG (non-Plus) T-Deck not getting any satellite lock?
 **A:** The OG (non-Plus) T-Deck doesn't come with a GPS. If you added a GPS to your OG T-Deck, please refer to the manual of your GPS to see what baud rate it requires. Alternatively, you can try to set the baud rate from 9600, 19200, etc., and up to 115200 to see which one works.
 
-### Q: What size of SD card does the T-Deck support?
+### 4.4. Q: What size of SD card does the T-Deck support?
 **A:** Users have had no issues using 16GB or 32GB SD cards. Format the SD card to **FAT32**.
 
-### Q: How do I get maps on T-Deck?
+### 4.5. Q: How do I get maps on T-Deck?
 **A:** You need map tiles. You can get pre-downloaded map tiles here (a good way to support development):  
 - <https://buymeacoffee.com/ripplebiz/e/342543> (Europe)  
 - <https://buymeacoffee.com/ripplebiz/e/342542> (US)
@@ -190,28 +283,46 @@ There is also a modified script that adds additional error handling and parallel
 UK map tiles are available separately from Andy Kirby on his discord server:  
 <https://discord.com/channels/826570251612323860/1330643963501351004/1331346597367386224>
 
-### Q: Where do the map tiles go?
+### 4.6. Q: Where do the map tiles go?
 Once you have the tiles downloaded, copy the `\tiles` folder to the root of your T-Deck's SD card.
 
-### Q: How to unlock deeper map zoom and server management features on T-Deck?
+### 4.7. Q: How to unlock deeper map zoom and server management features on T-Deck?
 **A:** You can download, install, and use the T-Deck firmware for free, but it has some features (map zoom, server administration) that are enabled if you purchase an unlock code for \$10 per T-Deck device.  
 Unlock page: <https://buymeacoffee.com/ripplebiz/e/249834>
 
+### 4.8. Q: How to decipher the diagnostics screen on T-Deck?
 
-### Q: The T-Deck sound is too loud?
-### Q: Can you customize the sound?
+**A: ** Space is tight on T-Deck's screen so the information is a bit cryptic.  Format is :
+`{hops} l:{packet-length}({payload-len}) t:{packet-type} snr:{n} rssi:{n}`
+
+See here for packet-type: [https://github.com/ripplebiz/MeshCore/blob/main/src/Packet.h#L19](https://github.com/ripplebiz/MeshCore/blob/main/src/Packet.h#L19 "https://github.com/ripplebiz/MeshCore/blob/main/src/Packet.h#L19")
+ 
+
+    #define PAYLOAD_TYPE_REQ 0x00 // request (prefixed with dest/src hashes, MAC) (enc data: timestamp, blob) 
+    #define PAYLOAD_TYPE_RESPONSE 0x01 // response to REQ or ANON_REQ (prefixed with dest/src hashes, MAC) (enc data: timestamp, blob) 
+    #define PAYLOAD_TYPE_TXT_MSG 0x02 // a plain text message (prefixed with dest/src hashes, MAC) (enc data: timestamp, text) 
+    #define PAYLOAD_TYPE_ACK 0x03 // a simple ack #define PAYLOAD_TYPE_ADVERT 0x04 // a node advertising its Identity 
+    #define PAYLOAD_TYPE_GRP_TXT 0x05 // an (unverified) group text message (prefixed with channel hash, MAC) (enc data: timestamp, "name: msg") 
+    #define PAYLOAD_TYPE_GRP_DATA 0x06 // an (unverified) group datagram (prefixed with channel hash, MAC) (enc data: timestamp, blob) 
+    #define PAYLOAD_TYPE_ANON_REQ 0x07 // generic request (prefixed with dest_hash, ephemeral pub_key, MAC) (enc data: ...) 
+    #define PAYLOAD_TYPE_PATH 0x08 // returned path (prefixed with dest/src hashes, MAC) (enc data: path, extra)
+
+[Source](https://discord.com/channels/1343693475589263471/1343693475589263474/1350611321040932966)
+
+### 4.9. Q: The T-Deck sound is too loud?
+### 4.10. Q: Can you customize the sound?
 
 **A:** You can customise the sounds on the T-Deck, just by placing `.mp3` files onto the `root` dir of the SD card. `startup.mp3`, `alert.mp3` and `new-advert.mp3`
 
-### Q: What is the 'Import from Clipboard' feature on the t-deck and is there a way to manually add nodes without having to receive adverts?
+### 4.11. Q: What is the 'Import from Clipboard' feature on the t-deck and is there a way to manually add nodes without having to receive adverts?
 
 **A:** 'Import from Clipboard' is for importing a contact via a file named 'clipboard.txt' on the SD card. The opposite, is in the Identity screen, the 'Card to Clipboard' menu, which writes to 'clipboard.txt' so you can share yourself (call these 'biz cards', that start with "meshcore://...")
 
 ---
 
-## General
+## 5. General
 
-### Q: What are BW, SF, and CR?
+### 5.1. Q: What are BW, SF, and CR?
 
 **A:** 
 
@@ -227,55 +338,268 @@ Lowering the spreading factor makes it more difficult for the gateway to receive
 So it's balancing act between speed of the transmission and resistance to noise.
 things network is mainly focused on LoRaWAN, but the LoRa low-level stuff still checks out for any LoRa project
 
-### Q: Is MeshCore open source?
+### 5.2. Q: Do MeshCore clients repeat?
+**A:** No, MeshCore clients do not repeat.  This is the core of MeshCore's messaging-first design.  This is to avoid devices flooding the air ware and create endless collisions so messages sent aren't received.  
+In MeshCore, only repeaters and room server with '`set repeat on` repeat.  
+
+### 5.3. Q: What happens when a node learns a route via a mobile repeater, and that repeater is gone?
+
+**A:** If you used to reach a node through a repeater and the repeater is no longer reachable, the client will send the message using the existing (but now broken) known path, the message will fail after 3 retries, and the app will reset the path and send the message as flood on the last retry by default.  This can be turned off in settings.  If the destination is reachable directly or through another repeater, the new path will be used going forward.  Or you can set the path manually if you know a specific repeater to use to reach that destination.
+
+In the case if users are moving around frequently, and the paths are breaking, they just see the phone client retries and revert to flood to attempt to reestablish a path. 
+
+### 5.4. Q: How does a node discovery a path to its destination and then use it to send messages in the future, instead of flooding every message it sends like Meshtastic?
+
+Routes are stored in sender's contact list.  When you send a message the first time, the message  first gets to your destination by flood routing,  When your destination node gets the message, it  sends back to the sender a delivery report with all repeaters that the original message went through. This delivery report is flood-routed back to you the sender and is a basis for future direct path. when you send the next message, the path will get embedded into the packet and be evaluated by repeaters. if the hop and address of the repeater matches, it will retransmit the message, otherwise it will not retransmit, hence minimizing utilization.
+
+[Source](https://discord.com/channels/826570251612323860/1330643963501351004/1351279141630119996)
+
+### 5.5. Q: Do public channels always flood? Do private channels always flood?
+
+**A:** Yes, group channels are A to B, so there is no defined path.  They have to flood.  Repeaters can however deny flood traffic up to some hop limit, with the `set flood.max` CLI command.  Admistrators of repeaters get to set the rules of their repeaters.
+
+[Source](https://discord.com/channels/1343693475589263471/1343693475589263474/1350023009527664672)
+
+
+### 5.6. Q: what is the public key for the default public channel?
+**A:** The smartphone app key is in hex:
+` 8b3387e9c5cdea6ac9e5edbaa115cd72`
+
+T-Deck uses the same key but in base64 
+`izOH6cXN6mrJ5e26oRXNcg==`
+The third character is the capital letter 'O', not zero `0`
+[Source](https://discord.com/channels/826570251612323860/1330643963501351004/1354194409213792388)
+
+### 5.7. Q: Is MeshCore open source?
 **A:** Most of the firmware is freely available. Everything is open source except the T-Deck firmware and Liam's native mobile apps.  
 - Firmware repo: <https://github.com/ripplebiz/MeshCore>  
 
-### Q: How can I support MeshCore?
-**A:** Provide your honest feedback on GitHub and on AndyKirby's Discord server <http://discord.com/invite/H62Re4DCeD>. Spread the word of MeshCore to your friends and communities; help them get started with MeshCore. Support MeshCore development at <https://buymeacoffee.com/ripplebiz>.
+### 5.8. Q: How can I support MeshCore?
+**A:** Provide your honest feedback on GitHub and on AndyKirby's Discord server <http://discord.com/invite/H62Re4DCeD>. Spread the word of MeshCore to your friends and communities; help them get started with MeshCore. Support Scott's MeshCore development at <https://buymeacoffee.com/ripplebiz>.
 
-### Q: How do I build MeshCore firmware from source?
+Support Liam Cottle's smartphone client development by unlocking the server administration wait gate with in-app purchase
+
+Support Rastislav Vysoky (recrof)'s flasher web site and the map web site development through [PayPal](https://www.paypal.com/donate/?business=DREHF5HM265ES&no_recurring=0&item_name=If+you+enjoy+my+work%2C+you+can+support+me+here%3A&currency_code=EUR) or [Revolut](https://revolut.me/recrof)
+
+### 5.9. Q: How do I build MeshCore firmware from source?
 **A:** See instructions here:  
-<https://discord.com/channels/826570251612323860/1330643963501351004/1342120825251299388>  
+https://discord.com/channels/826570251612323860/1330643963501351004/1341826372120608769
+
+Build instructions for MeshCore:
+
+For Windows, first install WSL and Python+pip via: https://plainenglish.io/blog/setting-up-python-on-windows-subsystem-for-linux-wsl-26510f1b2d80
+
+(Linux, Windows+WSL) In the terminal/shell:
+```
+sudo apt update
+sudo apt install libpython3-dev
+sudo apt install python3-venv
+```
+Mac: python3 should be already installed.
+
+Then it should be the same for all platforms:
+```
+python3 -m venv meshcore
+cd meshcore && source bin/activate
+pip install -U platformio
+git clone https://github.com/ripplebiz/MeshCore.git 
+cd MeshCore
+```
+open platformio.ini and in `[arduino_base]` edit the `LORA_FREQ=867.5`
+save, then run:
+```
+pio run -e RAK_4631_Repeater
+```
+then you'll find `firmware.zip` in `.pio/build/RAK_4631_Repeater`
 
 Andy also has a video on how to build using VS Code:  
 *How to build and flash Meshcore repeater firmware | Heltec V3*  
 <https://www.youtube.com/watch?v=WJvg6dt13hk> *(Link referenced in the Discord post)*
 
-### Q: Are there other MeshCore related open source projects?
+### 5.10. Q: Are there other MeshCore related open source projects?
 
 **A:** [Liam Cottle](https://liamcottle.net)'s MeshCore web client and MeshCore Javascript libary are open source under MIT license.
 
 Web client: https://github.com/liamcottle/meshcore-web
 Javascript: https://github.com/liamcottle/meshcore.js
 
-### Q: Does MeshCore support ATAK
+### 5.11. Q: Does MeshCore support ATAK
 **A:** ATAK is not currently on MeshCore's roadmap.
-    
+
+Meshcore would not be best suited to ATAK  because MeshCore:
+clients do not repeat and therefore you would need a network of repeaters in place
+will not have a stable path where all clients are constantly moving between repeaters
+
+MeshCore clients would need to reset path constantly and flood traffic across the network which could lead to lots of collisions with something as chatty as ATAK. 
+
+This could change in the future if MeshCore develops a client firmware that repeats.
+[Source](https://discord.com/channels/826570251612323860/1330643963501351004/1354780032140054659)
+
+### 5.12. Q: How do I add a node to the [MeshCore Map]([url](https://meshcore.co.uk/map.html))
+**A:** From the smartphone app, connect to a BLE Companion radio
+- To add the BLE Companion radio your smartphone is connected to to the map, tap the `advert` icon, then tap `Advert (To Clipboard)`.  
+- To add a Repeater or Room Server to the map, tap the 3 dots next to the Repeater or Room Server you want to add to the map, then tap `Share (To Clipboard)`.  
+- Go to the [MeshCore Map web site]([url](https://meshcore.co.uk/map.html)), tap the plus sign on the lower right corner and paste in the meshcore://... blob, then tap `Add Node`
+
+### 5.13. Q: Can I use a Raspberry Pi to update a MeshCore radio?
+** A:** Yes.
+You will need to install picocom on the pi.
+`sudo apt install picocom`
+
+Then run the following commands to setup the repeater.
+```
+picocom -b 115200 /dev/ttyUSB0 --imap lfcrlf
+set name your_repeater_name
+time epoch_time
+password your_unique_password
+set advert.interval 240
+advert
+```
+Note: If using a RAK the path will most likely be /dev/ttyACM0
+
+Epoch time comes from https://www.epochconverter.com/
+
+You can also flash the repeater using esptool.  You will need to install esptool with the following command...
+
+`pip install esptool --break-system-packages`
+
+Then to flash the firmware to Heltec, obtain the .bin file from https://flasher.meshcore.co.uk/ (download all firmware link)
+
+For Heltec:
+`esptool.py -p /dev/ttyUSB0 --chip esp32-s3 write_flash 0x00000 firmware.bin`
+
+If flashing a visual studio code build bin file, flash with the following offset:
+`esptool.py -p /dev/ttyUSB0 --chip esp32-s3 write_flash 0x10000 firmware.bin`
+
+For Pi
+Download the zip from the online flasher website and use the following command:
+
+Note: Requires adafruit-nrfutil command which can be installed as follows.
+`pip install adafruit-nrfutil --break-system-packages`
+
+```
+adafruit-nrfutil --verbose dfu serial --package t1000_e_bootloader-0.9.1-5-g488711a_s140_7.3.0.zip -p /dev/ttyACM0 -b 115200 --singlebank --touch 1200
+```
+
+[Source](https://discord.com/channels/826570251612323860/1330643963501351004/1342120825251299388)
+  
+### 5.14. Q: Are there are projects built around MeshCore?
+
+**A:** Yes.  See the following:
+
+#### 5.14.1. meshcoremqtt
+A python based script to send meshore debug and packet capture data to MQTT for analysis
+https://github.com/Andrew-a-g/meshcoretomqtt
+
+#### 5.14.2. MeshCore for Home Assistant
+A custom Home Assistant integration for MeshCore mesh radio nodes. It allows you to monitor and control MeshCore nodes via USB, BLE, or TCP connections.
+https://github.com/awolden/meshcore-ha
+
+#### 5.14.3. Python MeshCore
+Bindings to access your MeshCore companion radio nodes in python.
+https://github.com/fdlamotte/meshcore_py
+
+#### 5.14.4. meshcore-cli  
+CLI interface to MeshCore companion radio over BLE, TCP, or serial.  Uses Pyton MeshCore above.
+ https://github.com/fdlamotte/meshcore-cli
+
+#### 5.14.5. meshcore.js
+A Javascript library for interacting with a MeshCore device running the companion radio firmware
+https://github.com/liamcottle/meshcore.js
+
 ---
 
-## Troubleshooting
+## 6. Troubleshooting
 
-### Q: My client says another client or a repeater or a room server was last seen many, many days ago.
-### Q: A repeater or a client or a room server I expect to see on my discover list (on T-Deck) or contact list (on a smart device client) are not listed.
+### 6.1. Q: My client says another client or a repeater or a room server was last seen many, many days ago.
+### 6.2. Q: A repeater or a client or a room server I expect to see on my discover list (on T-Deck) or contact list (on a smart device client) are not listed.
 **A:**  
 - If your client is a T-Deck, it may not have its time set (no GPS installed, no GPS lock, or wrong GPS baud rate).  
 - If you are using the Android or iOS client, the other client, repeater, or room server may have the wrong time.  
 
 You can get the epoch time on <https://www.epochconverter.com/> and use it to set your T-Deck clock. For a repeater and room server, the admin can use a T-Deck to remotely set their clock (clock sync), or use the `time` command in the USB serial console with the server device connected.
 
-### Q: How to connect to a repeater via BLE (bluetooth)?
+### 6.3. Q: How to connect to a repeater via BLE (bluetooth)?
 **A:** You can't connect to a device running repeater firmware  via bluetooth.  Devices running the BLE companion firmware you can connect to it via bluetooth using the android app
 
-### Q: I can't connect via bluetooth, what is the bluetooth pairing code?
+### 6.4. Q: I can't connect via bluetooth, what is the bluetooth pairing code?
 
 **A:** the default bluetooth pairing code is `123456`
 
-### Q: My Heltec V3 keeps disconnecting from my smartphone.  It can't hold a solid Bluetooth connection.
+### 6.5. Q: My Heltec V3 keeps disconnecting from my smartphone.  It can't hold a solid Bluetooth connection.
 
 **A:** Heltec V3 has a very small coil antenna on its PCB for WiFi and Bluetooth connectivty.  It has a very short range, only a few feet.  It is possible to remove the coil antenna  and replace it with a 31mm wire.  The BT range is much improved with the modification.
 
+---
+## 7. Other Questions:
+### 7.1. Q: How to  Update repeater and room server firmware over the air?
+
+**A:** Only nRF-based RAK4631 and Heltec T114 OTA firmware update are verified using nRF smartphone app.  Lilygo T-Echo doesn't work currently.
+You can update repeater and room server firmware with a bluetooth connection between your smartphone and your LoRa radio using the nRF app.
+
+1. Download the ZIP file for the specific node from the web flasher to your smartphone
+2. On the phone client, log on to the repeater as administrator (default password is `password`) to issue the `start ota`command to the repeater or room server to get the device into OTA DFU mode
+   
+![image](https://github.com/user-attachments/assets/889bb81b-7214-4a1c-955a-396b5a05d8ad)
+
+1. `start ota` can be initiated from USB serial console on the web flasher page or a T-Deck
+4. On the smartphone, download and run the nRF app and scan for Bluetooth devices
+5. Connect to the repeater/room server node you want to update
+	1. nRF app is available on both Android and iOS
+
+**Android continues after the iOS section:**
+
+**iOS continues here:**
+5. Once connected successfully, a `DFU` icon ![Pasted image 20250309173039](https://github.com/user-attachments/assets/af7a9f78-8739-4946-b734-02bade9c8e71)
+ appears in the top right corner of the app
+ ![Pasted image 20250309171919](https://github.com/user-attachments/assets/08007ec8-4924-49c1-989f-ca2611e78793)
+
+6. Scroll down to change the `PRN(s)` number:
+
+![Pasted image 20250309190158](https://github.com/user-attachments/assets/11f69cdd-12f3-4696-a6fc-14a78c85fe32)
+
+- For the T114, change the number of packets `(PRN(s)` to 8
+- For RAK, it can be 10, but it also works on 8.
+
+7. Click the `DFU` icon ![Pasted image 20250309173039](https://github.com/user-attachments/assets/af7a9f78-8739-4946-b734-02bade9c8e71), select the type of file to upload (choose ZIP), then select the ZIP file that was downloaded earlier  from the web flasher
+8. The upload process will start now. If everything goes well, the node resets and is flashed successfully.
+![Pasted image 20250309190342](https://github.com/user-attachments/assets/a60e25d0-33b8-46cf-af90-20a7d8ac2adb)
+
+
+
+**Android steps continues below:**
+1. on the top left corner of the nRF Connect app on Android, tap the 3-bar hamburger menu, then `Settings`, then `nRF5 DFU Options`
+
+![Android nRF Hamberger](https://github.com/user-attachments/assets/ea6dfeef-9367-4830-bd70-1441d517c706)
+
+![Android nRF Settings](https://github.com/user-attachments/assets/c63726bf-cecd-4987-be68-afb6358c7190)
+
+![Android nRF DFU Options](https://github.com/user-attachments/assets/b20e872f-5122-41d9-90df-0215cff5fbc9)
+
+2. Change `Number of packets` to `10` for RAK, `8` for Heltec T114
+
+![Android nRF Number of Packets](https://github.com/user-attachments/assets/c092adaf-4cb3-460b-b7ef-8d7f450d602b)
+
+3. Go back to the main screen
+4. Your LoRa device should already ben in DFU mode from previous steps
+5. tap `SCANNER` and then `SCAN` to find the device you want to update, tap `CONNECT`
+
+![Android nRF Scanner Scan Connect](https://github.com/user-attachments/assets/37218717-f167-48b6-a6ca-93d132ef77ca)
+
+6. On the top left corner of the nRF Connect app, tap the `DFU` icon next to the three dots
+
+![Android nRF DFU](https://github.com/user-attachments/assets/1ec3b818-bf0c-461f-8fdf-37c41a63cafa)
+
+7. Choose `Distribution packet (ZIP)` and then `OK`
+
+![Android nRF Distribution Packet (ZIP)](https://github.com/user-attachments/assets/e65f5616-9793-44f5-95c0-a3eb15aa7152)
+
+8. Choose the firmware file in ZIP formate that you downloaded earlier from the MeshCore web flasher, update will start as soon as you tap the file
+
+![Android nRF FW Updating](https://github.com/user-attachments/assets/0814d123-85ce-4c87-90a7-e1a25dc71900)
+
+9. When the update process is done, the device will disconnect from nRF app and the LoRa device is updated
+
 
 ---
     
-    

examples/companion_radio/UITask.cpp

@@ -4,6 +4,10 @@
 
 #define AUTO_OFF_MILLIS   15000   // 15 seconds
 
+#ifndef USER_BTN_PRESSED
+#define USER_BTN_PRESSED LOW
+#endif
+
 // 'meshcore', 128x13px
 static const uint8_t meshcore_logo [] PROGMEM = {
     0x3c, 0x01, 0xe3, 0xff, 0xc7, 0xff, 0x8f, 0x03, 0x87, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 0x1f, 0xfe, 
@@ -21,14 +25,23 @@ static const uint8_t meshcore_logo [] PROGMEM = {
     0xe3, 0xe3, 0x8f, 0xff, 0x1f, 0xfc, 0x3c, 0x0e, 0x1f, 0xf8, 0xff, 0xf8, 0x70, 0x3c, 0x7f, 0xf8, 
 };
 
-void UITask::begin(const char* node_name, const char* build_date, uint32_t pin_code) {
-  _prevBtnState = HIGH;
+void UITask::begin(DisplayDriver* display, const char* node_name, const char* build_date, uint32_t pin_code) {
+  _display = display;
   _auto_off = millis() + AUTO_OFF_MILLIS;
   clearMsgPreview();
   _node_name = node_name;
   _build_date = build_date;
   _pin_code = pin_code;
-  _display->turnOn();
+  if (_display != NULL) {
+    _display->turnOn();
+  }
+}
+
+void UITask::msgRead(int msgcount) {
+  _msgcount = msgcount;
+  if (msgcount == 0) {
+    clearMsgPreview();
+  }
 }
 
 void UITask::clearMsgPreview() {
@@ -36,7 +49,9 @@ void UITask::clearMsgPreview() {
   _msg[0] = 0;
 }
 
-void UITask::showMsgPreview(uint8_t path_len, const char* from_name, const char* text) {
+void UITask::newMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount) {
+  _msgcount = msgcount;
+
   if (path_len == 0xFF) {
     sprintf(_origin, "(F) %s", from_name);
   } else {
@@ -44,11 +59,15 @@ void UITask::showMsgPreview(uint8_t path_len, const char* from_name, const char*
   }
   StrHelper::strncpy(_msg, text, sizeof(_msg));
 
-  if (!_display->isOn()) _display->turnOn();
-  _auto_off = millis() + AUTO_OFF_MILLIS;  // extend the auto-off timer
+  if (_display != NULL) {
+    if (!_display->isOn()) _display->turnOn();
+    _auto_off = millis() + AUTO_OFF_MILLIS;  // extend the auto-off timer
+  }
 }
 
 void UITask::renderCurrScreen() {
+  if (_display == NULL) return;  // assert() ??
+
   char tmp[80];
   if (_origin[0] && _msg[0]) {
     // render message preview
@@ -61,9 +80,10 @@ void UITask::renderCurrScreen() {
     _display->setCursor(0, 24);
     _display->print(_msg);
 
-    //_display->setCursor(100, 9);   TODO
-    //_display->setTextSize(2);
-    //_display->printf("%d", msgs);
+    _display->setCursor(100, 9);
+    _display->setTextSize(2);
+    sprintf(tmp, "%d", _msgcount);
+    _display->print(tmp);
   } else {
     // render 'home' screen
     _display->drawXbm(0, 0, meshcore_logo, 128, 13);
@@ -87,24 +107,72 @@ void UITask::renderCurrScreen() {
   }
 }
 
-void UITask::loop() {
-  if (millis() >= _next_read) {
-    int btnState = digitalRead(PIN_USER_BTN);
-    if (btnState != _prevBtnState) {
-      if (btnState == LOW) {  // pressed?
-        if (_display->isOn()) {
-          clearMsgPreview();
-        } else {
-          _display->turnOn();
-        }
-        _auto_off = millis() + AUTO_OFF_MILLIS;   // extend auto-off timer
+void UITask::userLedHandler() {
+#ifdef PIN_STATUS_LED
+  static int state = 0;
+  static int next_change = 0;
+  int cur_time = millis();
+  if (cur_time > next_change) {
+    if (state == 0) {
+      state = 1; // led on, short = unread msg
+      if (_msgcount > 0) {
+        next_change = cur_time + 500;
+      } else {
+        next_change = cur_time + 2000;
+      }
+    } else {
+      state = 0;
+      if (_board->getBattMilliVolts() > 3800) {
+        next_change = cur_time + 2000;
+      } else {
+        next_change = cur_time + 4000; // 4s blank if bat level low
       }
-      _prevBtnState = btnState;
     }
-    _next_read = millis() + 100;  // 10 reads per second
+    digitalWrite(PIN_STATUS_LED, state);
   }
+#endif
+}
 
-  if (_display->isOn()) {
+void UITask::buttonHandler() {
+#ifdef PIN_USER_BTN
+  static int prev_btn_state = !USER_BTN_PRESSED;
+  static unsigned long btn_state_change_time = 0;
+  static unsigned long next_read = 0;
+  int cur_time = millis();
+  if (cur_time >= next_read) {
+    int btn_state = digitalRead(PIN_USER_BTN);
+    if (btn_state != prev_btn_state) {
+      if (btn_state == USER_BTN_PRESSED) {  // pressed?
+        if (_display != NULL) {
+          if (_display->isOn()) {
+            clearMsgPreview();
+          } else {
+            _display->turnOn();
+          }
+          _auto_off = cur_time + AUTO_OFF_MILLIS;   // extend auto-off timer
+        }
+      } else { // unpressed ? check pressed time ...
+        if ((cur_time - btn_state_change_time) > 5000) {
+        #ifdef PIN_STATUS_LED
+          digitalWrite(PIN_STATUS_LED, LOW);
+          delay(10);
+        #endif
+          _board->powerOff();
+        }
+      }
+      btn_state_change_time = millis();
+      prev_btn_state = btn_state;
+    }
+    next_read = millis() + 100;  // 10 reads per second
+  }
+#endif
+}
+
+void UITask::loop() {
+  buttonHandler();
+  userLedHandler();
+
+  if (_display != NULL && _display->isOn()) {
     if (millis() >= _next_refresh) {
       _display->startFrame();
       renderCurrScreen();

examples/companion_radio/UITask.h

@@ -1,25 +1,37 @@
 #pragma once
 
+#include <MeshCore.h>
 #include <helpers/ui/DisplayDriver.h>
+#include <stddef.h>
 
 class UITask {
   DisplayDriver* _display;
-  unsigned long _next_read, _next_refresh, _auto_off;
-  int _prevBtnState;
+  mesh::MainBoard* _board;
+  unsigned long _next_refresh, _auto_off;
   bool _connected;
   uint32_t _pin_code;
   const char* _node_name;
   const char* _build_date;
   char _origin[62];
   char _msg[80];
+  int _msgcount;
 
   void renderCurrScreen();
+  void buttonHandler();
+  void userLedHandler();
+
 public:
-  UITask(DisplayDriver& display) : _display(&display) { _next_read = _next_refresh = 0; _connected = false; }
-  void begin(const char* node_name, const char* build_date, uint32_t pin_code);
+
+  UITask(mesh::MainBoard* board) : _board(board), _display(NULL) {
+      _next_refresh = 0; 
+      _connected = false;
+  }
+  void begin(DisplayDriver* display, const char* node_name, const char* build_date, uint32_t pin_code);
 
   void setHasConnection(bool connected) { _connected = connected; }
+  bool hasDisplay() const { return _display != NULL; }
   void clearMsgPreview();
-  void showMsgPreview(uint8_t path_len, const char* from_name, const char* text);
+  void msgRead(int msgcount);
+  void newMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount);
   void loop();
-};
+};

examples/simple_repeater/main.cpp

@@ -7,26 +7,24 @@
   #include <SPIFFS.h>
 #endif
 
-#define RADIOLIB_STATIC_ONLY 1
-#include <RadioLib.h>
 #include <helpers/ArduinoHelpers.h>
 #include <helpers/StaticPoolPacketManager.h>
 #include <helpers/SimpleMeshTables.h>
 #include <helpers/IdentityStore.h>
-#include <helpers/AutoDiscoverRTCClock.h>
 #include <helpers/AdvertDataHelpers.h>
 #include <helpers/TxtDataHelpers.h>
 #include <helpers/CommonCLI.h>
 #include <RTClib.h>
+#include <target.h>
 
 /* ------------------------------ Config -------------------------------- */
 
 #ifndef FIRMWARE_BUILD_DATE
-  #define FIRMWARE_BUILD_DATE   "9 Mar 2025"
+  #define FIRMWARE_BUILD_DATE   "7 Apr 2025"
 #endif
 
 #ifndef FIRMWARE_VERSION
-  #define FIRMWARE_VERSION   "v1.2.2"
+  #define FIRMWARE_VERSION   "v1.4.3"
 #endif
 
 #ifndef LORA_FREQ
@@ -59,47 +57,6 @@
   #define  ADMIN_PASSWORD  "password"
 #endif
 
-#if defined(HELTEC_LORA_V3)
-  #include <helpers/HeltecV3Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static HeltecV3Board board;
-#elif defined(HELTEC_LORA_V2)
-  #include <helpers/HeltecV2Board.h>
-  #include <helpers/CustomSX1276Wrapper.h>
-  static HeltecV2Board board;
-#elif defined(ARDUINO_XIAO_ESP32C3)
-  #include <helpers/XiaoC3Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  #include <helpers/CustomSX1268Wrapper.h>
-  static XiaoC3Board board;
-#elif defined(SEEED_XIAO_S3) || defined(LILYGO_T3S3)
-  #include <helpers/ESP32Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static ESP32Board board;
-#elif defined(LILYGO_TLORA)
-  #include <helpers/LilyGoTLoraBoard.h>
-  #include <helpers/CustomSX1276Wrapper.h>
-  static LilyGoTLoraBoard board;
-#elif defined(STATION_G2)
-  #include <helpers/StationG2Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static StationG2Board board;
-#elif defined(RAK_4631)
-  #include <helpers/nrf52/RAK4631Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static RAK4631Board board;
-#elif defined(HELTEC_T114)
-  #include <helpers/nrf52/T114Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static T114Board board;
-#elif defined(LILYGO_TECHO)
-  #include <helpers/nrf52/TechoBoard.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static TechoBoard board;
-#else
-  #error "need to provide a 'board' object"
-#endif
-
 #ifdef DISPLAY_CLASS
   #include <helpers/ui/SSD1306Display.h>
 
@@ -109,6 +66,8 @@
   static UITask ui_task(display);
 #endif
 
+#define FIRMWARE_ROLE "repeater"
+
 #define PACKET_LOG_FILE  "/packet_log"
 
 /* ------------------------------ Code -------------------------------- */
@@ -148,11 +107,8 @@ struct ClientInfo {
 #define CLI_REPLY_DELAY_MILLIS  1500
 
 class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
-  RadioLibWrapper* my_radio;
   FILESYSTEM* _fs;
-  RADIO_CLASS* _phy;
-  mesh::MainBoard* _board;
-  unsigned long next_local_advert;
+  unsigned long next_local_advert, next_flood_advert;
   bool _logging;
   NodePrefs _prefs;
   CommonCLI _cli;
@@ -187,9 +143,9 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
         stats.batt_milli_volts = board.getBattMilliVolts();
         stats.curr_tx_queue_len = _mgr->getOutboundCount();
         stats.curr_free_queue_len = _mgr->getFreeCount();
-        stats.last_rssi = (int16_t) my_radio->getLastRSSI();
-        stats.n_packets_recv = my_radio->getPacketsRecv();
-        stats.n_packets_sent = my_radio->getPacketsSent();
+        stats.last_rssi = (int16_t) radio_driver.getLastRSSI();
+        stats.n_packets_recv = radio_driver.getPacketsRecv();
+        stats.n_packets_sent = radio_driver.getPacketsSent();
         stats.total_air_time_secs = getTotalAirTime() / 1000;
         stats.total_up_time_secs = _ms->getMillis() / 1000;
         stats.n_sent_flood = getNumSentFlood();
@@ -197,7 +153,7 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
         stats.n_recv_flood = getNumRecvFlood();
         stats.n_recv_direct = getNumRecvDirect();
         stats.n_full_events = getNumFullEvents();
-        stats.last_snr = (int16_t)(my_radio->getLastSNR() * 4);
+        stats.last_snr = (int16_t)(radio_driver.getLastSNR() * 4);
         stats.n_direct_dups = ((SimpleMeshTables *)getTables())->getNumDirectDups();
         stats.n_flood_dups = ((SimpleMeshTables *)getTables())->getNumFloodDups();
 
@@ -235,7 +191,9 @@ protected:
   }
 
   bool allowPacketForward(const mesh::Packet* packet) override {
-    return !_prefs.disable_fwd;
+    if (_prefs.disable_fwd) return false;
+    if (packet->isRouteFlood() && packet->path_len >= _prefs.flood_max) return false;
+    return true;
   }
 
   const char* getLogDateTime() override {
@@ -512,13 +470,12 @@ protected:
   }
 
 public:
-  MyMesh(RADIO_CLASS& phy, mesh::MainBoard& board, RadioLibWrapper& radio, mesh::MillisecondClock& ms, mesh::RNG& rng, mesh::RTCClock& rtc, SimpleMeshTables& tables)
+  MyMesh(mesh::MainBoard& board, mesh::Radio& radio, mesh::MillisecondClock& ms, mesh::RNG& rng, mesh::RTCClock& rtc, mesh::MeshTables& tables)
      : mesh::Mesh(radio, ms, rng, rtc, *new StaticPoolPacketManager(32), tables),
-        _phy(&phy), _board(&board), _cli(board, this, &_prefs, this)
+      _cli(board, this, &_prefs, this)
   {
-    my_radio = &radio;
     memset(known_clients, 0, sizeof(known_clients));
-    next_local_advert = 0;
+    next_local_advert = next_flood_advert = 0;
     _logging = false;
 
     // defaults
@@ -536,6 +493,8 @@ public:
     _prefs.cr = LORA_CR;
     _prefs.tx_power_dbm = LORA_TX_POWER;
     _prefs.advert_interval = 1;  // default to 2 minutes for NEW installs
+    _prefs.flood_advert_interval = 3;   // 3 hours
+    _prefs.flood_max = 64;
   }
 
   CommonCLI* getCLI() { return &_cli; }
@@ -546,17 +505,16 @@ public:
     // load persisted prefs
     _cli.loadPrefs(_fs);
 
-    _phy->setFrequency(_prefs.freq);
-    _phy->setSpreadingFactor(_prefs.sf);
-    _phy->setBandwidth(_prefs.bw);
-    _phy->setCodingRate(_prefs.cr);
-    _phy->setOutputPower(_prefs.tx_power_dbm);
+    radio_set_params(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
+    radio_set_tx_power(_prefs.tx_power_dbm);
 
     updateAdvertTimer();
+    updateFloodAdvertTimer();
   }
 
   const char* getFirmwareVer() override { return FIRMWARE_VERSION; }
   const char* getBuildDate() override { return FIRMWARE_BUILD_DATE; }
+  const char* getRole() override { return FIRMWARE_ROLE; }
   const char* getNodeName() { return _prefs.node_name; }
 
   void savePrefs() override {
@@ -585,11 +543,18 @@ public:
 
   void updateAdvertTimer() override {
     if (_prefs.advert_interval > 0) {  // schedule local advert timer
-      next_local_advert = futureMillis((uint32_t)_prefs.advert_interval * 2 * 60 * 1000);
+      next_local_advert = futureMillis( ((uint32_t)_prefs.advert_interval) * 2 * 60 * 1000);
     } else {
       next_local_advert = 0;  // stop the timer
     }
   }
+  void updateFloodAdvertTimer() override {
+    if (_prefs.flood_advert_interval > 0) {  // schedule flood advert timer
+      next_flood_advert = futureMillis( ((uint32_t)_prefs.flood_advert_interval) * 60 * 60 * 1000);
+    } else {
+      next_flood_advert = 0;  // stop the timer
+    }
+  }
 
   void setLoggingOn(bool enable) override { _logging = enable; }
 
@@ -610,17 +575,21 @@ public:
   }
 
   void setTxPower(uint8_t power_dbm) override {
-    _phy->setOutputPower(power_dbm);
+    radio_set_tx_power(power_dbm);
   }
 
   void loop() {
     mesh::Mesh::loop();
 
-    if (next_local_advert && millisHasNowPassed(next_local_advert)) {
+    if (next_flood_advert && millisHasNowPassed(next_flood_advert)) {
       mesh::Packet* pkt = createSelfAdvert();
-      if (pkt) {
-        sendZeroHop(pkt);
-      }
+      if (pkt) sendFlood(pkt);
+
+      updateFloodAdvertTimer();   // schedule next flood advert
+      updateAdvertTimer();   // also schedule local advert (so they don't overlap)
+    } else if (next_local_advert && millisHasNowPassed(next_local_advert)) {
+      mesh::Packet* pkt = createSelfAdvert();
+      if (pkt) sendZeroHop(pkt);
 
       updateAdvertTimer();   // schedule next local advert
     }
@@ -630,28 +599,10 @@ public:
   }
 };
 
-#if defined(NRF52_PLATFORM)
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI);
-#elif defined(LILYGO_TLORA)
-SPIClass spi;
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_0, P_LORA_RESET, P_LORA_DIO_1, spi);
-#elif defined(P_LORA_SCLK)
-SPIClass spi;
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, spi);
-#else
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY);
-#endif
 StdRNG fast_rng;
 SimpleMeshTables tables;
 
-#ifdef ESP32
-ESP32RTCClock fallback_clock;
-#else
-VolatileRTCClock fallback_clock;
-#endif
-AutoDiscoverRTCClock rtc_clock(fallback_clock);
-
-MyMesh the_mesh(radio, board, *new WRAPPER_CLASS(radio, board), *new ArduinoMillis(), fast_rng, rtc_clock, tables);
+MyMesh the_mesh(board, radio_driver, *new ArduinoMillis(), fast_rng, rtc_clock, tables);
 
 void halt() {
   while (1) ;
@@ -664,44 +615,18 @@ void setup() {
   delay(1000);
 
   board.begin();
-#ifdef ESP32
-  fallback_clock.begin();
-#endif
-  rtc_clock.begin(Wire);
 
-#ifdef SX126X_DIO3_TCXO_VOLTAGE
-  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
-#else
-  float tcxo = 1.6f;
-#endif
-
-#if defined(NRF52_PLATFORM)
-  SPI.setPins(P_LORA_MISO, P_LORA_SCLK, P_LORA_MOSI);
-  SPI.begin();
-#elif defined(P_LORA_SCLK)
-  spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI);
-#endif
-  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
-  if (status != RADIOLIB_ERR_NONE) {
-    delay(5000);
-    Serial.print("ERROR: radio init failed: ");
-    Serial.println(status);
-    halt();
+#ifdef DISPLAY_CLASS
+  if(display.begin()){
+    display.startFrame();
+    display.print("Please wait...");
+    display.endFrame();
   }
-
-  radio.setCRC(1);
-
-#ifdef SX126X_CURRENT_LIMIT
-  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
-#endif
-#ifdef SX126X_DIO2_AS_RF_SWITCH
-  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
-#endif
-#ifdef SX126X_RX_BOOSTED_GAIN
-  radio.setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
 #endif
 
-  fast_rng.begin(radio.random(0x7FFFFFFF));
+  if (!radio_init()) { halt(); }
+
+  fast_rng.begin(radio_get_rng_seed());
 
   FILESYSTEM* fs;
 #if defined(NRF52_PLATFORM)
@@ -717,8 +642,11 @@ void setup() {
 #endif
   if (!store.load("_main", the_mesh.self_id)) {
     MESH_DEBUG_PRINTLN("Generating new keypair");
-    RadioNoiseListener rng(radio);
-    the_mesh.self_id = mesh::LocalIdentity(&rng);  // create new random identity
+    the_mesh.self_id = radio_new_identity();   // create new random identity
+    int count = 0;
+    while (count < 10 && (the_mesh.self_id.pub_key[0] == 0x00 || the_mesh.self_id.pub_key[0] == 0xFF)) {  // reserved id hashes
+      the_mesh.self_id = radio_new_identity(); count++;
+    }
     store.save("_main", the_mesh.self_id);
   }
 
@@ -730,12 +658,11 @@ void setup() {
   the_mesh.begin(fs);
 
 #ifdef DISPLAY_CLASS
-  display.begin();
   ui_task.begin(the_mesh.getNodeName(), FIRMWARE_BUILD_DATE);
 #endif
 
   // send out initial Advertisement to the mesh
-  the_mesh.sendSelfAdvertisement(2000);
+  the_mesh.sendSelfAdvertisement(16000);
 }
 
 void loop() {

examples/simple_room_server/main.cpp

@@ -7,26 +7,24 @@
   #include <SPIFFS.h>
 #endif
 
-#define RADIOLIB_STATIC_ONLY 1
-#include <RadioLib.h>
 #include <helpers/ArduinoHelpers.h>
 #include <helpers/StaticPoolPacketManager.h>
 #include <helpers/SimpleMeshTables.h>
 #include <helpers/IdentityStore.h>
-#include <helpers/AutoDiscoverRTCClock.h>
 #include <helpers/AdvertDataHelpers.h>
 #include <helpers/TxtDataHelpers.h>
 #include <helpers/CommonCLI.h>
 #include <RTClib.h>
+#include <target.h>
 
 /* ------------------------------ Config -------------------------------- */
 
 #ifndef FIRMWARE_BUILD_DATE
-  #define FIRMWARE_BUILD_DATE   "9 Mar 2025"
+  #define FIRMWARE_BUILD_DATE   "7 Apr 2025"
 #endif
 
 #ifndef FIRMWARE_VERSION
-  #define FIRMWARE_VERSION   "v1.2.2"
+  #define FIRMWARE_VERSION   "v1.4.3"
 #endif
 
 #ifndef LORA_FREQ
@@ -64,36 +62,7 @@
 #endif
 
 #ifndef MAX_UNSYNCED_POSTS
-  #define MAX_UNSYNCED_POSTS    16
-#endif
-
-#if defined(HELTEC_LORA_V3)
-  #include <helpers/HeltecV3Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static HeltecV3Board board;
-#elif defined(ARDUINO_XIAO_ESP32C3)
-  #include <helpers/XiaoC3Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  #include <helpers/CustomSX1268Wrapper.h>
-  static XiaoC3Board board;
-#elif defined(SEEED_XIAO_S3)
-  #include <helpers/ESP32Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static ESP32Board board;
-#elif defined(LILYGO_TLORA)
-  #include <helpers/LilyGoTLoraBoard.h>
-  #include <helpers/CustomSX1276Wrapper.h>
-  static LilyGoTLoraBoard board;
-#elif defined(STATION_G2)
-  #include <helpers/StationG2Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static StationG2Board board;
-#elif defined(RAK_4631)
-  #include <helpers/nrf52/RAK4631Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static RAK4631Board board;
-#else
-  #error "need to provide a 'board' object"
+  #define MAX_UNSYNCED_POSTS    32
 #endif
 
 #ifdef DISPLAY_CLASS
@@ -105,8 +74,18 @@
   static UITask ui_task(display);
 #endif
 
+#define FIRMWARE_ROLE "room_server"
+
+#define PACKET_LOG_FILE  "/packet_log"
+
 /* ------------------------------ Code -------------------------------- */
 
+enum RoomPermission {
+  ADMIN,
+  GUEST,
+  READ_ONLY
+};
+
 struct ClientInfo {
   mesh::Identity id;
   uint32_t last_timestamp;  // by THEIR clock
@@ -115,7 +94,7 @@ struct ClientInfo {
   uint32_t pending_ack;
   uint32_t push_post_timestamp;
   unsigned long ack_timeout;
-  bool     is_admin;
+  RoomPermission  permission;
   uint8_t  push_failures;
   uint8_t  secret[PUB_KEY_SIZE];
   int      out_path_len;
@@ -132,7 +111,7 @@ struct PostInfo {
 
 #define REPLY_DELAY_MILLIS         1500
 #define PUSH_NOTIFY_DELAY_MILLIS   2000
-#define SYNC_PUSH_INTERVAL         2000
+#define SYNC_PUSH_INTERVAL         1200
 
 #define PUSH_ACK_TIMEOUT_FLOOD    12000
 #define PUSH_TIMEOUT_BASE          4000
@@ -145,18 +124,34 @@ struct PostInfo {
 
 #define RESP_SERVER_LOGIN_OK      0   // response to ANON_REQ
 
+struct ServerStats {
+  uint16_t batt_milli_volts;
+  uint16_t curr_tx_queue_len;
+  uint16_t curr_free_queue_len;
+  int16_t  last_rssi;
+  uint32_t n_packets_recv;
+  uint32_t n_packets_sent;
+  uint32_t total_air_time_secs;
+  uint32_t total_up_time_secs;
+  uint32_t n_sent_flood, n_sent_direct;
+  uint32_t n_recv_flood, n_recv_direct;
+  uint16_t n_full_events;
+  int16_t  last_snr;   // x 4
+  uint16_t n_direct_dups, n_flood_dups;
+  uint16_t n_posted, n_post_push;
+};
+
 class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
-  RadioLibWrapper* my_radio;
   FILESYSTEM* _fs;
-  RADIO_CLASS* _phy;
-  mesh::MainBoard* _board;
-  unsigned long next_local_advert;
+  unsigned long next_local_advert, next_flood_advert;
+  bool _logging;
   NodePrefs _prefs;
   CommonCLI _cli;
   uint8_t reply_data[MAX_PACKET_PAYLOAD];
   int num_clients;
   ClientInfo known_clients[MAX_CLIENTS];
   unsigned long next_push;
+  uint16_t _num_posted, _num_post_pushes;
   int next_client_idx;  // for round-robin polling
   int next_post_idx;
   PostInfo posts[MAX_UNSYNCED_POSTS];   // cyclic queue
@@ -203,6 +198,7 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
     next_post_idx = (next_post_idx + 1) % MAX_UNSYNCED_POSTS;
 
     next_push = futureMillis(PUSH_NOTIFY_DELAY_MILLIS);
+    _num_posted++;  // stats
   }
 
   void pushPostToClient(ClientInfo* client, PostInfo& post) {
@@ -229,6 +225,7 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
         sendDirect(reply, client->out_path, client->out_path_len);
         client->ack_timeout = futureMillis(PUSH_TIMEOUT_BASE + PUSH_ACK_TIMEOUT_FACTOR * (client->out_path_len + 1));
       }
+      _num_post_pushes++;  // stats
     } else {
       client->pending_ack = 0;
       MESH_DEBUG_PRINTLN("Unable to push post to client");
@@ -259,6 +256,14 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
    return createAdvert(self_id, app_data, app_data_len);
   }
 
+  File openAppend(const char* fname) {
+    #if defined(NRF52_PLATFORM)
+      return _fs->open(fname, FILE_O_WRITE);
+    #else
+      return _fs->open(fname, "a", true);
+    #endif
+    }
+
 protected:
   float getAirtimeBudgetFactor() const override {
     return _prefs.airtime_factor;
@@ -273,6 +278,55 @@ protected:
     #endif
   }
 
+  void logRx(mesh::Packet* pkt, int len, float score) override {
+    if (_logging) {
+      File f = openAppend(PACKET_LOG_FILE);
+      if (f) {
+        f.print(getLogDateTime());
+        f.printf(": RX, len=%d (type=%d, route=%s, payload_len=%d) SNR=%d RSSI=%d score=%d",
+          len, pkt->getPayloadType(), pkt->isRouteDirect() ? "D" : "F", pkt->payload_len,
+          (int)_radio->getLastSNR(), (int)_radio->getLastRSSI(), (int)(score*1000));
+
+        if (pkt->getPayloadType() == PAYLOAD_TYPE_PATH || pkt->getPayloadType() == PAYLOAD_TYPE_REQ
+          || pkt->getPayloadType() == PAYLOAD_TYPE_RESPONSE || pkt->getPayloadType() == PAYLOAD_TYPE_TXT_MSG) {
+          f.printf(" [%02X -> %02X]\n", (uint32_t)pkt->payload[1], (uint32_t)pkt->payload[0]);
+        } else {
+          f.printf("\n");
+        }
+        f.close();
+      }
+    }
+  }
+  void logTx(mesh::Packet* pkt, int len) override {
+    if (_logging) {
+      File f = openAppend(PACKET_LOG_FILE);
+      if (f) {
+        f.print(getLogDateTime());
+        f.printf(": TX, len=%d (type=%d, route=%s, payload_len=%d)",
+          len, pkt->getPayloadType(), pkt->isRouteDirect() ? "D" : "F", pkt->payload_len);
+
+        if (pkt->getPayloadType() == PAYLOAD_TYPE_PATH || pkt->getPayloadType() == PAYLOAD_TYPE_REQ
+          || pkt->getPayloadType() == PAYLOAD_TYPE_RESPONSE || pkt->getPayloadType() == PAYLOAD_TYPE_TXT_MSG) {
+          f.printf(" [%02X -> %02X]\n", (uint32_t)pkt->payload[1], (uint32_t)pkt->payload[0]);
+        } else {
+          f.printf("\n");
+        }
+        f.close();
+      }
+    }
+  }
+  void logTxFail(mesh::Packet* pkt, int len) override {
+    if (_logging) {
+      File f = openAppend(PACKET_LOG_FILE);
+      if (f) {
+        f.print(getLogDateTime());
+        f.printf(": TX FAIL!, len=%d (type=%d, route=%s, payload_len=%d)\n",
+          len, pkt->getPayloadType(), pkt->isRouteDirect() ? "D" : "F", pkt->payload_len);
+        f.close();
+      }
+    }
+  }
+
   int calcRxDelay(float score, uint32_t air_time) const override {
     if (_prefs.rx_delay_base <= 0.0f) return 0;
     return (int) ((pow(_prefs.rx_delay_base, 0.85f - score) - 1.0) * air_time);
@@ -296,7 +350,9 @@ protected:
   }
 
   bool allowPacketForward(const mesh::Packet* packet) override {
-    return !_prefs.disable_fwd;
+    if (_prefs.disable_fwd) return false;
+    if (packet->isRouteFlood() && packet->path_len >= _prefs.flood_max) return false;
+    return true;
   }
 
   void onAnonDataRecv(mesh::Packet* packet, uint8_t type, const mesh::Identity& sender, uint8_t* data, size_t len) override {
@@ -305,13 +361,16 @@ protected:
       memcpy(&sender_timestamp, data, 4);
       memcpy(&sender_sync_since, &data[4], 4);  // sender's "sync messags SINCE x" timestamp
 
-      bool is_admin;
+      RoomPermission perm;
       data[len] = 0;  // ensure null terminator
       if (strcmp((char *) &data[8], _prefs.password) == 0) {  // check for valid admin password
-        is_admin = true;
+        perm = RoomPermission::ADMIN;
       } else {
-        is_admin = false;
-        if (strcmp((char *) &data[8], _prefs.guest_password) != 0) {  // check the room/public password
+        if (strcmp((char *) &data[8], _prefs.guest_password) == 0) {  // check the room/public password
+          perm = RoomPermission::GUEST;
+        } else if (_prefs.allow_read_only) {
+          perm = RoomPermission::READ_ONLY;
+        } else {
           MESH_DEBUG_PRINTLN("Incorrect room password");
           return;   // no response. Client will timeout
         }
@@ -324,7 +383,7 @@ protected:
       }
 
       MESH_DEBUG_PRINTLN("Login success!");
-      client->is_admin = is_admin;
+      client->permission = perm;
       client->last_timestamp = sender_timestamp;
       client->sync_since = sender_sync_since;
       client->pending_ack = 0;
@@ -338,7 +397,7 @@ protected:
       // TODO: maybe reply with count of messages waiting to be synced for THIS client?
       reply_data[4] = RESP_SERVER_LOGIN_OK;
       reply_data[5] = (CLIENT_KEEP_ALIVE_SECS >> 4);  // NEW: recommended keep-alive interval (secs / 16)
-      reply_data[6] = is_admin ? 1 : 0;
+      reply_data[6] = (perm == RoomPermission::ADMIN ? 1 : (perm == RoomPermission::GUEST ? 0 : 2));
       reply_data[7] = 0;  // FUTURE: reserved
       memcpy(&reply_data[8], "OK", 2);  // REVISIT: not really needed
 
@@ -415,7 +474,7 @@ protected:
         uint8_t temp[166];
         bool send_ack;
         if (flags == TXT_TYPE_CLI_DATA) {
-          if (client->is_admin) {
+          if (client->permission == RoomPermission::ADMIN) {
             if (is_retry) {
               temp[5] = 0;  // no reply
             } else {
@@ -428,11 +487,16 @@ protected:
             send_ack = false;  // and no ACK...  user shoudn't be sending these
           }
         } else {   // TXT_TYPE_PLAIN
-          if (!is_retry) {
-            addPost(client, (const char *) &data[5]);
+          if (client->permission == RoomPermission::READ_ONLY) {
+            temp[5] = 0;  // no reply
+            send_ack = false;  // no ACK
+          } else {
+            if (!is_retry) {
+              addPost(client, (const char *) &data[5]);
+            }
+            temp[5] = 0;  // no reply (ACK is enough)
+            send_ack = true;
           }
-          temp[5] = 0;  // no reply (ACK is enough)
-          send_ack = true;
         }
 
         uint32_t delay_millis;
@@ -476,33 +540,81 @@ protected:
     } else if (type == PAYLOAD_TYPE_REQ && len >= 5) {
       uint32_t sender_timestamp;
       memcpy(&sender_timestamp, data, 4);  // timestamp (by sender's RTC clock - which could be wrong)
-      if (data[4] == REQ_TYPE_KEEP_ALIVE && packet->isRouteDirect()) {   // request type
-        uint32_t forceSince = 0;
-        if (len >= 9) {   // optional - last post_timestamp client received
-          memcpy(&forceSince, &data[5], 4);    // NOTE: this may be 0, if part of decrypted PADDING!
-        } else {
-          memcpy(&data[5], &forceSince, 4);  // make sure there are zeroes in payload (for ack_hash calc below)
-        }
-        if (forceSince > 0) {
-          client->sync_since = forceSince;    // force-update the 'sync since'
-        }
+      if (sender_timestamp < client->last_timestamp) {  // prevent replay attacks
+        MESH_DEBUG_PRINTLN("onPeerDataRecv: possible replay attack detected");
+      } else {
+        client->last_timestamp = sender_timestamp;
 
         uint32_t now = getRTCClock()->getCurrentTime();
         client->last_activity = now;   // <-- THIS will keep client connection alive
         client->push_failures = 0;  // reset so push can resume (if prev failed)
-        client->pending_ack = 0;
 
-        // TODO: Throttle KEEP_ALIVE requests!
-        // if client sends too quickly, evict()
+        if (data[4] == REQ_TYPE_KEEP_ALIVE && packet->isRouteDirect()) {   // request type
+          uint32_t forceSince = 0;
+          if (len >= 9) {   // optional - last post_timestamp client received
+            memcpy(&forceSince, &data[5], 4);    // NOTE: this may be 0, if part of decrypted PADDING!
+          } else {
+            memcpy(&data[5], &forceSince, 4);  // make sure there are zeroes in payload (for ack_hash calc below)
+          }
+          if (forceSince > 0) {
+            client->sync_since = forceSince;    // force-update the 'sync since'
+          }
 
-        // RULE: only send keep_alive response DIRECT!
-        if (client->out_path_len >= 0) {
-          uint32_t ack_hash;    // calc ACK to prove to sender that we got request
-          mesh::Utils::sha256((uint8_t *) &ack_hash, 4, data, 9, client->id.pub_key, PUB_KEY_SIZE);
+          client->pending_ack = 0;
 
-          auto reply = createAck(ack_hash);
-          if (reply) {
-            sendDirect(reply, client->out_path, client->out_path_len);
+          // TODO: Throttle KEEP_ALIVE requests!
+          // if client sends too quickly, evict()
+
+          // RULE: only send keep_alive response DIRECT!
+          if (client->out_path_len >= 0) {
+            uint32_t ack_hash;    // calc ACK to prove to sender that we got request
+            mesh::Utils::sha256((uint8_t *) &ack_hash, 4, data, 9, client->id.pub_key, PUB_KEY_SIZE);
+
+            auto reply = createAck(ack_hash);
+            if (reply) {
+              sendDirect(reply, client->out_path, client->out_path_len);
+            }
+          }
+        } else if (data[4] == REQ_TYPE_GET_STATUS) {
+          ServerStats stats;
+          stats.batt_milli_volts = board.getBattMilliVolts();
+          stats.curr_tx_queue_len = _mgr->getOutboundCount();
+          stats.curr_free_queue_len = _mgr->getFreeCount();
+          stats.last_rssi = (int16_t) radio_driver.getLastRSSI();
+          stats.n_packets_recv = radio_driver.getPacketsRecv();
+          stats.n_packets_sent = radio_driver.getPacketsSent();
+          stats.total_air_time_secs = getTotalAirTime() / 1000;
+          stats.total_up_time_secs = _ms->getMillis() / 1000;
+          stats.n_sent_flood = getNumSentFlood();
+          stats.n_sent_direct = getNumSentDirect();
+          stats.n_recv_flood = getNumRecvFlood();
+          stats.n_recv_direct = getNumRecvDirect();
+          stats.n_full_events = getNumFullEvents();
+          stats.last_snr = (int16_t)(radio_driver.getLastSNR() * 4);
+          stats.n_direct_dups = ((SimpleMeshTables *)getTables())->getNumDirectDups();
+          stats.n_flood_dups = ((SimpleMeshTables *)getTables())->getNumFloodDups();
+          stats.n_posted = _num_posted;
+          stats.n_post_push = _num_post_pushes;
+
+          now = getRTCClock()->getCurrentTimeUnique();
+          memcpy(reply_data, &now, 4);   // response packets always prefixed with timestamp
+          memcpy(&reply_data[4], &stats, sizeof(stats));
+          uint8_t reply_len = 4 + sizeof(stats);
+
+          if (packet->isRouteFlood()) {
+            // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
+            mesh::Packet* path = createPathReturn(client->id, secret, packet->path, packet->path_len,
+                                                  PAYLOAD_TYPE_RESPONSE, reply_data, reply_len);
+            if (path) sendFlood(path);
+          } else {
+            mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, client->id, secret, reply_data, reply_len);
+            if (reply) {
+              if (client->out_path_len >= 0) {  // we have an out_path, so send DIRECT
+                sendDirect(reply, client->out_path, client->out_path_len);
+              } else {
+                sendFlood(reply);
+              }
+            }
           }
         }
       }
@@ -537,12 +649,12 @@ protected:
   }
 
 public:
-  MyMesh(RADIO_CLASS& phy, mesh::MainBoard& board, RadioLibWrapper& radio, mesh::MillisecondClock& ms, mesh::RNG& rng, mesh::RTCClock& rtc, mesh::MeshTables& tables)
+  MyMesh(mesh::MainBoard& board, mesh::Radio& radio, mesh::MillisecondClock& ms, mesh::RNG& rng, mesh::RTCClock& rtc, mesh::MeshTables& tables)
      : mesh::Mesh(radio, ms, rng, rtc, *new StaticPoolPacketManager(32), tables),
-        _phy(&phy), _board(&board), _cli(board, this, &_prefs, this)
+      _cli(board, this, &_prefs, this)
   {
-    my_radio = &radio;
-    next_local_advert = 0;
+    next_local_advert = next_flood_advert = 0;
+    _logging = false;
 
     // defaults
     memset(&_prefs, 0, sizeof(_prefs));
@@ -560,6 +672,8 @@ public:
     _prefs.tx_power_dbm = LORA_TX_POWER;
     _prefs.disable_fwd = 1;
     _prefs.advert_interval = 1;  // default to 2 minutes for NEW installs
+    _prefs.flood_advert_interval = 3;   // 3 hours
+    _prefs.flood_max = 64;
   #ifdef ROOM_PASSWORD
     StrHelper::strncpy(_prefs.guest_password, ROOM_PASSWORD, sizeof(_prefs.guest_password));
   #endif
@@ -569,6 +683,7 @@ public:
     next_client_idx = 0;
     next_push = 0;
     memset(posts, 0, sizeof(posts));
+    _num_posted = _num_post_pushes = 0;
   }
 
   CommonCLI* getCLI() { return &_cli; }
@@ -579,17 +694,16 @@ public:
     // load persisted prefs
     _cli.loadPrefs(_fs);
 
-    _phy->setFrequency(_prefs.freq);
-    _phy->setSpreadingFactor(_prefs.sf);
-    _phy->setBandwidth(_prefs.bw);
-    _phy->setCodingRate(_prefs.cr);
-    _phy->setOutputPower(_prefs.tx_power_dbm);
+    radio_set_params(_prefs.freq, _prefs.bw, _prefs.sf, _prefs.cr);
+    radio_set_tx_power(_prefs.tx_power_dbm);
 
     updateAdvertTimer();
+    updateFloodAdvertTimer();
   }
 
   const char* getFirmwareVer() override { return FIRMWARE_VERSION; }
   const char* getBuildDate() override { return FIRMWARE_BUILD_DATE; }
+  const char* getRole() override { return FIRMWARE_ROLE; }
   const char* getNodeName() { return _prefs.node_name; }
 
   void savePrefs() override {
@@ -623,13 +737,34 @@ public:
       next_local_advert = 0;  // stop the timer
     }
   }
+  void updateFloodAdvertTimer() override {
+    if (_prefs.flood_advert_interval > 0) {  // schedule flood advert timer
+      next_flood_advert = futureMillis( ((uint32_t)_prefs.flood_advert_interval) * 60 * 60 * 1000);
+    } else {
+      next_flood_advert = 0;  // stop the timer
+    }
+  }
 
-  void setLoggingOn(bool enable) override { /* no-op */ }
-  void eraseLogFile() override { /* no-op */ }
-  void dumpLogFile() override { /* no-op */ }
+  void setLoggingOn(bool enable) override { _logging = enable; }
+
+  void eraseLogFile() override {
+    _fs->remove(PACKET_LOG_FILE);
+  }
+
+  void dumpLogFile() override {
+    File f = _fs->open(PACKET_LOG_FILE);
+    if (f) {
+      while (f.available()) {
+        int c = f.read();
+        if (c < 0) break;
+        Serial.print((char)c);
+      }
+      f.close();
+    }
+  }
 
   void setTxPower(uint8_t power_dbm) override {
-    _phy->setOutputPower(power_dbm);
+    radio_set_tx_power(power_dbm);
   }
 
   void loop() {
@@ -647,6 +782,7 @@ public:
       }
       // check next Round-Robin client, and sync next new post
       auto client = &known_clients[next_client_idx];
+      bool did_push = false;
       if (client->pending_ack == 0 && client->last_activity != 0 && client->push_failures < 3) {  // not already waiting for ACK, AND not evicted, AND retries not max
         MESH_DEBUG_PRINTLN("loop - checking for client %02X", (uint32_t) client->id.pub_key[0]);
         for (int k = 0, idx = next_post_idx; k < MAX_UNSYNCED_POSTS; k++) {
@@ -654,6 +790,7 @@ public:
             && !posts[idx].author.matches(client->id)) {    // don't push posts to the author
             // push this post to Client, then wait for ACK
             pushPostToClient(client, posts[idx]);
+            did_push = true;
             MESH_DEBUG_PRINTLN("loop - pushed to client %02X: %s", (uint32_t) client->id.pub_key[0], posts[idx].text);
             break;
           }
@@ -664,14 +801,23 @@ public:
       }
       next_client_idx = (next_client_idx + 1) % num_clients;  // round robin polling for each client
 
-      next_push = futureMillis(SYNC_PUSH_INTERVAL);
+      if (did_push) {
+        next_push = futureMillis(SYNC_PUSH_INTERVAL);
+      } else {
+        // were no unsynced posts for curr client, so proccess next client much quicker! (in next loop())
+        next_push = futureMillis(SYNC_PUSH_INTERVAL / 8);
+      }
     }
 
-    if (next_local_advert && millisHasNowPassed(next_local_advert)) {
+    if (next_flood_advert && millisHasNowPassed(next_flood_advert)) {
       mesh::Packet* pkt = createSelfAdvert();
-      if (pkt) {
-        sendZeroHop(pkt);
-      }
+      if (pkt) sendFlood(pkt);
+
+      updateFloodAdvertTimer();   // schedule next flood advert
+      updateAdvertTimer();   // also schedule local advert (so they don't overlap)
+    } else if (next_local_advert && millisHasNowPassed(next_local_advert)) {
+      mesh::Packet* pkt = createSelfAdvert();
+      if (pkt) sendZeroHop(pkt);
 
       updateAdvertTimer();   // schedule next local advert
     }
@@ -684,28 +830,9 @@ public:
   }
 };
 
-#if defined(NRF52_PLATFORM)
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI);
-#elif defined(LILYGO_TLORA)
-SPIClass spi;
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_0, P_LORA_RESET, P_LORA_DIO_1, spi);
-#elif defined(P_LORA_SCLK)
-SPIClass spi;
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, spi);
-#else
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY);
-#endif
 StdRNG fast_rng;
 SimpleMeshTables tables;
-
-#ifdef ESP32
-ESP32RTCClock fallback_clock;
-#else
-VolatileRTCClock fallback_clock;
-#endif
-AutoDiscoverRTCClock rtc_clock(fallback_clock);
-
-MyMesh the_mesh(radio, board, *new WRAPPER_CLASS(radio, board), *new ArduinoMillis(), fast_rng, rtc_clock, tables);
+MyMesh the_mesh(board, radio_driver, *new ArduinoMillis(), fast_rng, rtc_clock, tables);
 
 void halt() {
   while (1) ;
@@ -718,44 +845,18 @@ void setup() {
   delay(1000);
 
   board.begin();
-#ifdef ESP32
-  fallback_clock.begin();
-#endif
-  rtc_clock.begin(Wire);
 
-#ifdef SX126X_DIO3_TCXO_VOLTAGE
-  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
-#else
-  float tcxo = 1.6f;
-#endif
-
-#if defined(NRF52_PLATFORM)
-  SPI.setPins(P_LORA_MISO, P_LORA_SCLK, P_LORA_MOSI);
-  SPI.begin();
-#elif defined(P_LORA_SCLK)
-  spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI);
-#endif
-  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
-  if (status != RADIOLIB_ERR_NONE) {
-    delay(5000);
-    Serial.print("ERROR: radio init failed: ");
-    Serial.println(status);
-    halt();
+#ifdef DISPLAY_CLASS
+  if(display.begin()){
+    display.startFrame();
+    display.print("Please wait...");
+    display.endFrame();
   }
-
-  radio.setCRC(1);
-
-#ifdef SX126X_CURRENT_LIMIT
-  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
-#endif
-#ifdef SX126X_DIO2_AS_RF_SWITCH
-  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
-#endif
-#ifdef SX126X_RX_BOOSTED_GAIN
-  radio.setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
 #endif
 
-  fast_rng.begin(radio.random(0x7FFFFFFF));
+  if (!radio_init()) { halt(); }
+
+  fast_rng.begin(radio_get_rng_seed());
 
   FILESYSTEM* fs;
 #if defined(NRF52_PLATFORM)
@@ -770,8 +871,11 @@ void setup() {
   #error "need to define filesystem"
 #endif
   if (!store.load("_main", the_mesh.self_id)) {
-    RadioNoiseListener rng(radio);
-    the_mesh.self_id = mesh::LocalIdentity(&rng);  // create new random identity
+    the_mesh.self_id = radio_new_identity();   // create new random identity
+    int count = 0;
+    while (count < 10 && (the_mesh.self_id.pub_key[0] == 0x00 || the_mesh.self_id.pub_key[0] == 0xFF)) {  // reserved id hashes
+      the_mesh.self_id = radio_new_identity(); count++;
+    }
     store.save("_main", the_mesh.self_id);
   }
 
@@ -783,12 +887,11 @@ void setup() {
   the_mesh.begin(fs);
 
 #ifdef DISPLAY_CLASS
-  display.begin();
   ui_task.begin(the_mesh.getNodeName(), FIRMWARE_BUILD_DATE);
 #endif
 
   // send out initial Advertisement to the mesh
-  the_mesh.sendSelfAdvertisement(2000);
+  the_mesh.sendSelfAdvertisement(16000);
 }
 
 void loop() {

examples/simple_secure_chat/main.cpp

@@ -7,14 +7,12 @@
   #include <SPIFFS.h>
 #endif
 
-#define RADIOLIB_STATIC_ONLY 1
-#include <RadioLib.h>
-#include <helpers/RadioLibWrappers.h>
 #include <helpers/ArduinoHelpers.h>
 #include <helpers/StaticPoolPacketManager.h>
 #include <helpers/SimpleMeshTables.h>
 #include <helpers/IdentityStore.h>
 #include <RTClib.h>
+#include <target.h>
 
 /* ---------------------------------- CONFIGURATION ------------------------------------- */
 
@@ -49,39 +47,6 @@
 
 #define  PUBLIC_GROUP_PSK  "izOH6cXN6mrJ5e26oRXNcg=="
 
-#if defined(HELTEC_LORA_V3)
-  #include <helpers/HeltecV3Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static HeltecV3Board board;
-#elif defined(HELTEC_LORA_V2)
-  #include <helpers/HeltecV2Board.h>
-  #include <helpers/CustomSX1276Wrapper.h>
-  static HeltecV2Board board;
-#elif defined(ARDUINO_XIAO_ESP32C3)
-  #include <helpers/XiaoC3Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  #include <helpers/CustomSX1268Wrapper.h>
-  static XiaoC3Board board;
-#elif defined(SEEED_XIAO_S3) || defined(LILYGO_T3S3)
-  #include <helpers/ESP32Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static ESP32Board board;
-#elif defined(LILYGO_TLORA)
-  #include <helpers/LilyGoTLoraBoard.h>
-  #include <helpers/CustomSX1276Wrapper.h>
-  static LilyGoTLoraBoard board;
-#elif defined(RAK_4631)
-  #include <helpers/nrf52/RAK4631Board.h>
-  #include <helpers/CustomSX1262Wrapper.h>
-  static RAK4631Board board;
-#elif defined(T1000_E)
-  #include <helpers/nrf52/T1000eBoard.h>
-  #include <helpers/CustomLR1110Wrapper.h>
-  static T1000eBoard board;
-#else
-  #error "need to provide a 'board' object"
-#endif
-
 // Believe it or not, this std C function is busted on some platforms!
 static uint32_t _atoi(const char* sp) {
   uint32_t n = 0;
@@ -107,7 +72,7 @@ class MyMesh : public BaseChatMesh, ContactVisitor {
   FILESYSTEM* _fs;
   NodePrefs _prefs;
   uint32_t expected_ack_crc;
-  mesh::GroupChannel* _public;
+  ChannelDetails* _public;
   unsigned long last_msg_sent;
   ContactInfo* curr_recipient;
   char command[512+10];
@@ -225,6 +190,10 @@ protected:
     return 0;  // disable rxdelay
   }
 
+  bool allowPacketForward(const mesh::Packet* packet) override {
+    return true;
+  }
+
   void onDiscoveredContact(ContactInfo& contact, bool is_new) override {
     // TODO: if not in favs,  prompt to add as fav(?)
 
@@ -254,8 +223,8 @@ protected:
     return false;
   }
 
-  void onMessageRecv(const ContactInfo& from, uint8_t path_len, uint32_t sender_timestamp, const char *text) override {
-    Serial.printf("(%s) MSG -> from %s\n", path_len == 0xFF ? "DIRECT" : "FLOOD", from.name);
+  void onMessageRecv(const ContactInfo& from, mesh::Packet* pkt, uint32_t sender_timestamp, const char *text) override {
+    Serial.printf("(%s) MSG -> from %s\n", pkt->isRouteDirect() ? "DIRECT" : "FLOOD", from.name);
     Serial.printf("   %s\n", text);
 
     if (strcmp(text, "clock sync") == 0) {  // special text command
@@ -263,16 +232,16 @@ protected:
     }
   }
 
-  void onCommandDataRecv(const ContactInfo& from, uint8_t path_len, uint32_t sender_timestamp, const char *text) override {
+  void onCommandDataRecv(const ContactInfo& from, mesh::Packet* pkt, uint32_t sender_timestamp, const char *text) override {
   }
-  void onSignedMessageRecv(const ContactInfo& from, uint8_t path_len, uint32_t sender_timestamp, const uint8_t *sender_prefix, const char *text) override {
+  void onSignedMessageRecv(const ContactInfo& from, mesh::Packet* pkt, uint32_t sender_timestamp, const uint8_t *sender_prefix, const char *text) override {
   }
 
-  void onChannelMessageRecv(const mesh::GroupChannel& channel, int in_path_len, uint32_t timestamp, const char *text) override {
-    if (in_path_len < 0) {
+  void onChannelMessageRecv(const mesh::GroupChannel& channel, mesh::Packet* pkt, uint32_t timestamp, const char *text) override {
+    if (pkt->isRouteDirect()) {
       Serial.printf("PUBLIC CHANNEL MSG -> (Direct!)\n");
     } else {
-      Serial.printf("PUBLIC CHANNEL MSG -> (Flood) hops %d\n", in_path_len);
+      Serial.printf("PUBLIC CHANNEL MSG -> (Flood) hops %d\n", pkt->path_len);
     }
     Serial.printf("   %s\n", text);
   }
@@ -294,8 +263,7 @@ protected:
   }
 
 public:
-
-  MyMesh(RadioLibWrapper& radio, mesh::RNG& rng, mesh::RTCClock& rtc, SimpleMeshTables& tables)
+  MyMesh(mesh::Radio& radio, StdRNG& rng, mesh::RTCClock& rtc, SimpleMeshTables& tables)
      : BaseChatMesh(radio, *new ArduinoMillis(), rng, rtc, *new StaticPoolPacketManager(16), tables)
   {
     // defaults
@@ -323,7 +291,19 @@ public:
     IdentityStore store(fs, "/identity");
   #endif
     if (!store.load("_main", self_id, _prefs.node_name, sizeof(_prefs.node_name))) {  // legacy: node_name was from identity file
+      // Need way to get some entropy to seed RNG
+      Serial.println("Press ENTER to generate key:");
+      char c = 0;
+      while (c != '\n') {   // wait for ENTER to be pressed
+        if (Serial.available()) c = Serial.read();
+      }
+      ((StdRNG *)getRNG())->begin(millis());
+
       self_id = mesh::LocalIdentity(getRNG());  // create new random identity
+      int count = 0;
+      while (count < 10 && (self_id.pub_key[0] == 0x00 || self_id.pub_key[0] == 0xFF)) {  // reserved id hashes
+        self_id = mesh::LocalIdentity(getRNG()); count++;
+      }
       store.save("_main", self_id);
     }
 
@@ -337,7 +317,7 @@ public:
     }
 
     loadContacts();
-    _public = addChannel(PUBLIC_GROUP_PSK); // pre-configure Andy's public channel
+    _public = addChannel("Public", PUBLIC_GROUP_PSK); // pre-configure Andy's public channel
   }
 
   void savePrefs() {
@@ -357,6 +337,8 @@ public:
     Serial.println("===== MeshCore Chat Terminal =====");
     Serial.println();
     Serial.printf("WELCOME  %s\n", _prefs.node_name);
+    mesh::Utils::printHex(Serial, self_id.pub_key, PUB_KEY_SIZE);
+    Serial.println();
     Serial.println("   (enter 'help' for basic commands)");
     Serial.println();
   }
@@ -405,7 +387,7 @@ public:
       temp[5 + MAX_TEXT_LEN] = 0;  // truncate if too long
 
       int len = strlen((char *) &temp[5]);
-      auto pkt = createGroupDatagram(PAYLOAD_TYPE_GRP_TXT, *_public, temp, 5 + len);
+      auto pkt = createGroupDatagram(PAYLOAD_TYPE_GRP_TXT, _public->channel, temp, 5 + len);
       if (pkt) {
         sendFlood(pkt);
         Serial.println("   Sent.");
@@ -543,20 +525,9 @@ public:
   }
 };
 
-#if defined(NRF52_PLATFORM)
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI);
-#elif defined(LILYGO_TLORA)
-SPIClass spi;
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_0, P_LORA_RESET, P_LORA_DIO_1, spi);
-#elif defined(P_LORA_SCLK)
-SPIClass spi;
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, spi);
-#else
-RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY);
-#endif
 StdRNG fast_rng;
 SimpleMeshTables tables;
-MyMesh the_mesh(*new WRAPPER_CLASS(radio, board), fast_rng, *new VolatileRTCClock(), tables);
+MyMesh the_mesh(radio_driver, fast_rng, *new VolatileRTCClock(), tables); // TODO: test with 'rtc_clock' in target.cpp
 
 void halt() {
   while (1) ;
@@ -566,36 +537,10 @@ void setup() {
   Serial.begin(115200);
 
   board.begin();
-#ifdef SX126X_DIO3_TCXO_VOLTAGE
-  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
-#else
-  float tcxo = 1.6f;
-#endif
 
-#if defined(NRF52_PLATFORM)
-  SPI.setPins(P_LORA_MISO, P_LORA_SCLK, P_LORA_MOSI);
-  SPI.begin();
-#elif defined(P_LORA_SCLK)
-  spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI);
-#endif
-  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
-  if (status != RADIOLIB_ERR_NONE) {
-    Serial.print("ERROR: radio init failed: ");
-    Serial.println(status);
-    halt();
-  }
+  if (!radio_init()) { halt(); }
 
-  radio.setCRC(1);
-
-#ifdef SX126X_CURRENT_LIMIT
-  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
-#endif
-
-#ifdef SX126X_DIO2_AS_RF_SWITCH
-  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
-#endif
-
-  fast_rng.begin(radio.random(0x7FFFFFFF));
+  fast_rng.begin(radio_get_rng_seed());
 
 #if defined(NRF52_PLATFORM)
   InternalFS.begin();
@@ -607,12 +552,8 @@ void setup() {
   #error "need to define filesystem"
 #endif
 
-  if (LORA_FREQ != the_mesh.getFreqPref()) {
-    radio.setFrequency(the_mesh.getFreqPref());
-  }
-  if (LORA_TX_POWER != the_mesh.getTxPowerPref()) {
-    radio.setOutputPower(the_mesh.getTxPowerPref());
-  }
+  radio_set_params(the_mesh.getFreqPref(), LORA_BW, LORA_SF, LORA_CR);
+  radio_set_tx_power(the_mesh.getTxPowerPref());
 
   the_mesh.showWelcome();
 

platformio.ini

@@ -8,6 +8,10 @@
 ; Please visit documentation for the other options and examples
 ; https://docs.platformio.org/page/projectconf.html
 
+[platformio]
+extra_configs =
+	variants/*/platformio.ini
+
 [arduino_base]
 framework = arduino
 monitor_speed = 115200
@@ -19,606 +23,28 @@ lib_deps =
   adafruit/RTClib @ ^2.1.3
   melopero/Melopero RV3028 @ ^1.1.0
 build_flags = -w -DNDEBUG -DRADIOLIB_STATIC_ONLY=1 -DRADIOLIB_GODMODE=1
-  -D LORA_FREQ=867.5
+  -D LORA_FREQ=869.525
   -D LORA_BW=250
-  -D LORA_SF=10
+  -D LORA_SF=11
 build_src_filter =
   +<*.cpp>
   +<helpers/*.cpp>
 
+; ----------------- ESP32 ---------------------
+
 [esp32_base]
 extends = arduino_base
 platform = espressif32
 monitor_filters = esp32_exception_decoder
 extra_scripts = merge-bin.py
+build_flags = ${arduino_base.build_flags}
+;  -D ESP32_CPU_FREQ=80          ; change it to your need
 build_src_filter = ${arduino_base.build_src_filter}
 
-; ================
-[Heltec_lora32_v2]
-extends = esp32_base
-board = heltec_wifi_lora_32_V2   ; heltec_wifi_lora_32_V2
-build_flags =
-  ${esp32_base.build_flags}
-  -D HELTEC_LORA_V2
-  -D RADIO_CLASS=CustomSX1276
-  -D WRAPPER_CLASS=CustomSX1276Wrapper
-  -D LORA_TX_POWER=20
-  -D P_LORA_TX_LED=25
-build_src_filter = ${esp32_base.build_src_filter}
-
-[env:Heltec_v2_repeater]
-extends = Heltec_lora32_v2
-build_flags =
-  ${Heltec_lora32_v2.build_flags}
-  -D ADVERT_NAME="\"Heltec Repeater\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_lora32_v2.build_src_filter}
-  +<../examples/simple_repeater/main.cpp>
-
-[env:Heltec_v2_terminal_chat]
-extends = Heltec_lora32_v2
-build_flags =
-  ${Heltec_lora32_v2.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_lora32_v2.build_src_filter}
-  +<../examples/simple_secure_chat/main.cpp>
+[esp32_ota]
 lib_deps =
-  ${Heltec_lora32_v2.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:Heltec_v2_companion_radio_usb]
-extends = Heltec_lora32_v2
-build_flags =
-  ${Heltec_lora32_v2.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
-; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_lora32_v2.build_src_filter}
-  +<helpers/esp32/*.cpp>
-  +<../examples/companion_radio/main.cpp>
-lib_deps =
-  ${Heltec_lora32_v2.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:Heltec_v2_companion_radio_ble]
-extends = Heltec_lora32_v2
-build_flags =
-  ${Heltec_lora32_v2.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D BLE_PIN_CODE=123456
-  -D BLE_DEBUG_LOGGING=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_lora32_v2.build_src_filter}
-  +<helpers/esp32/*.cpp>
-  +<../examples/companion_radio/main.cpp>
-lib_deps =
-  ${Heltec_lora32_v2.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-
-; ================
-[Heltec_lora32_v3]
-extends = esp32_base
-board = esp32-s3-devkitc-1
-build_flags =
-  ${esp32_base.build_flags}
-  -D HELTEC_LORA_V3
-  -D RADIO_CLASS=CustomSX1262
-  -D WRAPPER_CLASS=CustomSX1262Wrapper
-  -D LORA_TX_POWER=22
-  -D P_LORA_TX_LED=35
-  -D PIN_BOARD_SDA=17
-  -D PIN_BOARD_SCL=18
-  -D PIN_USER_BTN=0
-  -D SX126X_DIO2_AS_RF_SWITCH=true
-  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
-  -D SX126X_CURRENT_LIMIT=130.0f  ; for best TX power!
-  -D SX126X_RX_BOOSTED_GAIN=true
-build_src_filter = ${esp32_base.build_src_filter}
-lib_deps =
-  ${esp32_base.lib_deps}
-	adafruit/Adafruit SSD1306 @ ^2.5.13
-
-[env:Heltec_v3_repeater]
-extends = Heltec_lora32_v3
-build_flags =
-  ${Heltec_lora32_v3.build_flags}
-  -D DISPLAY_CLASS=SSD1306Display
-  -D ADVERT_NAME="\"Heltec Repeater\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_lora32_v3.build_src_filter}
-  +<helpers/ui/*.cpp>
-  +<../examples/simple_repeater>
-
-[env:Heltec_v3_room_server]
-extends = Heltec_lora32_v3
-build_src_filter = ${Heltec_lora32_v3.build_src_filter}
-  +<helpers/ui/*.cpp>
-  +<../examples/simple_room_server>
-build_flags =
-  ${Heltec_lora32_v3.build_flags}
-  -D DISPLAY_CLASS=SSD1306Display
-  -D ADVERT_NAME="\"Heltec Room\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-  -D ROOM_PASSWORD="\"hello\""
-  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-
-[env:Heltec_v3_terminal_chat]
-extends = Heltec_lora32_v3
-build_flags =
-  ${Heltec_lora32_v3.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_lora32_v3.build_src_filter}
-  +<../examples/simple_secure_chat/main.cpp>
-lib_deps =
-  ${Heltec_lora32_v3.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:Heltec_v3_companion_radio_usb]
-extends = Heltec_lora32_v3
-build_flags =
-  ${Heltec_lora32_v3.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D DISPLAY_CLASS=SSD1306Display
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
-; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_lora32_v3.build_src_filter}
-  +<helpers/ui/*.cpp>
-  +<../examples/companion_radio>
-lib_deps =
-  ${Heltec_lora32_v3.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:Heltec_v3_companion_radio_ble]
-extends = Heltec_lora32_v3
-build_flags =
-  ${Heltec_lora32_v3.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D DISPLAY_CLASS=SSD1306Display
-  -D BLE_PIN_CODE=0   ; dynamic, random PIN
-  -D BLE_DEBUG_LOGGING=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_lora32_v3.build_src_filter}
-  +<helpers/ui/*.cpp>
-  +<helpers/esp32/*.cpp>
-  +<../examples/companion_radio>
-lib_deps =
-  ${Heltec_lora32_v3.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:Heltec_WSL3_companion_radio_ble]
-extends = Heltec_lora32_v3
-build_flags =
-  ${Heltec_lora32_v3.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D BLE_PIN_CODE=123456
-  -D BLE_DEBUG_LOGGING=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_lora32_v3.build_src_filter}
-  +<helpers/esp32/*.cpp>
-  +<../examples/companion_radio>
-lib_deps =
-  ${Heltec_lora32_v3.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:Heltec_v3_companion_radio_wifi]
-extends = Heltec_lora32_v3
-build_flags =
-  ${Heltec_lora32_v3.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D DISPLAY_CLASS=SSD1306Display
-  -D WIFI_DEBUG_LOGGING=1
-  -D WIFI_SSID="\"myssid\""
-  -D WIFI_PWD="\"mypwd\""
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_lora32_v3.build_src_filter}
-  +<helpers/ui/*.cpp>
-  +<helpers/esp32/*.cpp>
-  +<../examples/companion_radio>
-lib_deps =
-  ${Heltec_lora32_v3.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-; ================
-[Xiao_esp32_C3]
-extends = esp32_base
-board = seeed_xiao_esp32c3
-build_flags =
-  ${esp32_base.build_flags}
-  -D LORA_TX_BOOST_PIN=D3
-  -D P_LORA_TX_LED=D5
-  -D PIN_VBAT_READ=D0
-  -D P_LORA_DIO_1=D2
-  -D P_LORA_NSS=D4
-  -D P_LORA_RESET=RADIOLIB_NC
-  -D P_LORA_BUSY=D1
-  -D PIN_BOARD_SDA=D6
-  -D PIN_BOARD_SCL=D7
-  -D SX126X_DIO2_AS_RF_SWITCH=true
-  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
-  -D SX126X_CURRENT_LIMIT=130.0f  ; for best TX power!
-
-[env:Xiao_C3_Repeater_sx1262]
-extends = Xiao_esp32_C3
-build_src_filter = ${Xiao_esp32_C3.build_src_filter}
-  +<../examples/simple_repeater/main.cpp>
-build_flags =
-  ${Xiao_esp32_C3.build_flags}
-  -D RADIO_CLASS=CustomSX1262
-  -D WRAPPER_CLASS=CustomSX1262Wrapper
-  -D LORA_TX_POWER=22
-  -D ADVERT_NAME="\"Xiao Repeater\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-
-[env:Xiao_C3_Repeater_sx1268]
-extends = Xiao_esp32_C3
-build_src_filter = ${Xiao_esp32_C3.build_src_filter}
-  +<../examples/simple_repeater/main.cpp>
-build_flags =
-  ${Xiao_esp32_C3.build_flags}
-  -D RADIO_CLASS=CustomSX1268
-  -D WRAPPER_CLASS=CustomSX1268Wrapper
-  -D LORA_TX_POWER=22
-  -D ADVERT_NAME="\"Xiao Repeater\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
- ; -D MESH_PACKET_LOGGING=1
- ; -D MESH_DEBUG=1
-
-; =============
-[Xiao_S3_WIO]
-extends = esp32_base
-board = seeed_xiao_esp32s3
-board_check = true
-board_build.mcu = esp32s3
-build_flags = ${esp32_base.build_flags}
-  -D SEEED_XIAO_S3
-  -D P_LORA_DIO_1=39
-  -D P_LORA_NSS=41
-  -D P_LORA_RESET=42   ; RADIOLIB_NC
-  -D P_LORA_BUSY=40   ;  DIO2 = 38
-  -D P_LORA_SCLK=7
-  -D P_LORA_MISO=8
-  -D P_LORA_MOSI=9
-  -D SX126X_DIO2_AS_RF_SWITCH=true
-  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
-  -D SX126X_CURRENT_LIMIT=130
-  -D RADIO_CLASS=CustomSX1262
-  -D WRAPPER_CLASS=CustomSX1262Wrapper
-  -D LORA_TX_POWER=22
-
-[env:Xiao_S3_WIO_Repeater]
-extends = Xiao_S3_WIO
-build_src_filter = ${Xiao_S3_WIO.build_src_filter}
-  +<../examples/simple_repeater/main.cpp>
-build_flags =
-  ${Xiao_S3_WIO.build_flags}
-  -D ADVERT_NAME="\"XiaoS3 Repeater\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-
-[env:Xiao_S3_WIO_terminal_chat]
-extends = Xiao_S3_WIO
-build_flags =
-  ${Xiao_S3_WIO.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Xiao_S3_WIO.build_src_filter}
-  +<../examples/simple_secure_chat/main.cpp>
-lib_deps =
-  ${Xiao_S3_WIO.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:Xiao_S3_WIO_companion_radio_ble]
-extends = Xiao_S3_WIO
-build_flags =
-  ${Xiao_S3_WIO.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D BLE_PIN_CODE=123456
-;  -D BLE_DEBUG_LOGGING=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Xiao_S3_WIO.build_src_filter}
-  +<helpers/esp32/*.cpp>
-  +<../examples/companion_radio/main.cpp>
-lib_deps =
-  ${Xiao_S3_WIO.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-; =============
-[LilyGo_TLora_V2_1_1_6]
-extends = esp32_base
-board = ttgo-lora32-v1  ; LILYGO T-LoRa V2.1-1.6 ESP32 with SX1276
-build_unflags = -Os
-build_type = release  ; Set build type to release
-board_build.partitions = min_spiffs.csv ; get around 4mb flash limit
-build_flags =
-  ${esp32_base.build_flags}
-  -Os -ffunction-sections -fdata-sections  ; Optimize for size
-  -D LILYGO_TLORA  ; LILYGO T-LoRa V2.1-1.6 ESP32 with SX1276
-  -D P_LORA_DIO_0=26    ; SX1276 DIO0 interrupt pin
-  -D P_LORA_DIO_1=33    ; SX1276 DIO1 interrupt pin
-  -D P_LORA_NSS=18      ; Chip select - SS pin
-  -D P_LORA_RESET=14    ; Reset pin
-  -D P_LORA_SCLK=5      ; SPI clock
-  -D P_LORA_MISO=19     ; SPI MISO
-  -D P_LORA_MOSI=27     ; SPI MOSI
-  -D P_LORA_TX_LED=2    ; LED pin for TX indication
-  -D PIN_VBAT_READ=35   ; Battery voltage reading (analog pin)
-  -D PIN_USER_BTN=0
-  -D RADIO_CLASS=CustomSX1276
-  -D ARDUINO_LOOP_STACK_SIZE=16384
-  -D DISPLAY_CLASS=SSD1306Display
-  -D WRAPPER_CLASS=CustomSX1276Wrapper
-  -D LORA_TX_POWER=20
-lib_deps =
-  ${esp32_base.lib_deps}
-  adafruit/Adafruit SSD1306 @ ^2.5.13
-
-; === LILYGO T-LoRa V2.1-1.6 with SX1276 environments ===
-[env:LilyGo_TLora_V2_1_1_6_Repeater]
-extends = LilyGo_TLora_V2_1_1_6
-build_src_filter = ${LilyGo_TLora_V2_1_1_6.build_src_filter}
-  +<helpers/ui/*.cpp>
-  +<../examples/simple_repeater>
-build_flags =
-  ${LilyGo_TLora_V2_1_1_6.build_flags}
-  -D ADVERT_NAME="\"TLora-V2.1-1.6 Repeater\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-;  -D CORE_DEBUG_LEVEL=3
-
-[env:LilyGo_TLora_V2_1_1_6_terminal_chat]
-extends = LilyGo_TLora_V2_1_1_6
-build_flags =
-  ${LilyGo_TLora_V2_1_1_6.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${LilyGo_TLora_V2_1_1_6.build_src_filter}
-  +<helpers/ui/*.cpp>
-  +<../examples/simple_repeater>
-lib_deps =
-  ${LilyGo_TLora_V2_1_1_6.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:LilyGo_TLora_V2_1_1_6_companion_radio_usb]
-extends = LilyGo_TLora_V2_1_1_6
-build_flags =
-  ${LilyGo_TLora_V2_1_1_6.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
-; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
-build_src_filter = ${LilyGo_TLora_V2_1_1_6.build_src_filter}
-  +<helpers/ui/*.cpp>
-  +<../examples/companion_radio>
-lib_deps =
-  ${LilyGo_TLora_V2_1_1_6.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:LilyGo_TLora_V2_1_1_6_companion_radio_ble]
-extends = LilyGo_TLora_V2_1_1_6
-build_flags =
-  ${LilyGo_TLora_V2_1_1_6.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D BLE_PIN_CODE=123456
-;  -D BLE_DEBUG_LOGGING=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${LilyGo_TLora_V2_1_1_6.build_src_filter}
-  +<helpers/esp32/*.cpp>
-  +<helpers/ui/*.cpp>
-  +<../examples/companion_radio>
-lib_deps =
-  ${LilyGo_TLora_V2_1_1_6.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:LilyGo_TLora_V2_1_1_6_room_server]
-extends = LilyGo_TLora_V2_1_1_6
-build_src_filter = ${LilyGo_TLora_V2_1_1_6.build_src_filter}
-  +<helpers/ui/*.cpp>
-  +<../examples/simple_room_server>
-build_flags =
-  ${LilyGo_TLora_V2_1_1_6.build_flags}
-  -D ADVERT_NAME="\"TLora-V2.1-1.6 Room\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-  -D ROOM_PASSWORD="\"hello\""
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-
-; =============
-[LilyGo_T3S3_sx1262]
-extends = esp32_base
-board = t3_s3_v1_x
-build_flags = ${esp32_base.build_flags}
-  -D LILYGO_T3S3
-  -D P_LORA_DIO_1=33
-  -D P_LORA_NSS=7
-  -D P_LORA_RESET=8   ; RADIOLIB_NC
-  -D P_LORA_BUSY=34
-  -D P_LORA_SCLK=5
-  -D P_LORA_MISO=3
-  -D P_LORA_MOSI=6
-  -D P_LORA_TX_LED=37
-  -D PIN_VBAT_READ=1
-  -D SX126X_DIO2_AS_RF_SWITCH=true
-  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
-  -D SX126X_CURRENT_LIMIT=130
-  -D RADIO_CLASS=CustomSX1262
-  -D WRAPPER_CLASS=CustomSX1262Wrapper
-  -D LORA_TX_POWER=22
-
-; === LilyGo T3S3 with SX1262 environments ===
-[env:LilyGo_T3S3_sx1262_Repeater]
-extends = LilyGo_T3S3_sx1262
-build_src_filter = ${LilyGo_T3S3_sx1262.build_src_filter}
-  +<../examples/simple_repeater/main.cpp>
-build_flags =
-  ${LilyGo_T3S3_sx1262.build_flags}
-  -D ADVERT_NAME="\"T3S3-1262 Repeater\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-
-[env:LilyGo_T3S3_sx1262_terminal_chat]
-extends = LilyGo_T3S3_sx1262
-build_flags =
-  ${LilyGo_T3S3_sx1262.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${LilyGo_T3S3_sx1262.build_src_filter}
-  +<../examples/simple_secure_chat/main.cpp>
-lib_deps =
-  ${LilyGo_T3S3_sx1262.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:LilyGo_T3S3_sx1262_companion_radio_usb]
-extends = LilyGo_T3S3_sx1262
-build_flags =
-  ${LilyGo_T3S3_sx1262.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
-; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
-build_src_filter = ${LilyGo_T3S3_sx1262.build_src_filter}
-  +<../examples/companion_radio/main.cpp>
-lib_deps =
-  ${LilyGo_T3S3_sx1262.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:LilyGo_T3S3_sx1262_companion_radio_ble]
-extends = LilyGo_T3S3_sx1262
-build_flags =
-  ${LilyGo_T3S3_sx1262.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D BLE_PIN_CODE=123456
-  -D BLE_DEBUG_LOGGING=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${LilyGo_T3S3_sx1262.build_src_filter}
-  +<helpers/esp32/*.cpp>
-  +<../examples/companion_radio/main.cpp>
-lib_deps =
-  ${LilyGo_T3S3_sx1262.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[Station_G2]
-extends = esp32_base
-board = station-g2
-build_flags =
-  ${esp32_base.build_flags}
-  -D STATION_G2
-  -D RADIO_CLASS=CustomSX1262
-  -D WRAPPER_CLASS=CustomSX1262Wrapper
-  -D LORA_TX_POWER=7
-;  -D P_LORA_TX_LED=35
-;  -D PIN_BOARD_SDA=5
-;  -D PIN_BOARD_SCL=6
-  -D PIN_USER_BTN=0
-  -D SX126X_DIO2_AS_RF_SWITCH=true
-  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
-  -D SX126X_CURRENT_LIMIT=130.0f  ; for best TX power!
-build_src_filter = ${esp32_base.build_src_filter}
-lib_deps =
-  ${esp32_base.lib_deps}
-
-[env:Station_G2_repeater]
-extends = Station_G2
-build_flags =
-  ${Station_G2.build_flags}
-  -D ADVERT_NAME="\"Station G2 Repeater\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Station_G2.build_src_filter}
-  +<../examples/simple_repeater>
-
-[env:Station_G2_room_server]
-extends = Station_G2
-build_src_filter = ${Station_G2.build_src_filter}
-  +<../examples/simple_room_server>
-build_flags =
-  ${Station_G2.build_flags}
-  -D ADVERT_NAME="\"Station G2 Room\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-  -D ROOM_PASSWORD="\"hello\""
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
+  me-no-dev/ESPAsyncWebServer @ ^3.6.0
+  file://arch/esp32/AsyncElegantOTA
 
 ; ----------------- NRF52 ---------------------
 [nrf52_base]
@@ -634,263 +60,3 @@ lib_deps =
   ${nrf52_base.lib_deps}
   rweather/Crypto @ ^0.4.0
   https://github.com/adafruit/Adafruit_nRF52_Arduino
-
-[rak4631]
-extends = nrf52840_base
-platform = https://github.com/maxgerhardt/platform-nordicnrf52.git#rak
-board = wiscore_rak4631
-board_check = true
-build_src_filter = ${nrf52840_base.build_src_filter}
-  +<helpers/nrf52/*.cpp>
-build_flags = ${nrf52840_base.build_flags}
-  -D RAK_4631
-  -D RADIO_CLASS=CustomSX1262
-  -D WRAPPER_CLASS=CustomSX1262Wrapper
-  -D LORA_TX_POWER=22
-  -D SX126X_CURRENT_LIMIT=130
-
-[env:RAK_4631_Repeater]
-extends = rak4631
-build_src_filter = ${rak4631.build_src_filter}
-  +<../examples/simple_repeater/main.cpp>
-build_flags =
-  ${rak4631.build_flags}
-  -D ADVERT_NAME="\"RAK4631 Repeater\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-
-[env:RAK_4631_room_server]
-extends = rak4631
-build_src_filter = ${rak4631.build_src_filter}
-  +<../examples/simple_room_server/main.cpp>
-build_flags =
-  ${rak4631.build_flags}
-  -D ADVERT_NAME="\"Test Room\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-  -D ROOM_PASSWORD="\"hello\""
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-
-[env:RAK_4631_terminal_chat]
-extends = rak4631
-build_flags =
-  ${rak4631.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D MESH_PACKET_LOGGING=1
-  -D MESH_DEBUG=1
-build_src_filter = ${rak4631.build_src_filter}
-  +<../examples/simple_secure_chat/main.cpp>
-lib_deps =
-  ${rak4631.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:RAK_4631_companion_radio_usb]
-extends = rak4631
-build_flags =
-  ${rak4631.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
-; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
-build_src_filter = ${rak4631.build_src_filter}
-  +<../examples/companion_radio/main.cpp>
-lib_deps =
-  ${rak4631.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[env:RAK_4631_companion_radio_ble]
-extends = rak4631
-build_flags =
-  ${rak4631.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D BLE_PIN_CODE=123456
-  -D BLE_DEBUG_LOGGING=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${rak4631.build_src_filter}
-  +<helpers/nrf52/*.cpp>
-  +<../examples/companion_radio/main.cpp>
-lib_deps =
-  ${rak4631.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-; ----------------- NRF52 T1000e---------------------
-[nrf52840_t1000e]
-extends = nrf52_base
-platform_packages = framework-arduinoadafruitnrf52
-build_flags = ${nrf52_base.build_flags}
-  -I src/helpers/nrf52
-  -I lib/nrf52/s140_nrf52_7.3.0_API/include
-  -I lib/nrf52/s140_nrf52_7.3.0_API/include/nrf52
-lib_ignore =
-  BluetoothOTA
-  lvgl
-  lib5b4
-lib_deps =
-  ${nrf52_base.lib_deps}
-  rweather/Crypto @ ^0.4.0
-
-[t1000-e]
-extends = nrf52840_t1000e
-board = tracker-t1000-e
-board_build.ldscript = boards/nrf52840_s140_v7.ld
-build_flags = ${nrf52840_t1000e.build_flags}
-  -Ivariants/t1000-e
-  -DT1000_E
-  -D PIN_USER_BTN=6
-  -D RADIO_CLASS=CustomLR1110
-  -D WRAPPER_CLASS=CustomLR1110Wrapper
-build_src_filter = ${nrf52840_t1000e.build_src_filter}
-  +<helpers/*.cpp>
-  +<helpers/nrf52/T1000eBoard.cpp>
-  +<../variants/t1000-e>
-debug_tool = jlink
-upload_protocol = nrfutil
-
-[env:t1000e_companion_radio_ble]
-extends = t1000-e
-build_flags = ${t1000-e.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D BLE_PIN_CODE=123456
-  -D BLE_DEBUG_LOGGING=1
-  -D MESH_PACKET_LOGGING=1
-  -D MESH_DEBUG=1
-build_src_filter = ${t1000-e.build_src_filter}
-  +<helpers/nrf52/SerialBLEInterface.cpp>
-  +<../examples/companion_radio/*.cpp>
-lib_deps = ${t1000-e.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[nrf52840_t114]
-extends = nrf52_base
-platform_packages = framework-arduinoadafruitnrf52
-build_flags = ${nrf52_base.build_flags}
-  -I src/helpers/nrf52
-  -I lib/nrf52/s140_nrf52_6.1.1_API/include
-  -I lib/nrf52/s140_nrf52_6.1.1_API/include/nrf52
-lib_deps =
-  ${nrf52_base.lib_deps}
-  rweather/Crypto @ ^0.4.0
-
-[Heltec_t114]
-extends = nrf52840_t114
-board = heltec_t114
-board_build.ldscript = boards/nrf52840_s140_v6.ld
-build_flags = ${nrf52840_t114.build_flags}
-  -Ivariants/t114
-  -DHELTEC_T114
-  -D P_LORA_TX_LED=35
-  -D RADIO_CLASS=CustomSX1262
-  -D WRAPPER_CLASS=CustomSX1262Wrapper
-  -D LORA_TX_POWER=22
-  -D SX126X_CURRENT_LIMIT=130
-build_src_filter = ${nrf52840_t114.build_src_filter}
-  +<helpers/*.cpp>
-  +<helpers/nrf52/T114Board.cpp>
-  +<../variants/t114>
-debug_tool = jlink
-upload_protocol = nrfutil
-
-[env:Heltec_t114_repeater]
-extends = Heltec_t114
-build_src_filter = ${Heltec_t114.build_src_filter}
-  +<../examples/simple_repeater/main.cpp>
-build_flags =
-  ${Heltec_t114.build_flags}
-  -D ADVERT_NAME="\"Heltec_T114 Repeater\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-
-[env:Heltec_t114_companion_radio_ble]
-extends = Heltec_t114
-build_flags =
-  ${Heltec_t114.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D BLE_PIN_CODE=123456
-  -D BLE_DEBUG_LOGGING=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${Heltec_t114.build_src_filter}
-  +<helpers/nrf52/*.cpp>
-  +<../examples/companion_radio/main.cpp>
-lib_deps =
-  ${Heltec_t114.lib_deps}
-  densaugeo/base64 @ ~1.4.0
-
-[nrf52840_techo]
-extends = nrf52_base
-platform_packages = framework-arduinoadafruitnrf52
-build_flags = ${nrf52_base.build_flags}
-  -I src/helpers/nrf52
-  -I lib/nrf52/s140_nrf52_6.1.1_API/include
-  -I lib/nrf52/s140_nrf52_6.1.1_API/include/nrf52
-lib_deps =
-  ${nrf52_base.lib_deps}
-  rweather/Crypto @ ^0.4.0
-
-[LilyGo_Techo]
-extends = nrf52840_techo
-board = t-echo
-board_build.ldscript = boards/nrf52840_s140_v6.ld
-build_flags = ${nrf52840_techo.build_flags}
-  -Ivariants/techo
-  -DLILYGO_TECHO
-  -D RADIO_CLASS=CustomSX1262
-  -D WRAPPER_CLASS=CustomSX1262Wrapper
-  -D LORA_TX_POWER=22
-  -D SX126X_CURRENT_LIMIT=130
-build_src_filter = ${nrf52840_techo.build_src_filter}
-  +<helpers/*.cpp>
-  +<helpers/nrf52/TechoBoard.cpp>
-  +<../variants/techo>
-debug_tool = jlink
-upload_protocol = nrfutil
-
-[env:LilyGo_T-Echo_repeater]
-extends = LilyGo_Techo
-build_src_filter = ${LilyGo_Techo.build_src_filter} +<../examples/simple_repeater/main.cpp>
-build_flags =
-  ${LilyGo_Techo.build_flags}
-  -D ADVERT_NAME="\"T-Echo Repeater\""
-  -D ADVERT_LAT=-37.0
-  -D ADVERT_LON=145.0
-  -D ADMIN_PASSWORD="\"password\""
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-
-[env:LilyGo_T-Echo_companion_radio_ble]
-extends = LilyGo_Techo
-build_flags =
-  ${LilyGo_Techo.build_flags}
-  -D MAX_CONTACTS=100
-  -D MAX_GROUP_CHANNELS=1
-  -D BLE_PIN_CODE=123456
-  -D BLE_DEBUG_LOGGING=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
-;  -D MESH_PACKET_LOGGING=1
-;  -D MESH_DEBUG=1
-build_src_filter = ${LilyGo_Techo.build_src_filter}
-  +<helpers/nrf52/*.cpp>
-  +<../examples/companion_radio/main.cpp>
-lib_deps =
-  ${LilyGo_Techo.lib_deps}
-  densaugeo/base64 @ ~1.4.0

src/Dispatcher.cpp

@@ -29,6 +29,9 @@ int Dispatcher::calcRxDelay(float score, uint32_t air_time) const {
 uint32_t Dispatcher::getCADFailRetryDelay() const {
   return 200;
 }
+uint32_t Dispatcher::getCADFailMaxDuration() const {
+  return 4000;   // 4 seconds
+}
 
 void Dispatcher::loop() {
   if (outbound) {  // waiting for outbound send to be completed
@@ -115,6 +118,7 @@ void Dispatcher::checkRecv() {
           } else {
             memcpy(pkt->payload, &raw[i], pkt->payload_len);
 
+            pkt->_snr = _radio->getLastSNR() * 4.0f;
             score = _radio->packetScore(_radio->getLastSNR(), len);
             air_time = _radio->getEstAirtimeFor(len);
           }
@@ -129,7 +133,7 @@ void Dispatcher::checkRecv() {
     Serial.print(getLogDateTime());
     Serial.printf(": RX, len=%d (type=%d, route=%s, payload_len=%d) SNR=%d RSSI=%d score=%d", 
             2 + pkt->path_len + pkt->payload_len, pkt->getPayloadType(), pkt->isRouteDirect() ? "D" : "F", pkt->payload_len,
-            (int)_radio->getLastSNR(), (int)_radio->getLastRSSI(), (int)(score*1000));
+            (int)pkt->getSNR(), (int)_radio->getLastRSSI(), (int)(score*1000));
 
     static uint8_t packet_hash[MAX_HASH_SIZE];
     pkt->calculatePacketHash(packet_hash);
@@ -184,9 +188,20 @@ void Dispatcher::checkSend() {
   if (_mgr->getOutboundCount() == 0) return;  // nothing waiting to send
   if (!millisHasNowPassed(next_tx_time)) return;   // still in 'radio silence' phase (from airtime budget setting)
   if (_radio->isReceiving()) {   // LBT - check if radio is currently mid-receive, or if channel activity
-    next_tx_time = futureMillis(getCADFailRetryDelay());
-    return; 
+    if (cad_busy_start == 0) {
+      cad_busy_start = _ms->getMillis();   // record when CAD busy state started
+    }
+
+    if (_ms->getMillis() - cad_busy_start > getCADFailMaxDuration()) {
+      MESH_DEBUG_PRINTLN("%s Dispatcher::checkSend(): CAD busy max duration reached!", getLogDateTime());
+      // channel activity has gone on too long... (Radio might be in a bad state)
+      // force the pending transmit below...
+    } else {
+      next_tx_time = futureMillis(getCADFailRetryDelay());
+      return;
+    }
   }
+  cad_busy_start = 0;  // reset busy state
 
   outbound = _mgr->getNextOutbound(_ms->getMillis());
   if (outbound) {
@@ -233,6 +248,7 @@ Packet* Dispatcher::obtainNewPacket() {
     n_full_events++;
   } else {
     pkt->payload_len = pkt->path_len = 0;
+    pkt->_snr = 0;
   }
   return pkt;
 }

src/Dispatcher.h

@@ -98,6 +98,7 @@ class Dispatcher {
   Packet* outbound;  // current outbound packet
   unsigned long outbound_expiry, outbound_start, total_air_time;
   unsigned long next_tx_time;
+  unsigned long cad_busy_start;
   uint32_t n_sent_flood, n_sent_direct;
   uint32_t n_recv_flood, n_recv_direct;
   uint32_t n_full_events;
@@ -113,6 +114,7 @@ protected:
     : _radio(&radio), _ms(&ms), _mgr(&mgr)
   {
     outbound = NULL; total_air_time = 0; next_tx_time = 0;
+    cad_busy_start = 0;
   }
 
   virtual DispatcherAction onRecvPacket(Packet* pkt) = 0;
@@ -127,6 +129,7 @@ protected:
   virtual float getAirtimeBudgetFactor() const;
   virtual int calcRxDelay(float score, uint32_t air_time) const;
   virtual uint32_t getCADFailRetryDelay() const;
+  virtual uint32_t getCADFailMaxDuration() const;
 
 public:
   void begin();

src/Identity.cpp

@@ -2,6 +2,7 @@
 #include <string.h>
 #define ED25519_NO_SEED  1
 #include <ed_25519.h>
+#include <Ed25519.h>
 
 namespace mesh {
 
@@ -14,7 +15,12 @@ Identity::Identity(const char* pub_hex) {
 }
 
 bool Identity::verify(const uint8_t* sig, const uint8_t* message, int msg_len) const {
+#if 0
+  // NOTE:  memory corruption bug was found in this function!!
   return ed25519_verify(sig, message, msg_len, pub_key);
+#else
+  return Ed25519::verify(sig, this->pub_key, message, msg_len);
+#endif
 }
 
 bool Identity::readFrom(Stream& s) {

src/Mesh.cpp

@@ -41,6 +41,30 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
     return ACTION_RELEASE;
   }
 
+  if (pkt->isRouteDirect() && pkt->getPayloadType() == PAYLOAD_TYPE_TRACE) {
+    if (pkt->path_len < MAX_PATH_SIZE) {
+      uint8_t i = 0;
+      uint32_t trace_tag;
+      memcpy(&trace_tag, &pkt->payload[i], 4); i += 4;
+      uint32_t auth_code;
+      memcpy(&auth_code, &pkt->payload[i], 4); i += 4;
+      uint8_t flags = pkt->payload[i++];
+
+      uint8_t len = pkt->payload_len - i;
+      if (pkt->path_len >= len) {   // TRACE has reached end of given path
+        onTraceRecv(pkt, trace_tag, auth_code, flags, pkt->path, &pkt->payload[i], len);
+      } else if (self_id.isHashMatch(&pkt->payload[i + pkt->path_len]) && allowPacketForward(pkt) && !_tables->hasSeen(pkt)) {
+        // append SNR (Not hash!)
+        pkt->path[pkt->path_len] = (int8_t) (pkt->getSNR()*4);
+        pkt->path_len += PATH_HASH_SIZE;
+
+        uint32_t d = getDirectRetransmitDelay(pkt);
+        return ACTION_RETRANSMIT_DELAYED(5, d);  // schedule with priority 5 (for now), maybe make configurable?
+      }
+    }
+    return ACTION_RELEASE;
+  }
+
   if (pkt->isRouteDirect() && pkt->path_len >= PATH_HASH_SIZE) {
     if (self_id.isHashMatch(pkt->path) && allowPacketForward(pkt)) {
       if (_tables->hasSeen(pkt)) return ACTION_RELEASE;  // don't retransmit!
@@ -79,7 +103,7 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
       uint8_t src_hash = pkt->payload[i++];
 
       uint8_t* macAndData = &pkt->payload[i];   // MAC + encrypted data 
-      if (i + 2 >= pkt->payload_len) {
+      if (i + CIPHER_MAC_SIZE >= pkt->payload_len) {
         MESH_DEBUG_PRINTLN("%s Mesh::onRecvPacket(): incomplete data packet", getLogDateTime());
       } else if (!_tables->hasSeen(pkt)) {
         // NOTE: this is a 'first packet wins' impl. When receiving from multiple paths, the first to arrive wins.
@@ -333,7 +357,7 @@ Packet* Mesh::createPathReturn(const uint8_t* dest_hash, const uint8_t* secret,
 
 Packet* Mesh::createDatagram(uint8_t type, const Identity& dest, const uint8_t* secret, const uint8_t* data, size_t data_len) {
   if (type == PAYLOAD_TYPE_TXT_MSG || type == PAYLOAD_TYPE_REQ || type == PAYLOAD_TYPE_RESPONSE) {
-    if (data_len + 2 + CIPHER_BLOCK_SIZE-1 > MAX_PACKET_PAYLOAD) return NULL;
+    if (data_len + CIPHER_MAC_SIZE + CIPHER_BLOCK_SIZE-1 > MAX_PACKET_PAYLOAD) return NULL;
   } else {
     return NULL;  // invalid type
   }
@@ -433,7 +457,28 @@ Packet* Mesh::createRawData(const uint8_t* data, size_t len) {
   return packet;
 }
 
+Packet* Mesh::createTrace(uint32_t tag, uint32_t auth_code, uint8_t flags) {
+  Packet* packet = obtainNewPacket();
+  if (packet == NULL) {
+    MESH_DEBUG_PRINTLN("%s Mesh::createTrace(): error, packet pool empty", getLogDateTime());
+    return NULL;
+  }
+  packet->header = (PAYLOAD_TYPE_TRACE << PH_TYPE_SHIFT);  // ROUTE_TYPE_* set later
+
+  memcpy(packet->payload, &tag, 4);
+  memcpy(&packet->payload[4], &auth_code, 4);
+  packet->payload[8] = flags;
+  packet->payload_len = 9;  // NOTE: path will be appended to payload[] later
+
+  return packet;
+}
+
 void Mesh::sendFlood(Packet* packet, uint32_t delay_millis) {
+  if (packet->getPayloadType() == PAYLOAD_TYPE_TRACE) {
+    MESH_DEBUG_PRINTLN("%s Mesh::sendFlood(): TRACE type not suspported", getLogDateTime());
+    return;
+  }
+
   packet->header &= ~PH_ROUTE_MASK;
   packet->header |= ROUTE_TYPE_FLOOD;
   packet->path_len = 0;
@@ -455,11 +500,20 @@ void Mesh::sendDirect(Packet* packet, const uint8_t* path, uint8_t path_len, uin
   packet->header &= ~PH_ROUTE_MASK;
   packet->header |= ROUTE_TYPE_DIRECT;
 
-  memcpy(packet->path, path, packet->path_len = path_len);
+  uint8_t pri;
+  if (packet->getPayloadType() == PAYLOAD_TYPE_TRACE) {   // TRACE packets are different
+    // for TRACE packets, path is appended to end of PAYLOAD. (path is used for SNR's)
+    memcpy(&packet->payload[packet->payload_len], path, path_len);
+    packet->payload_len += path_len;
 
+    packet->path_len = 0;
+    pri = 5;   // maybe make this configurable
+  } else {
+    memcpy(packet->path, path, packet->path_len = path_len);
+    pri = 0;
+  }
   _tables->hasSeen(packet); // mark this packet as already sent in case it is rebroadcast back to us
-
-  sendPacket(packet, 0, delay_millis);
+  sendPacket(packet, pri, delay_millis);
 }
 
 void Mesh::sendZeroHop(Packet* packet, uint32_t delay_millis) {

src/Mesh.h

@@ -4,34 +4,6 @@
 
 namespace mesh {
 
-/**
- * An abstraction of the device's Realtime Clock.
-*/
-class RTCClock {
-  uint32_t last_unique;
-protected:
-  RTCClock() { last_unique = 0; }
-
-public:
-  /**
-   * \returns  the current time. in UNIX epoch seconds.
-  */
-  virtual uint32_t getCurrentTime() = 0;
-
-  /**
-   * \param time  current time in UNIX epoch seconds.
-  */
-  virtual void setCurrentTime(uint32_t time) = 0;
-
-  uint32_t getCurrentTimeUnique() {
-    uint32_t t = getCurrentTime();
-    if (t <= last_unique) {
-      return ++last_unique;
-    }
-    return last_unique = t;
-  }
-};
-
 class GroupChannel {
 public:
   uint8_t hash[PATH_HASH_SIZE];
@@ -100,9 +72,22 @@ protected:
    * \param  type  one of: PAYLOAD_TYPE_TXT_MSG, PAYLOAD_TYPE_REQ, PAYLOAD_TYPE_RESPONSE
    * \param  sender_idx  index of peer, [0..n) where n is what searchPeersByHash() returned
    * \param  secret   the pre-calculated shared-secret (handy for sending response packet)
+   * \param  data   decrypted data from payload
   */
   virtual void onPeerDataRecv(Packet* packet, uint8_t type, int sender_idx, const uint8_t* secret, uint8_t* data, size_t len) { }
 
+  /**
+   * \brief  A TRACE packet has been received. (and has reached the end of its given path)
+   *         NOTE: this may have been initiated by another node.
+   * \param  tag         a random (unique-ish) tag set by initiator
+   * \param  auth_code   a code to authenticate the packet
+   * \param  flags       zero for now
+   * \param  path_snrs   single byte SNR*4 for each hop in the path
+   * \param  path_hashes hashes if each repeater in the path
+   * \param  path_len    length of the path_snrs[] and path_hashes[] arrays
+  */
+  virtual void onTraceRecv(Packet* packet, uint32_t tag, uint32_t auth_code, uint8_t flags, const uint8_t* path_snrs, const uint8_t* path_hashes, uint8_t path_len) { }
+
   /**
    * \brief  A path TO peer (sender_idx) has been received. (also with optional 'extra' data encoded)
    *         NOTE: these can be received multiple times (per sender), via differen routes
@@ -182,6 +167,7 @@ public:
   Packet* createPathReturn(const uint8_t* dest_hash, const uint8_t* secret, const uint8_t* path, uint8_t path_len, uint8_t extra_type, const uint8_t*extra, size_t extra_len);
   Packet* createPathReturn(const Identity& dest, const uint8_t* secret, const uint8_t* path, uint8_t path_len, uint8_t extra_type, const uint8_t*extra, size_t extra_len);
   Packet* createRawData(const uint8_t* data, size_t len);
+  Packet* createTrace(uint32_t tag, uint32_t auth_code, uint8_t flags = 0);
 
   /**
    * \brief  send a locally-generated Packet with flood routing
@@ -197,6 +183,7 @@ public:
    * \brief  send a locally-generated Packet to just neigbor nodes (zero hops)
   */
   void sendZeroHop(Packet* packet, uint32_t delay_millis=0);
+
 };
 
 }

src/MeshCore.h

@@ -40,8 +40,37 @@ public:
   virtual void onBeforeTransmit() { }
   virtual void onAfterTransmit() { }
   virtual void reboot() = 0;
+  virtual void powerOff() { /* no op */ }
   virtual uint8_t getStartupReason() const = 0;
-  virtual bool startOTAUpdate() { return false; }   // not supported
+  virtual bool startOTAUpdate(const char* id, char reply[]) { return false; }   // not supported
+};
+
+/**
+ * An abstraction of the device's Realtime Clock.
+*/
+class RTCClock {
+  uint32_t last_unique;
+protected:
+  RTCClock() { last_unique = 0; }
+
+public:
+  /**
+   * \returns  the current time. in UNIX epoch seconds.
+  */
+  virtual uint32_t getCurrentTime() = 0;
+
+  /**
+   * \param time  current time in UNIX epoch seconds.
+  */
+  virtual void setCurrentTime(uint32_t time) = 0;
+
+  uint32_t getCurrentTimeUnique() {
+    uint32_t t = getCurrentTime();
+    if (t <= last_unique) {
+      return ++last_unique;
+    }
+    return last_unique = t;
+  }
 };
 
 }

src/Packet.cpp

@@ -10,11 +10,13 @@ Packet::Packet() {
   payload_len = 0;
 }
 
-
 void Packet::calculatePacketHash(uint8_t* hash) const {
   SHA256 sha;
   uint8_t t = getPayloadType();
   sha.update(&t, 1);
+  if (t == PAYLOAD_TYPE_TRACE) {
+    sha.update(&path_len, sizeof(path_len));   // CAVEAT: TRACE packets can revisit same node on return path
+  }
   sha.update(payload, payload_len);
   sha.finalize(hash, MAX_HASH_SIZE);
 }

src/Packet.h

@@ -25,6 +25,7 @@ namespace mesh {
 #define PAYLOAD_TYPE_GRP_DATA    0x06    // an (unverified) group datagram (prefixed with channel hash, MAC) (enc data: timestamp, blob)
 #define PAYLOAD_TYPE_ANON_REQ    0x07    // generic request (prefixed with dest_hash, ephemeral pub_key, MAC) (enc data: ...)
 #define PAYLOAD_TYPE_PATH        0x08    // returned path (prefixed with dest/src hashes, MAC) (enc data: path, extra)
+#define PAYLOAD_TYPE_TRACE       0x09    // trace a path, collecting SNI for each hop
 //...
 #define PAYLOAD_TYPE_RAW_CUSTOM   0x0F    // custom packet as raw bytes, for applications with custom encryption, payloads, etc
 
@@ -44,6 +45,7 @@ public:
   uint16_t payload_len, path_len;
   uint8_t path[MAX_PATH_SIZE];
   uint8_t payload[MAX_PACKET_PAYLOAD];
+  int8_t _snr;
 
   /**
    * \brief calculate the hash of payload + type
@@ -72,6 +74,8 @@ public:
   void markDoNotRetransmit() { header = 0xFF; }
   bool isMarkedDoNotRetransmit() const { return header == 0xFF; }
 
+  float getSNR() const { return ((float)_snr) / 4.0f; }
+
   /**
    * \brief  save entire packet as a blob
    * \param dest  (OUT) destination buffer (assumed to be MAX_MTU_SIZE)

src/helpers/ArduinoSerialInterface.h

@@ -23,7 +23,12 @@ public:
 #ifdef LILYGO_T3S3
   void begin(HWCDC& serial) { _serial = &serial; }
 #elif defined(NRF52_PLATFORM)
-  void begin(Adafruit_USBD_CDC& serial) { _serial = &serial; }
+  void begin(Adafruit_USBD_CDC& serial) {
+    _serial = &serial;
+  #ifdef RAK_4631
+    pinMode(WB_IO2, OUTPUT);
+  #endif
+  }
 #else
   void begin(HardwareSerial& serial) { _serial = &serial; }
 #endif

src/helpers/BaseChatMesh.cpp

@@ -105,7 +105,7 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
     data[len] = 0; // need to make a C string again, with null terminator
 
     if (flags == TXT_TYPE_PLAIN) {
-      onMessageRecv(from, packet->isRouteFlood() ? packet->path_len : 0xFF, timestamp, (const char *) &data[5]);  // let UI know
+      onMessageRecv(from, packet, timestamp, (const char *) &data[5]);  // let UI know
 
       uint32_t ack_hash;    // calc truncated hash of the message timestamp + text + sender pub_key, to prove to sender that we got it
       mesh::Utils::sha256((uint8_t *) &ack_hash, 4, data, 5 + strlen((char *)&data[5]), from.id.pub_key, PUB_KEY_SIZE);
@@ -126,7 +126,7 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
         }
       }
     } else if (flags == TXT_TYPE_CLI_DATA) {
-      onCommandDataRecv(from, packet->isRouteFlood() ? packet->path_len : 0xFF, timestamp, (const char *) &data[5]);  // let UI know
+      onCommandDataRecv(from, packet, timestamp, (const char *) &data[5]);  // let UI know
       // NOTE: no ack expected for CLI_DATA replies
 
       if (packet->isRouteFlood()) {
@@ -138,7 +138,7 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
       if (timestamp > from.sync_since) {  // make sure 'sync_since' is up-to-date
         from.sync_since = timestamp;
       }
-      onSignedMessageRecv(from, packet->isRouteFlood() ? packet->path_len : 0xFF, timestamp, &data[5], (const char *) &data[9]);  // let UI know
+      onSignedMessageRecv(from, packet, timestamp, &data[5], (const char *) &data[9]);  // let UI know
 
       uint32_t ack_hash;    // calc truncated hash of the message timestamp + text + OUR pub_key, to prove to sender that we got it
       mesh::Utils::sha256((uint8_t *) &ack_hash, 4, data, 9 + strlen((char *)&data[9]), self_id.pub_key, PUB_KEY_SIZE);
@@ -203,9 +203,9 @@ void BaseChatMesh::onAckRecv(mesh::Packet* packet, uint32_t ack_crc) {
 #ifdef MAX_GROUP_CHANNELS
 int BaseChatMesh::searchChannelsByHash(const uint8_t* hash, mesh::GroupChannel dest[], int max_matches) {
   int n = 0;
-  for (int i = 0; i < num_channels && n < max_matches; i++) {
-    if (channels[i].hash[0] == hash[0]) {
-      dest[n++] = channels[i];
+  for (int i = 0; i < MAX_GROUP_CHANNELS && n < max_matches; i++) {
+    if (channels[i].channel.hash[0] == hash[0]) {
+      dest[n++] = channels[i].channel;
     }
   }
   return n;
@@ -222,13 +222,14 @@ void BaseChatMesh::onGroupDataRecv(mesh::Packet* packet, uint8_t type, const mes
     data[len] = 0; // need to make a C string again, with null terminator
 
     // notify UI  of this new message
-    onChannelMessageRecv(channel, packet->isRouteFlood() ? packet->path_len : -1, timestamp, (const char *) &data[5]);  // let UI know
+    onChannelMessageRecv(channel, packet, timestamp, (const char *) &data[5]);  // let UI know
   }
 }
 
 mesh::Packet* BaseChatMesh::composeMsgPacket(const ContactInfo& recipient, uint32_t timestamp, uint8_t attempt, const char *text, uint32_t& expected_ack) {
   int text_len = strlen(text);
   if (text_len > MAX_TEXT_LEN) return NULL;
+  if (attempt > 3 && text_len > MAX_TEXT_LEN-2) return NULL;
 
   uint8_t temp[5+MAX_TEXT_LEN+1];
   memcpy(temp, &timestamp, 4);   // mostly an extra blob to help make packet_hash unique
@@ -238,7 +239,13 @@ mesh::Packet* BaseChatMesh::composeMsgPacket(const ContactInfo& recipient, uint3
   // calc expected ACK reply
   mesh::Utils::sha256((uint8_t *)&expected_ack, 4, temp, 5 + text_len, self_id.pub_key, PUB_KEY_SIZE);
 
-  return createDatagram(PAYLOAD_TYPE_TXT_MSG, recipient.id, recipient.shared_secret, temp, 5 + text_len);
+  int len = 5 + text_len;
+  if (attempt > 3) {
+    temp[len++] = 0;  // null terminator
+    temp[len++] = attempt;  // hide attempt number at tail end of payload
+  }
+
+  return createDatagram(PAYLOAD_TYPE_TXT_MSG, recipient.id, recipient.shared_secret, temp, len);
 }
 
 int  BaseChatMesh::sendMessage(const ContactInfo& recipient, uint32_t timestamp, uint8_t attempt, const char* text, uint32_t& expected_ack, uint32_t& est_timeout) {
@@ -588,24 +595,61 @@ bool BaseChatMesh::removeContact(ContactInfo& contact) {
 #ifdef MAX_GROUP_CHANNELS
 #include <base64.hpp>
 
-mesh::GroupChannel* BaseChatMesh::addChannel(const char* psk_base64) {
+ChannelDetails* BaseChatMesh::addChannel(const char* name, const char* psk_base64) {
   if (num_channels < MAX_GROUP_CHANNELS) {
     auto dest = &channels[num_channels];
 
-    memset(dest->secret, 0, sizeof(dest->secret));
-    int len = decode_base64((unsigned char *) psk_base64, strlen(psk_base64), dest->secret);
+    memset(dest->channel.secret, 0, sizeof(dest->channel.secret));
+    int len = decode_base64((unsigned char *) psk_base64, strlen(psk_base64), dest->channel.secret);
     if (len == 32 || len == 16) {
-      mesh::Utils::sha256(dest->hash, sizeof(dest->hash), dest->secret, len);
+      mesh::Utils::sha256(dest->channel.hash, sizeof(dest->channel.hash), dest->channel.secret, len);
+      StrHelper::strncpy(dest->name, name, sizeof(dest->name));
       num_channels++;
       return dest;
     }
   }
   return NULL;
 }
+bool BaseChatMesh::getChannel(int idx, ChannelDetails& dest) {
+  if (idx >= 0 && idx < MAX_GROUP_CHANNELS) {
+    dest = channels[idx];
+    return true;
+  }
+  return false;
+}
+bool BaseChatMesh::setChannel(int idx, const ChannelDetails& src) {
+  static uint8_t zeroes[] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
+
+  if (idx >= 0 && idx < MAX_GROUP_CHANNELS) {
+    channels[idx] = src;
+    if (memcmp(&src.channel.secret[16], zeroes, 16) == 0) {
+      mesh::Utils::sha256(channels[idx].channel.hash, sizeof(channels[idx].channel.hash), src.channel.secret, 16);  // 128-bit key
+    } else {
+      mesh::Utils::sha256(channels[idx].channel.hash, sizeof(channels[idx].channel.hash), src.channel.secret, 32);  // 256-bit key
+    }
+    return true;
+  }
+  return false;
+}
+int BaseChatMesh::findChannelIdx(const mesh::GroupChannel& ch) {
+  for (int i = 0; i < MAX_GROUP_CHANNELS; i++) {
+    if (memcmp(ch.secret, channels[i].channel.secret, sizeof(ch.secret)) == 0) return i;
+  }
+  return -1;  // not found
+}
 #else
-mesh::GroupChannel* BaseChatMesh::addChannel(const char* psk_base64) {
+ChannelDetails* BaseChatMesh::addChannel(const char* name, const char* psk_base64) {
   return NULL;  // not supported
 }
+bool BaseChatMesh::getChannel(int idx, ChannelDetails& dest) {
+  return false;
+}
+bool BaseChatMesh::setChannel(int idx, const ChannelDetails& src) {
+  return false;
+}
+int BaseChatMesh::findChannelIdx(const mesh::GroupChannel& ch) {
+  return -1;  // not found
+}
 #endif
 
 ContactsIterator BaseChatMesh::startContactsIterator() {

src/helpers/BaseChatMesh.h

@@ -61,6 +61,11 @@ struct ConnectionInfo {
   uint32_t expected_ack;
 };
 
+struct ChannelDetails {
+  mesh::GroupChannel channel;
+  char name[32];
+};
+
 /**
  *  \brief  abstract Mesh class for common 'chat' client
  */
@@ -74,8 +79,8 @@ class BaseChatMesh : public mesh::Mesh {
   int matching_peer_indexes[MAX_SEARCH_RESULTS];
   unsigned long txt_send_timeout;
 #ifdef MAX_GROUP_CHANNELS
-  mesh::GroupChannel channels[MAX_GROUP_CHANNELS];
-  int num_channels;
+  ChannelDetails channels[MAX_GROUP_CHANNELS];
+  int num_channels;  // only for addChannel()
 #endif
   mesh::Packet* _pendingLoopback;
   uint8_t temp_buf[MAX_TRANS_UNIT];
@@ -89,6 +94,7 @@ protected:
   { 
     num_contacts = 0;
   #ifdef MAX_GROUP_CHANNELS
+    memset(channels, 0, sizeof(channels));
     num_channels = 0;
   #endif
     txt_send_timeout = 0;
@@ -100,13 +106,13 @@ protected:
   virtual void onDiscoveredContact(ContactInfo& contact, bool is_new) = 0;
   virtual bool processAck(const uint8_t *data) = 0;
   virtual void onContactPathUpdated(const ContactInfo& contact) = 0;
-  virtual void onMessageRecv(const ContactInfo& contact, uint8_t path_len, uint32_t sender_timestamp, const char *text) = 0;
-  virtual void onCommandDataRecv(const ContactInfo& contact, uint8_t path_len, uint32_t sender_timestamp, const char *text) = 0;
-  virtual void onSignedMessageRecv(const ContactInfo& contact, uint8_t path_len, uint32_t sender_timestamp, const uint8_t *sender_prefix, const char *text) = 0;
+  virtual void onMessageRecv(const ContactInfo& contact, mesh::Packet* pkt, uint32_t sender_timestamp, const char *text) = 0;
+  virtual void onCommandDataRecv(const ContactInfo& contact, mesh::Packet* pkt, uint32_t sender_timestamp, const char *text) = 0;
+  virtual void onSignedMessageRecv(const ContactInfo& contact, mesh::Packet* pkt, uint32_t sender_timestamp, const uint8_t *sender_prefix, const char *text) = 0;
   virtual uint32_t calcFloodTimeoutMillisFor(uint32_t pkt_airtime_millis) const = 0;
   virtual uint32_t calcDirectTimeoutMillisFor(uint32_t pkt_airtime_millis, uint8_t path_len) const = 0;
   virtual void onSendTimeout() = 0;
-  virtual void onChannelMessageRecv(const mesh::GroupChannel& channel, int in_path_len, uint32_t timestamp, const char *text) = 0;
+  virtual void onChannelMessageRecv(const mesh::GroupChannel& channel, mesh::Packet* pkt, uint32_t timestamp, const char *text) = 0;
   virtual void onContactResponse(const ContactInfo& contact, const uint8_t* data, uint8_t len) = 0;
 
   // storage concepts, for sub-classes to override/implement
@@ -151,7 +157,10 @@ public:
   bool  addContact(const ContactInfo& contact);
   int getNumContacts() const { return num_contacts; }
   ContactsIterator startContactsIterator();
-  mesh::GroupChannel* addChannel(const char* psk_base64);
+  ChannelDetails* addChannel(const char* name, const char* psk_base64);
+  bool getChannel(int idx, ChannelDetails& dest);
+  bool setChannel(int idx, const ChannelDetails& src);
+  int findChannelIdx(const mesh::GroupChannel& ch);
 
   void loop();
 };

src/helpers/CommonCLI.cpp

@@ -14,56 +14,66 @@ static uint32_t _atoi(const char* sp) {
 }
 
 void CommonCLI::loadPrefs(FILESYSTEM* fs) {
-  if (fs->exists("/node_prefs")) {
-    File file = fs->open("/node_prefs");
-    if (file) {
-      uint8_t pad[8];
+  if (fs->exists("/com_prefs")) {
+    loadPrefsInt(fs, "/com_prefs");   // new filename
+  } else if (fs->exists("/node_prefs")) {
+    loadPrefsInt(fs, "/node_prefs");
+    savePrefs(fs);  // save to new filename
+    fs->remove("/node_prefs");  // remove old
+  }
+}
 
-      file.read((uint8_t *) &_prefs->airtime_factor, sizeof(_prefs->airtime_factor));  // 0
-      file.read((uint8_t *) &_prefs->node_name, sizeof(_prefs->node_name));  // 4
-      file.read(pad, 4);   // 36
-      file.read((uint8_t *) &_prefs->node_lat, sizeof(_prefs->node_lat));  // 40
-      file.read((uint8_t *) &_prefs->node_lon, sizeof(_prefs->node_lon));  // 48
-      file.read((uint8_t *) &_prefs->password[0], sizeof(_prefs->password));  // 56
-      file.read((uint8_t *) &_prefs->freq, sizeof(_prefs->freq));   // 72
-      file.read((uint8_t *) &_prefs->tx_power_dbm, sizeof(_prefs->tx_power_dbm));  // 76
-      file.read((uint8_t *) &_prefs->disable_fwd, sizeof(_prefs->disable_fwd));  // 77
-      file.read((uint8_t *) &_prefs->advert_interval, sizeof(_prefs->advert_interval));  // 78
-      file.read((uint8_t *) &_prefs->unused, sizeof(_prefs->unused));  // 79
-      file.read((uint8_t *) &_prefs->rx_delay_base, sizeof(_prefs->rx_delay_base));  // 80
-      file.read((uint8_t *) &_prefs->tx_delay_factor, sizeof(_prefs->tx_delay_factor));  // 84
-      file.read((uint8_t *) &_prefs->guest_password[0], sizeof(_prefs->guest_password));  // 88
-      file.read((uint8_t *) &_prefs->direct_tx_delay_factor, sizeof(_prefs->direct_tx_delay_factor));  // 104
-      file.read(pad, 4);   // 108
-      file.read((uint8_t *) &_prefs->sf, sizeof(_prefs->sf));  // 112
-      file.read((uint8_t *) &_prefs->cr, sizeof(_prefs->cr));  // 113
-      file.read((uint8_t *) &_prefs->reserved1, sizeof(_prefs->reserved1));  // 114
-      file.read((uint8_t *) &_prefs->reserved2, sizeof(_prefs->reserved2));  // 115
-      file.read((uint8_t *) &_prefs->bw, sizeof(_prefs->bw));  // 116
-      file.read(pad, 4);   // 120
+void CommonCLI::loadPrefsInt(FILESYSTEM* fs, const char* filename) {
+  File file = fs->open(filename);
+  if (file) {
+    uint8_t pad[8];
 
-      // sanitise bad pref values
-      _prefs->rx_delay_base = constrain(_prefs->rx_delay_base, 0, 20.0f);
-      _prefs->tx_delay_factor = constrain(_prefs->tx_delay_factor, 0, 2.0f);
-      _prefs->direct_tx_delay_factor = constrain(_prefs->direct_tx_delay_factor, 0, 2.0f);
-      _prefs->airtime_factor = constrain(_prefs->airtime_factor, 0, 9.0f);
-      _prefs->freq = constrain(_prefs->freq, 400.0f, 2500.0f);
-      _prefs->bw = constrain(_prefs->bw, 62.5f, 500.0f);
-      _prefs->sf = constrain(_prefs->sf, 7, 12);
-      _prefs->cr = constrain(_prefs->cr, 5, 8);
-      _prefs->tx_power_dbm = constrain(_prefs->tx_power_dbm, 1, 30);
+    file.read((uint8_t *) &_prefs->airtime_factor, sizeof(_prefs->airtime_factor));  // 0
+    file.read((uint8_t *) &_prefs->node_name, sizeof(_prefs->node_name));  // 4
+    file.read(pad, 4);   // 36
+    file.read((uint8_t *) &_prefs->node_lat, sizeof(_prefs->node_lat));  // 40
+    file.read((uint8_t *) &_prefs->node_lon, sizeof(_prefs->node_lon));  // 48
+    file.read((uint8_t *) &_prefs->password[0], sizeof(_prefs->password));  // 56
+    file.read((uint8_t *) &_prefs->freq, sizeof(_prefs->freq));   // 72
+    file.read((uint8_t *) &_prefs->tx_power_dbm, sizeof(_prefs->tx_power_dbm));  // 76
+    file.read((uint8_t *) &_prefs->disable_fwd, sizeof(_prefs->disable_fwd));  // 77
+    file.read((uint8_t *) &_prefs->advert_interval, sizeof(_prefs->advert_interval));  // 78
+    file.read((uint8_t *) pad, 1);  // 79  was 'unused'
+    file.read((uint8_t *) &_prefs->rx_delay_base, sizeof(_prefs->rx_delay_base));  // 80
+    file.read((uint8_t *) &_prefs->tx_delay_factor, sizeof(_prefs->tx_delay_factor));  // 84
+    file.read((uint8_t *) &_prefs->guest_password[0], sizeof(_prefs->guest_password));  // 88
+    file.read((uint8_t *) &_prefs->direct_tx_delay_factor, sizeof(_prefs->direct_tx_delay_factor));  // 104
+    file.read(pad, 4);   // 108
+    file.read((uint8_t *) &_prefs->sf, sizeof(_prefs->sf));  // 112
+    file.read((uint8_t *) &_prefs->cr, sizeof(_prefs->cr));  // 113
+    file.read((uint8_t *) &_prefs->allow_read_only, sizeof(_prefs->allow_read_only));  // 114
+    file.read((uint8_t *) &_prefs->reserved2, sizeof(_prefs->reserved2));  // 115
+    file.read((uint8_t *) &_prefs->bw, sizeof(_prefs->bw));  // 116
+    file.read(pad, 4);   // 120
+    file.read((uint8_t *) &_prefs->flood_max, sizeof(_prefs->flood_max));   // 124
+    file.read((uint8_t *) &_prefs->flood_advert_interval, sizeof(_prefs->flood_advert_interval));  // 125
 
-      file.close();
-    }
+    // sanitise bad pref values
+    _prefs->rx_delay_base = constrain(_prefs->rx_delay_base, 0, 20.0f);
+    _prefs->tx_delay_factor = constrain(_prefs->tx_delay_factor, 0, 2.0f);
+    _prefs->direct_tx_delay_factor = constrain(_prefs->direct_tx_delay_factor, 0, 2.0f);
+    _prefs->airtime_factor = constrain(_prefs->airtime_factor, 0, 9.0f);
+    _prefs->freq = constrain(_prefs->freq, 400.0f, 2500.0f);
+    _prefs->bw = constrain(_prefs->bw, 62.5f, 500.0f);
+    _prefs->sf = constrain(_prefs->sf, 7, 12);
+    _prefs->cr = constrain(_prefs->cr, 5, 8);
+    _prefs->tx_power_dbm = constrain(_prefs->tx_power_dbm, 1, 30);
+
+    file.close();
   }
 }
 
 void CommonCLI::savePrefs(FILESYSTEM* fs) {
 #if defined(NRF52_PLATFORM)
-  File file = fs->open("/node_prefs", FILE_O_WRITE);
+  File file = fs->open("/com_prefs", FILE_O_WRITE);
   if (file) { file.seek(0); file.truncate(); }
 #else
-  File file = fs->open("/node_prefs", "w", true);
+  File file = fs->open("/com_prefs", "w", true);
 #endif
   if (file) {
     uint8_t pad[8];
@@ -79,7 +89,7 @@ void CommonCLI::savePrefs(FILESYSTEM* fs) {
     file.write((uint8_t *) &_prefs->tx_power_dbm, sizeof(_prefs->tx_power_dbm));  // 76
     file.write((uint8_t *) &_prefs->disable_fwd, sizeof(_prefs->disable_fwd));  // 77
     file.write((uint8_t *) &_prefs->advert_interval, sizeof(_prefs->advert_interval));  // 78
-    file.write((uint8_t *) &_prefs->unused, sizeof(_prefs->unused));  // 79
+    file.write((uint8_t *) pad, 1);  // 79  was 'unused'
     file.write((uint8_t *) &_prefs->rx_delay_base, sizeof(_prefs->rx_delay_base));  // 80
     file.write((uint8_t *) &_prefs->tx_delay_factor, sizeof(_prefs->tx_delay_factor));  // 84
     file.write((uint8_t *) &_prefs->guest_password[0], sizeof(_prefs->guest_password));  // 88
@@ -87,10 +97,12 @@ void CommonCLI::savePrefs(FILESYSTEM* fs) {
     file.write(pad, 4);   // 108
     file.write((uint8_t *) &_prefs->sf, sizeof(_prefs->sf));  // 112
     file.write((uint8_t *) &_prefs->cr, sizeof(_prefs->cr));  // 113
-    file.write((uint8_t *) &_prefs->reserved1, sizeof(_prefs->reserved1));  // 114
+    file.write((uint8_t *) &_prefs->allow_read_only, sizeof(_prefs->allow_read_only));  // 114
     file.write((uint8_t *) &_prefs->reserved2, sizeof(_prefs->reserved2));  // 115
     file.write((uint8_t *) &_prefs->bw, sizeof(_prefs->bw));  // 116
     file.write(pad, 4);   // 120
+    file.write((uint8_t *) &_prefs->flood_max, sizeof(_prefs->flood_max));   // 124
+    file.write((uint8_t *) &_prefs->flood_advert_interval, sizeof(_prefs->flood_advert_interval));  // 125
 
     file.close();
   }
@@ -127,9 +139,7 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
         strcpy(reply, "ERR: clock cannot go backwards");
       }
     } else if (memcmp(command, "start ota", 9) == 0) {
-      if (_board->startOTAUpdate()) {
-        strcpy(reply, "OK");
-      } else {
+      if (!_board->startOTAUpdate(_prefs->node_name, reply)) {
         strcpy(reply, "Error");
       }
     } else if (memcmp(command, "clock", 5) == 0) {
@@ -155,6 +165,10 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
       const char* config = &command[4];
       if (memcmp(config, "af", 2) == 0) {
         sprintf(reply, "> %s", StrHelper::ftoa(_prefs->airtime_factor));
+      } else if (memcmp(config, "allow.read.only", 15) == 0) {
+        sprintf(reply, "> %s", _prefs->allow_read_only ? "on" : "off");
+      } else if (memcmp(config, "flood.advert.interval", 21) == 0) {
+        sprintf(reply, "> %d", ((uint32_t) _prefs->flood_advert_interval));
       } else if (memcmp(config, "advert.interval", 15) == 0) {
         sprintf(reply, "> %d", ((uint32_t) _prefs->advert_interval) * 2);
       } else if (memcmp(config, "guest.password", 14) == 0) {
@@ -176,12 +190,19 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
         sprintf(reply, "> %s", StrHelper::ftoa(_prefs->rx_delay_base));
       } else if (memcmp(config, "txdelay", 7) == 0) {
         sprintf(reply, "> %s", StrHelper::ftoa(_prefs->tx_delay_factor));
+      } else if (memcmp(config, "flood.max", 9) == 0) {
+        sprintf(reply, "> %d", (uint32_t)_prefs->flood_max);
       } else if (memcmp(config, "direct.txdelay", 14) == 0) {
         sprintf(reply, "> %s", StrHelper::ftoa(_prefs->direct_tx_delay_factor));
       } else if (memcmp(config, "tx", 2) == 0 && (config[2] == 0 || config[2] == ' ')) {
         sprintf(reply, "> %d", (uint32_t) _prefs->tx_power_dbm);
       } else if (memcmp(config, "freq", 4) == 0) {
         sprintf(reply, "> %s", StrHelper::ftoa(_prefs->freq));
+      } else if (memcmp(config, "public.key", 10) == 0) {
+        strcpy(reply, "> ");
+        mesh::Utils::toHex(&reply[2], _mesh->self_id.pub_key, PUB_KEY_SIZE);
+      } else if (memcmp(config, "role", 4) == 0) {
+        sprintf(reply, "> %s", _callbacks->getRole());
       } else {
         sprintf(reply, "??: %s", config);
       }
@@ -191,6 +212,22 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
         _prefs->airtime_factor = atof(&config[3]);
         savePrefs();
         strcpy(reply, "OK");
+      } else if (memcmp(config, "allow.read.only ", 16) == 0) {
+        _prefs->allow_read_only = memcmp(&config[16], "on", 2) == 0;
+        savePrefs();
+        strcpy(reply, "OK");
+      } else if (memcmp(config, "flood.advert.interval ", 22) == 0) {
+        int hours = _atoi(&config[22]);
+        if (hours > 0 && hours < 3) {
+          sprintf(reply, "Error: min is 3 hours");
+        } else if (hours > 48) {
+          strcpy(reply, "Error: max is 48 hours");
+        } else {
+          _prefs->flood_advert_interval = (uint8_t)(hours);
+          _callbacks->updateFloodAdvertTimer();
+          savePrefs();
+          strcpy(reply, "OK");
+        }
       } else if (memcmp(config, "advert.interval ", 16) == 0) {
         int mins = _atoi(&config[16]);
         if (mins > 0 && mins < MIN_LOCAL_ADVERT_INTERVAL) {
@@ -262,6 +299,15 @@ void CommonCLI::handleCommand(uint32_t sender_timestamp, const char* command, ch
         } else {
           strcpy(reply, "Error, cannot be negative");
         }
+      } else if (memcmp(config, "flood.max ", 10) == 0) {
+        uint8_t m = atoi(&config[10]);
+        if (m <= 64) {
+          _prefs->flood_max = m;
+          savePrefs();
+          strcpy(reply, "OK");
+        } else {
+          strcpy(reply, "Error, max 64");
+        }
       } else if (memcmp(config, "direct.txdelay ", 15) == 0) {
         float f = atof(&config[15]);
         if (f >= 0) {

src/helpers/CommonCLI.h

@@ -11,8 +11,8 @@ struct NodePrefs {  // persisted to file
     float freq;
     uint8_t tx_power_dbm;
     uint8_t disable_fwd;
-    uint8_t advert_interval;   // minutes
-    uint8_t unused;
+    uint8_t advert_interval;   // minutes / 2
+    uint8_t flood_advert_interval;   // hours
     float rx_delay_base;
     float tx_delay_factor;
     char guest_password[16];
@@ -20,9 +20,10 @@ struct NodePrefs {  // persisted to file
     uint32_t guard;
     uint8_t sf;
     uint8_t cr;
-    uint8_t reserved1;
+    uint8_t allow_read_only;
     uint8_t reserved2;
     float bw;
+    uint8_t flood_max;
 };
 
 class CommonCLICallbacks {
@@ -30,9 +31,11 @@ public:
   virtual void savePrefs() = 0;
   virtual const char* getFirmwareVer() = 0;
   virtual const char* getBuildDate() = 0;
+  virtual const char* getRole() = 0;
   virtual bool formatFileSystem() = 0;
   virtual void sendSelfAdvertisement(int delay_millis) = 0;
   virtual void updateAdvertTimer() = 0;
+  virtual void updateFloodAdvertTimer() = 0;
   virtual void setLoggingOn(bool enable) = 0;
   virtual void eraseLogFile() = 0;
   virtual void dumpLogFile() = 0;
@@ -51,8 +54,10 @@ class CommonCLI {
 
   void checkAdvertInterval();
 
+  void loadPrefsInt(FILESYSTEM* _fs, const char* filename);
+
 public:
-  CommonCLI(mesh::MainBoard& board, mesh::Mesh* mesh, NodePrefs* prefs, CommonCLICallbacks* callbacks) 
+  CommonCLI(mesh::MainBoard& board, mesh::Mesh* mesh, NodePrefs* prefs, CommonCLICallbacks* callbacks)
       : _board(&board), _mesh(mesh), _prefs(prefs), _callbacks(callbacks) { }
 
   void loadPrefs(FILESYSTEM* _fs);

src/helpers/CustomLLCC68.h

@@ -3,14 +3,15 @@
 #include <RadioLib.h>
 
 #define SX126X_IRQ_HEADER_VALID                     0b0000010000  //  4     4     valid LoRa header received
+#define SX126X_IRQ_PREAMBLE_DETECTED           0x04
 
 class CustomLLCC68 : public LLCC68 {
   public:
     CustomLLCC68(Module *mod) : LLCC68(mod) { }
 
     bool isReceiving() {
-      uint16_t irq = getIrqStatus();
-      bool hasPreamble = (irq & SX126X_IRQ_HEADER_VALID);
-      return hasPreamble;
+      uint16_t irq = getIrqFlags();
+      bool detected = (irq & SX126X_IRQ_HEADER_VALID) || (irq & SX126X_IRQ_PREAMBLE_DETECTED);
+      return detected;
     }
 };

src/helpers/CustomLR1110.h

@@ -11,7 +11,7 @@ class CustomLR1110 : public LR1110 {
 
     bool isReceiving() {
       uint16_t irq = getIrqStatus();
-      bool hasPreamble = ((irq & LR1110_IRQ_HEADER_VALID) && (irq & LR1110_IRQ_HAS_PREAMBLE));
-      return hasPreamble;
+      bool detected = ((irq & LR1110_IRQ_HEADER_VALID) || (irq & LR1110_IRQ_HAS_PREAMBLE));
+      return detected;
     }
 };

src/helpers/CustomSX1262.h

@@ -3,6 +3,7 @@
 #include <RadioLib.h>
 
 #define SX126X_IRQ_HEADER_VALID                     0b0000010000  //  4     4     valid LoRa header received
+#define SX126X_IRQ_PREAMBLE_DETECTED           0x04
 
 class CustomSX1262 : public SX1262 {
   public:
@@ -10,7 +11,7 @@ class CustomSX1262 : public SX1262 {
 
     bool isReceiving() {
       uint16_t irq = getIrqFlags();
-      bool hasPreamble = (irq & SX126X_IRQ_HEADER_VALID);
-      return hasPreamble;
+      bool detected = (irq & SX126X_IRQ_HEADER_VALID) || (irq & SX126X_IRQ_PREAMBLE_DETECTED);
+      return detected;
     }
 };

src/helpers/CustomSX1268.h

@@ -3,6 +3,7 @@
 #include <RadioLib.h>
 
 #define SX126X_IRQ_HEADER_VALID                     0b0000010000  //  4     4     valid LoRa header received
+#define SX126X_IRQ_PREAMBLE_DETECTED           0x04
 
 class CustomSX1268 : public SX1268 {
   public:
@@ -10,7 +11,7 @@ class CustomSX1268 : public SX1268 {
 
     bool isReceiving() {
       uint16_t irq = getIrqFlags();
-      bool hasPreamble = (irq & SX126X_IRQ_HEADER_VALID);
-      return hasPreamble;
+      bool detected = (irq & SX126X_IRQ_HEADER_VALID) || (irq & SX126X_IRQ_PREAMBLE_DETECTED);
+      return detected;
     }
 };

src/helpers/ESP32Board.cpp

@@ -0,0 +1,41 @@
+#ifdef ESP_PLATFORM
+
+#include "ESP32Board.h"
+
+#if defined(ADMIN_PASSWORD)   // Repeater or Room Server only
+#include <WiFi.h>
+#include <AsyncTCP.h>
+#include <ESPAsyncWebServer.h>
+#include <AsyncElegantOTA.h>
+
+bool ESP32Board::startOTAUpdate(const char* id, char reply[]) {
+  WiFi.softAP("MeshCore-OTA", NULL);
+
+  sprintf(reply, "Started: http://%s/update", WiFi.softAPIP().toString().c_str());
+  MESH_DEBUG_PRINTLN("startOTAUpdate: %s", reply);
+
+  static char id_buf[60];
+  sprintf(id_buf, "%s (%s)", id, getManufacturerName());
+  static char home_buf[90];
+  sprintf(home_buf, "<H2>Hi! I am a MeshCore Repeater. ID: %s</H2>", id);
+
+  AsyncWebServer* server = new AsyncWebServer(80);
+
+  server->on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
+    request->send(200, "text/html", home_buf);
+  });
+
+  AsyncElegantOTA.setID(id_buf);
+  AsyncElegantOTA.begin(server);    // Start ElegantOTA
+  server->begin();
+
+  return true;
+}
+
+#else
+bool ESP32Board::startOTAUpdate(const char* id, char reply[]) {
+  return false; // not supported
+}
+#endif
+
+#endif

src/helpers/ESP32Board.h

@@ -7,6 +7,7 @@
 
 #include <rom/rtc.h>
 #include <sys/time.h>
+#include <Wire.h>
 
 class ESP32Board : public mesh::MainBoard {
 protected:
@@ -17,6 +18,10 @@ public:
     // for future use, sub-classes SHOULD call this from their begin()
     startup_reason = BD_STARTUP_NORMAL;
 
+  #ifdef ESP32_CPU_FREQ
+    setCpuFrequencyMhz(ESP32_CPU_FREQ);
+  #endif
+
   #ifdef PIN_VBAT_READ
     // battery read support
     pinMode(PIN_VBAT_READ, INPUT);
@@ -29,7 +34,9 @@ public:
   #endif
 
   #if defined(PIN_BOARD_SDA) && defined(PIN_BOARD_SCL)
+   #if PIN_BOARD_SDA >= 0 && PIN_BOARD_SCL >= 0
     Wire.begin(PIN_BOARD_SDA, PIN_BOARD_SCL);
+   #endif
   #else
     Wire.begin();
   #endif
@@ -69,6 +76,8 @@ public:
   void reboot() override {
     esp_restart();
   }
+
+  bool startOTAUpdate(const char* id, char reply[]) override;
 };
 
 class ESP32RTCClock : public mesh::RTCClock {

src/helpers/HeltecV3Board.h

@@ -24,11 +24,20 @@
 #include <driver/rtc_io.h>
 
 class HeltecV3Board : public ESP32Board {
+private:
+  bool adc_active_state;
+
 public:
   void begin() {
     ESP32Board::begin();
 
+    // Auto-detect correct ADC_CTRL pin polarity (different for boards >3.2)
+    pinMode(PIN_ADC_CTRL, INPUT);
+    adc_active_state = !digitalRead(PIN_ADC_CTRL);
+    
     pinMode(PIN_ADC_CTRL, OUTPUT);
+    digitalWrite(PIN_ADC_CTRL, !adc_active_state); // Initially inactive
+
     pinMode(PIN_VEXT_EN, OUTPUT);
     digitalWrite(PIN_VEXT_EN, LOW);  // for V3.2 boards
 
@@ -67,9 +76,14 @@ public:
     esp_deep_sleep_start();   // CPU halts here and never returns!
   }
 
+  void powerOff() override {
+    // TODO: re-enable this when there is a definite wake-up source pin:
+    //  enterDeepSleep(0);
+  }
+
   uint16_t getBattMilliVolts() override {
     analogReadResolution(10);
-    digitalWrite(PIN_ADC_CTRL, PIN_ADC_CTRL_ACTIVE);
+    digitalWrite(PIN_ADC_CTRL, adc_active_state);
 
     uint32_t raw = 0;
     for (int i = 0; i < 8; i++) {
@@ -77,7 +91,7 @@ public:
     }
     raw = raw / 8;
 
-    digitalWrite(PIN_ADC_CTRL, PIN_ADC_CTRL_INACTIVE);
+    digitalWrite(PIN_ADC_CTRL, !adc_active_state);
 
     return (5.2 * (3.3 / 1024.0) * raw) * 1000;
   }

src/helpers/TBeamBoard.h

@@ -0,0 +1,84 @@
+#pragma once
+
+
+#include <Wire.h>
+#include <Arduino.h>
+#include "XPowersLib.h"
+
+// Defined using AXP2102
+#define XPOWERS_CHIP_AXP2101
+
+// LoRa radio module pins for TBeam
+#define  P_LORA_DIO_0   26
+#define  P_LORA_DIO_2   32
+#define  P_LORA_DIO_1   33
+#define  P_LORA_NSS     18
+#define  P_LORA_RESET   14
+#define  P_LORA_BUSY    RADIOLIB_NC
+#define  P_LORA_SCLK     5
+#define  P_LORA_MISO    19
+#define  P_LORA_MOSI    27
+
+// built-ins
+//#define  PIN_VBAT_READ   37
+//#define  PIN_LED_BUILTIN 25
+
+#include "ESP32Board.h"
+
+#include <driver/rtc_io.h>
+
+class TBeamBoard : public ESP32Board {
+  XPowersAXP2101 power;
+
+public:
+  void begin() {
+    ESP32Board::begin();
+    
+    power.setALDO2Voltage(3300);
+    power.enableALDO2();
+
+    pinMode(38,INPUT_PULLUP);
+
+    esp_reset_reason_t reason = esp_reset_reason();
+    if (reason == ESP_RST_DEEPSLEEP) {
+      long wakeup_source = esp_sleep_get_ext1_wakeup_status();
+      if (wakeup_source & (1 << P_LORA_DIO_1)) {  // received a LoRa packet (while in deep sleep)
+        startup_reason = BD_STARTUP_RX_PACKET;
+      }
+
+      rtc_gpio_hold_dis((gpio_num_t)P_LORA_NSS);
+      rtc_gpio_deinit((gpio_num_t)P_LORA_DIO_1);
+    }
+  }
+
+  void enterDeepSleep(uint32_t secs, int pin_wake_btn = -1) {
+    esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
+
+    // Make sure the DIO1 and NSS GPIOs are hold on required levels during deep sleep
+    rtc_gpio_set_direction((gpio_num_t)P_LORA_DIO_1, RTC_GPIO_MODE_INPUT_ONLY);
+    rtc_gpio_pulldown_en((gpio_num_t)P_LORA_DIO_1);
+
+    rtc_gpio_hold_en((gpio_num_t)P_LORA_NSS);
+
+    if (pin_wake_btn < 0) {
+      esp_sleep_enable_ext1_wakeup( (1L << P_LORA_DIO_1), ESP_EXT1_WAKEUP_ANY_HIGH);  // wake up on: recv LoRa packet
+    } else {
+      esp_sleep_enable_ext1_wakeup( (1L << P_LORA_DIO_1) | (1L << pin_wake_btn), ESP_EXT1_WAKEUP_ANY_HIGH);  // wake up on: recv LoRa packet OR wake btn
+    }
+
+    if (secs > 0) {
+      esp_sleep_enable_timer_wakeup(secs * 1000000);
+    }
+
+    // Finally set ESP32 into sleep
+    esp_deep_sleep_start();   // CPU halts here and never returns!
+  }
+
+  uint16_t getBattMilliVolts() override {
+    return 0;
+  }
+
+  const char* getManufacturerName() const override {
+    return "LilyGo T-Beam";
+  }
+};

src/helpers/esp32/ESPNOWRadio.cpp

@@ -0,0 +1,103 @@
+#include "ESPNOWRadio.h"
+#include <esp_now.h>
+#include <WiFi.h>
+#include <esp_wifi.h>
+
+static uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+static esp_now_peer_info_t peerInfo;
+static bool is_send_complete = false;
+static esp_err_t last_send_result;
+static uint8_t rx_buf[256];
+static uint8_t last_rx_len = 0;
+
+// callback when data is sent
+static void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
+  is_send_complete = true;
+  ESPNOW_DEBUG_PRINTLN("Send Status: %d", (int)status);
+}
+
+static void OnDataRecv(const uint8_t *mac, const uint8_t *data, int len) {
+  ESPNOW_DEBUG_PRINTLN("Recv: len = %d", len);
+  memcpy(rx_buf, data, len);
+  last_rx_len = len;
+}
+
+void ESPNOWRadio::begin() {
+  // Set device as a Wi-Fi Station
+  WiFi.mode(WIFI_STA);
+  // Long Range mode
+  esp_wifi_set_protocol(WIFI_IF_STA, WIFI_PROTOCOL_LR);
+
+  // Init ESP-NOW
+  if (esp_now_init() != ESP_OK) {
+    ESPNOW_DEBUG_PRINTLN("Error initializing ESP-NOW");
+    return;
+  }
+
+  esp_wifi_set_max_tx_power(80);  // should be 20dBm
+
+  esp_now_register_send_cb(OnDataSent);
+  esp_now_register_recv_cb(OnDataRecv);
+
+  // Register peer
+  memcpy(peerInfo.peer_addr, broadcastAddress, 6);
+  peerInfo.channel = 0;
+  peerInfo.encrypt = false;
+
+  // Add peer        
+  if (esp_now_add_peer(&peerInfo) == ESP_OK) {
+    ESPNOW_DEBUG_PRINTLN("init success");
+  } else {
+   // ESPNOW_DEBUG_PRINTLN("Failed to add peer");
+  }
+}
+
+void ESPNOWRadio::setTxPower(uint8_t dbm) {
+  esp_wifi_set_max_tx_power(dbm * 4);
+}
+
+uint32_t ESPNOWRadio::intID() {
+  uint8_t mac[8];
+  memset(mac, 0, sizeof(mac));
+  esp_efuse_mac_get_default(mac);
+  uint32_t n, m;
+  memcpy(&n, &mac[0], 4);
+  memcpy(&m, &mac[4], 4);
+  
+  return n + m;
+}
+
+void ESPNOWRadio::startSendRaw(const uint8_t* bytes, int len) {
+  // Send message via ESP-NOW
+  is_send_complete = false;
+  esp_err_t result = esp_now_send(broadcastAddress, bytes, len);
+  if (result == ESP_OK) {
+    ESPNOW_DEBUG_PRINTLN("Send success");
+  } else {
+    last_send_result = result;
+    is_send_complete = true;
+    ESPNOW_DEBUG_PRINTLN("Send failed: %d", result);
+  }
+}
+
+bool ESPNOWRadio::isSendComplete() {
+  return is_send_complete;
+}
+void ESPNOWRadio::onSendFinished() {
+}
+
+float ESPNOWRadio::getLastRSSI() const { return 0; }
+float ESPNOWRadio::getLastSNR() const { return 0; }
+
+int ESPNOWRadio::recvRaw(uint8_t* bytes, int sz) {
+  int len = last_rx_len;
+  if (last_rx_len > 0) {
+    memcpy(bytes, rx_buf, last_rx_len);
+    last_rx_len = 0;
+  }
+  return len;
+}
+
+uint32_t ESPNOWRadio::getEstAirtimeFor(int len_bytes) {
+  return 4;  // Fast AF
+}

src/helpers/esp32/ESPNOWRadio.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <Mesh.h>
+
+class ESPNOWRadio : public mesh::Radio {
+protected:
+  uint32_t n_recv, n_sent;
+
+public:
+  ESPNOWRadio() { n_recv = n_sent = 0; }
+
+  void begin() override;
+  int recvRaw(uint8_t* bytes, int sz) override;
+  uint32_t getEstAirtimeFor(int len_bytes) override;
+  void startSendRaw(const uint8_t* bytes, int len) override;
+  bool isSendComplete() override;
+  void onSendFinished() override;
+
+  uint32_t getPacketsRecv() const { return n_recv; }
+  uint32_t getPacketsSent() const { return n_sent; }
+  virtual float getLastRSSI() const override;
+  virtual float getLastSNR() const override;
+
+  float packetScore(float snr, int packet_len) override { return 0; }
+  uint32_t intID();
+  void setTxPower(uint8_t dbm);
+};
+
+#if ESPNOW_DEBUG_LOGGING && ARDUINO
+  #include <Arduino.h>
+  #define ESPNOW_DEBUG_PRINT(F, ...) Serial.printf("ESP-Now: " F, ##__VA_ARGS__)
+  #define ESPNOW_DEBUG_PRINTLN(F, ...) Serial.printf("ESP-Now: " F "\n", ##__VA_ARGS__)
+#else
+  #define ESPNOW_DEBUG_PRINT(...) {}
+  #define ESPNOW_DEBUG_PRINTLN(...) {}
+#endif

src/helpers/nrf52/PromicroBoard.cpp

@@ -0,0 +1,83 @@
+#include <Arduino.h>
+#include "PromicroBoard.h"
+
+#include <bluefruit.h>
+#include <Wire.h>
+
+static BLEDfu bledfu;
+
+void PromicroBoard::begin() {    
+    // for future use, sub-classes SHOULD call this from their begin()
+    startup_reason = BD_STARTUP_NORMAL;
+    btn_prev_state = HIGH;
+  
+    pinMode(PIN_VBAT_READ, INPUT);
+
+    #ifdef BUTTON_PIN
+      pinMode(BUTTON_PIN, INPUT);
+    #endif
+
+    #if defined(PIN_BOARD_SDA) && defined(PIN_BOARD_SCL)
+      Wire.setPins(PIN_BOARD_SDA, PIN_BOARD_SCL);
+    #endif
+    
+    Wire.begin();
+
+    pinMode(SX126X_POWER_EN, OUTPUT);
+    digitalWrite(SX126X_POWER_EN, HIGH);
+    delay(10);   // give sx1262 some time to power up
+}
+
+static void connect_callback(uint16_t conn_handle) {
+    (void)conn_handle;
+    MESH_DEBUG_PRINTLN("BLE client connected");
+}
+
+static void disconnect_callback(uint16_t conn_handle, uint8_t reason) {
+    (void)conn_handle;
+    (void)reason;
+    MESH_DEBUG_PRINTLN("BLE client disconnected");
+}
+
+bool PromicroBoard::startOTAUpdate(const char* id, char reply[]) {
+  // Config the peripheral connection with maximum bandwidth
+  // more SRAM required by SoftDevice
+  // Note: All config***() function must be called before begin()
+  Bluefruit.configPrphBandwidth(BANDWIDTH_MAX);
+  Bluefruit.configPrphConn(92, BLE_GAP_EVENT_LENGTH_MIN, 16, 16);
+
+  Bluefruit.begin(1, 0);
+  // Set max power. Accepted values are: -40, -30, -20, -16, -12, -8, -4, 0, 4
+  Bluefruit.setTxPower(4);
+  // Set the BLE device name
+  Bluefruit.setName("ProMicro_OTA");
+
+  Bluefruit.Periph.setConnectCallback(connect_callback);
+  Bluefruit.Periph.setDisconnectCallback(disconnect_callback);
+
+  // To be consistent OTA DFU should be added first if it exists
+  bledfu.begin();
+
+  // Set up and start advertising
+  // Advertising packet
+  Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
+  Bluefruit.Advertising.addTxPower();
+  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
+
+  strcpy(reply, "OK - started");
+  return true;
+}

src/helpers/nrf52/PromicroBoard.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <MeshCore.h>
+#include <Arduino.h>
+
+#define P_LORA_NSS 13 //P1.13 45
+#define P_LORA_DIO_1 11 //P0.10 10
+#define P_LORA_RESET 10 //P0.09 9
+#define P_LORA_BUSY  16 //P0.29 29
+#define P_LORA_MISO  15 //P0.02 2
+#define P_LORA_SCLK  12 //P1.11 43
+#define P_LORA_MOSI  14 //P1.15 47
+#define SX126X_POWER_EN 21 //P0.13 13
+#define SX126X_RXEN 2 //P0.17
+#define SX126X_TXEN RADIOLIB_NC
+#define SX126X_DIO2_AS_RF_SWITCH  true
+#define SX126X_DIO3_TCXO_VOLTAGE (1.8f)
+
+#define  PIN_VBAT_READ 17
+#define  ADC_MULTIPLIER   (1.815f) // dependent on voltage divider resistors. TODO: more accurate battery tracking
+
+class PromicroBoard : public mesh::MainBoard {
+protected:
+  uint8_t startup_reason;
+  uint8_t btn_prev_state;
+
+public:
+  void begin();
+
+  uint8_t getStartupReason() const override { return startup_reason; }
+
+  #define BATTERY_SAMPLES 8
+
+  uint16_t getBattMilliVolts() override {
+    analogReadResolution(12);
+
+    uint32_t raw = 0;
+    for (int i = 0; i < BATTERY_SAMPLES; i++) {
+      raw += analogRead(PIN_VBAT_READ);
+    }
+    raw = raw / BATTERY_SAMPLES;
+    return (ADC_MULTIPLIER * raw);
+  }
+
+  const char* getManufacturerName() const override {
+    return "ProMicro DIY";
+  }
+
+  int buttonStateChanged() {
+    #ifdef BUTTON_PIN
+      uint8_t v = digitalRead(BUTTON_PIN);
+      if (v != btn_prev_state) {
+        btn_prev_state = v;
+        return (v == LOW) ? 1 : -1;
+      }
+    #endif
+      return 0;
+  }
+
+  void reboot() override {
+    NVIC_SystemReset();
+  }
+
+  bool startOTAUpdate(const char* id, char reply[]) override;
+};

src/helpers/nrf52/RAK4631Board.cpp

@@ -6,75 +6,76 @@
 
 static BLEDfu bledfu;
 
-static void connect_callback(uint16_t conn_handle)
-{
-    (void)conn_handle;
-    MESH_DEBUG_PRINTLN("BLE client connected");
+static void connect_callback(uint16_t conn_handle) {
+  (void)conn_handle;
+  MESH_DEBUG_PRINTLN("BLE client connected");
 }
 
-static void disconnect_callback(uint16_t conn_handle, uint8_t reason)
-{
-    (void)conn_handle;
-    (void)reason;
+static void disconnect_callback(uint16_t conn_handle, uint8_t reason) {
+  (void)conn_handle;
+  (void)reason;
 
-    MESH_DEBUG_PRINTLN("BLE client disconnected");
+  MESH_DEBUG_PRINTLN("BLE client disconnected");
 }
 
 void RAK4631Board::begin() {
   // for future use, sub-classes SHOULD call this from their begin()
   startup_reason = BD_STARTUP_NORMAL;
-
   pinMode(PIN_VBAT_READ, INPUT);
+#ifdef PIN_USER_BTN
+  pinMode(PIN_USER_BTN, INPUT_PULLUP);
+#endif
 
 #if defined(PIN_BOARD_SDA) && defined(PIN_BOARD_SCL)
-  Wire.begin(PIN_BOARD_SDA, PIN_BOARD_SCL);
-#else
-  Wire.begin();
+  Wire.setPins(PIN_BOARD_SDA, PIN_BOARD_SCL)
 #endif
 
+  Wire.begin();
+
   pinMode(SX126X_POWER_EN, OUTPUT);
   digitalWrite(SX126X_POWER_EN, HIGH);
   delay(10);   // give sx1262 some time to power up
 }
 
-bool RAK4631Board::startOTAUpdate() {
-    // Config the peripheral connection with maximum bandwidth
-    // more SRAM required by SoftDevice
-    // Note: All config***() function must be called before begin()
-    Bluefruit.configPrphBandwidth(BANDWIDTH_MAX);
-    Bluefruit.configPrphConn(92, BLE_GAP_EVENT_LENGTH_MIN, 16, 16);
+bool RAK4631Board::startOTAUpdate(const char* id, char reply[]) {
+  // Config the peripheral connection with maximum bandwidth
+  // more SRAM required by SoftDevice
+  // Note: All config***() function must be called before begin()
+  Bluefruit.configPrphBandwidth(BANDWIDTH_MAX);
+  Bluefruit.configPrphConn(92, BLE_GAP_EVENT_LENGTH_MIN, 16, 16);
 
-    Bluefruit.begin(1, 0);
-    // Set max power. Accepted values are: -40, -30, -20, -16, -12, -8, -4, 0, 4
-    Bluefruit.setTxPower(4);
-    // Set the BLE device name
-    Bluefruit.setName("RAK4631_OTA");
+  Bluefruit.begin(1, 0);
+  // Set max power. Accepted values are: -40, -30, -20, -16, -12, -8, -4, 0, 4
+  Bluefruit.setTxPower(4);
+  // Set the BLE device name
+  Bluefruit.setName("RAK4631_OTA");
 
-    Bluefruit.Periph.setConnectCallback(connect_callback);
-    Bluefruit.Periph.setDisconnectCallback(disconnect_callback);
+  Bluefruit.Periph.setConnectCallback(connect_callback);
+  Bluefruit.Periph.setDisconnectCallback(disconnect_callback);
 
-    // To be consistent OTA DFU should be added first if it exists
-    bledfu.begin();
+  // To be consistent OTA DFU should be added first if it exists
+  bledfu.begin();
 
-    // Set up and start advertising
-    // Advertising packet
-    Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
-    Bluefruit.Advertising.addTxPower();
-    Bluefruit.Advertising.addName();
+  // Set up and start advertising
+  // Advertising packet
+  Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
+  Bluefruit.Advertising.addTxPower();
+  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)
+  /* 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
+    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
 
+  strcpy(reply, "OK - started");
   return true;
 }

src/helpers/nrf52/RAK4631Board.h

@@ -50,5 +50,5 @@ public:
     NVIC_SystemReset();
   }
 
-  bool startOTAUpdate() override;
+  bool startOTAUpdate(const char* id, char reply[]) override;
 };

src/helpers/nrf52/T1000eBoard.cpp

@@ -4,12 +4,13 @@
 
 #include <bluefruit.h>
 
-void T1000eBoard::begin()
-  {
+void T1000eBoard::begin() {
   // for future use, sub-classes SHOULD call this from their begin()
   startup_reason = BD_STARTUP_NORMAL;
   btn_prev_state = HIGH;
 
+  sd_power_mode_set(NRF_POWER_MODE_LOWPWR);
+
 #ifdef BUTTON_PIN
   pinMode(BATTERY_PIN, INPUT);
   pinMode(BUTTON_PIN, INPUT);
@@ -17,71 +18,70 @@ void T1000eBoard::begin()
 #endif
 
 #if defined(PIN_BOARD_SDA) && defined(PIN_BOARD_SCL)
-  Wire.begin(PIN_BOARD_SDA, PIN_BOARD_SCL);
-#else
-  Wire.begin();
+  Wire.setPins(PIN_BOARD_SDA, PIN_BOARD_SCL)
 #endif
 
+  Wire.begin();
+
   delay(10);   // give sx1262 some time to power up
 }
 
 #if 0
 static BLEDfu bledfu;
 
-static void connect_callback(uint16_t conn_handle)
-{
-    (void)conn_handle;
-    MESH_DEBUG_PRINTLN("BLE client connected");
+static void connect_callback(uint16_t conn_handle) {
+  (void)conn_handle;
+  MESH_DEBUG_PRINTLN("BLE client connected");
 }
 
-static void disconnect_callback(uint16_t conn_handle, uint8_t reason)
-{
-    (void)conn_handle;
-    (void)reason;
+static void disconnect_callback(uint16_t conn_handle, uint8_t reason) {
+  (void)conn_handle;
+  (void)reason;
 
-    MESH_DEBUG_PRINTLN("BLE client disconnected");
+  MESH_DEBUG_PRINTLN("BLE client disconnected");
 }
 
 
-bool TrackerT1000eBoard::startOTAUpdate() {
-    // Config the peripheral connection with maximum bandwidth
-    // more SRAM required by SoftDevice
-    // Note: All config***() function must be called before begin()
-    Bluefruit.configPrphBandwidth(BANDWIDTH_MAX);
-    Bluefruit.configPrphConn(92, BLE_GAP_EVENT_LENGTH_MIN, 16, 16);
+bool TrackerT1000eBoard::startOTAUpdate(const char* id, char reply[]) {
+  // Config the peripheral connection with maximum bandwidth
+  // more SRAM required by SoftDevice
+  // Note: All config***() function must be called before begin()
+  Bluefruit.configPrphBandwidth(BANDWIDTH_MAX);
+  Bluefruit.configPrphConn(92, BLE_GAP_EVENT_LENGTH_MIN, 16, 16);
 
-    Bluefruit.begin(1, 0);
-    // Set max power. Accepted values are: -40, -30, -20, -16, -12, -8, -4, 0, 4
-    Bluefruit.setTxPower(4);
-    // Set the BLE device name
-    Bluefruit.setName("T1000E_OTA");
+  Bluefruit.begin(1, 0);
+  // Set max power. Accepted values are: -40, -30, -20, -16, -12, -8, -4, 0, 4
+  Bluefruit.setTxPower(4);
+  // Set the BLE device name
+  Bluefruit.setName("T1000E_OTA");
 
-    Bluefruit.Periph.setConnectCallback(connect_callback);
-    Bluefruit.Periph.setDisconnectCallback(disconnect_callback);
+  Bluefruit.Periph.setConnectCallback(connect_callback);
+  Bluefruit.Periph.setDisconnectCallback(disconnect_callback);
 
-    // To be consistent OTA DFU should be added first if it exists
-    bledfu.begin();
+  // To be consistent OTA DFU should be added first if it exists
+  bledfu.begin();
 
-    // Set up and start advertising
-    // Advertising packet
-    Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
-    Bluefruit.Advertising.addTxPower();
-    Bluefruit.Advertising.addName();
+  // Set up and start advertising
+  // Advertising packet
+  Bluefruit.Advertising.addFlags(BLE_GAP_ADV_FLAGS_LE_ONLY_GENERAL_DISC_MODE);
+  Bluefruit.Advertising.addTxPower();
+  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)
+  /* 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
+    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
 
+  strcpy(reply, "OK - started");
   return true;
 }
 #endif

src/helpers/nrf52/T1000eBoard.h

@@ -3,8 +3,6 @@
 #include <MeshCore.h>
 #include <Arduino.h>
 
-#define HAS_T1000e_POWEROFF
-
 // LoRa and SPI pins
 #define  P_LORA_DIO_1   (32 + 1)  // P1.1
 #define  P_LORA_NSS     (0 + 12)  // P0.12
@@ -61,7 +59,7 @@ public:
     return 0;
   }
 
-  void powerOff() {
+  void powerOff() override {
     #ifdef HAS_GPS
         digitalWrite(GPS_VRTC_EN, LOW);
         digitalWrite(GPS_RESET, LOW);
@@ -92,5 +90,5 @@ public:
     NVIC_SystemReset();
   }
 
-//  bool startOTAUpdate() override;
+//  bool startOTAUpdate(const char* id, char reply[]) override;
 };

src/helpers/nrf52/T114Board.cpp

@@ -27,11 +27,11 @@ void T114Board::begin() {
   pinMode(PIN_VBAT_READ, INPUT);
 
 #if defined(PIN_BOARD_SDA) && defined(PIN_BOARD_SCL)
-  Wire.begin(PIN_BOARD_SDA, PIN_BOARD_SCL);
-#else
-  Wire.begin();
+  Wire.setPins(PIN_BOARD_SDA, PIN_BOARD_SCL)
 #endif
 
+  Wire.begin();
+
 #ifdef P_LORA_TX_LED
   pinMode(P_LORA_TX_LED, OUTPUT);
   digitalWrite(P_LORA_TX_LED, HIGH);
@@ -42,7 +42,7 @@ void T114Board::begin() {
   delay(10);   // give sx1262 some time to power up
 }
 
-bool T114Board::startOTAUpdate() {
+bool T114Board::startOTAUpdate(const char* id, char reply[]) {
   // Config the peripheral connection with maximum bandwidth
   // more SRAM required by SoftDevice
   // Note: All config***() function must be called before begin()
@@ -81,5 +81,6 @@ bool T114Board::startOTAUpdate() {
   Bluefruit.Advertising.setFastTimeout(30);   // number of seconds in fast mode
   Bluefruit.Advertising.start(0);             // 0 = Don't stop advertising after n seconds
 
+  strcpy(reply, "OK - started");
   return true;
 }

src/helpers/nrf52/T114Board.h

@@ -18,7 +18,8 @@
 
 // built-ins
 #define  PIN_VBAT_READ    4
-#define  ADC_MULTIPLIER   (3 * 1.73 * 1.187 * 1000)
+#define  PIN_BAT_CTL      6
+#define  MV_LSB   (3000.0F / 4096.0F) // 12-bit ADC with 3.0V input range
 
 class T114Board : public mesh::MainBoard {
 protected:
@@ -37,17 +38,18 @@ public:
   }
 #endif
 
-  #define BATTERY_SAMPLES 8
-
   uint16_t getBattMilliVolts() override {
+    int adcvalue = 0;
     analogReadResolution(12);
-    uint32_t raw = 0;
-    for (int i = 0; i < BATTERY_SAMPLES; i++) {
-      raw += analogRead(PIN_VBAT_READ);
-    }
-    raw = raw / BATTERY_SAMPLES;
+    analogReference(AR_INTERNAL_3_0);
+    pinMode(PIN_BAT_CTL, OUTPUT);          // battery adc can be read only ctrl pin 6 set to high
+    digitalWrite(PIN_BAT_CTL, 1);
 
-    return (ADC_MULTIPLIER * raw) / 4096;
+    delay(10);
+    adcvalue = analogRead(PIN_VBAT_READ);
+    digitalWrite(6, 0);
+
+    return (uint16_t)((float)adcvalue * MV_LSB * 4.9);
   }
 
   const char* getManufacturerName() const override {
@@ -58,5 +60,5 @@ public:
     NVIC_SystemReset();
   }
 
-  bool startOTAUpdate() override;
+  bool startOTAUpdate(const char* id, char reply[]) override;
 };

src/helpers/nrf52/TechoBoard.cpp

@@ -1,19 +1,19 @@
 #include <Arduino.h>
 #include "TechoBoard.h"
 
+#ifdef LILYGO_TECHO
+
 #include <bluefruit.h>
 #include <Wire.h>
 
 static BLEDfu bledfu;
 
-static void connect_callback(uint16_t conn_handle)
-{
+static void connect_callback(uint16_t conn_handle) {
   (void)conn_handle;
   MESH_DEBUG_PRINTLN("BLE client connected");
 }
 
-static void disconnect_callback(uint16_t conn_handle, uint8_t reason)
-{
+static void disconnect_callback(uint16_t conn_handle, uint8_t reason) {
   (void)conn_handle;
   (void)reason;
 
@@ -24,20 +24,41 @@ void TechoBoard::begin() {
   // for future use, sub-classes SHOULD call this from their begin()
   startup_reason = BD_STARTUP_NORMAL;
 
-  pinMode(PIN_VBAT_READ, INPUT);
+  delay(200);
+  pinMode(PIN_PWR_EN, OUTPUT);
+  digitalWrite(PIN_PWR_EN, HIGH);
+  pinMode(PIN_BUTTON1, INPUT_PULLUP);
+  pinMode(PIN_BUTTON2, INPUT_PULLUP);
+  pinMode(LED_RED, OUTPUT);
+  pinMode(LED_GREEN, OUTPUT);
+  pinMode(LED_BLUE, OUTPUT);
+  delay(200);
+
+  pinMode(PIN_TXCO, OUTPUT);
+  digitalWrite(PIN_TXCO, HIGH);
 
-#if defined(PIN_BOARD_SDA) && defined(PIN_BOARD_SCL)
-  Wire.begin(PIN_BOARD_SDA, PIN_BOARD_SCL);
-#else
   Wire.begin();
-#endif
 
   pinMode(SX126X_POWER_EN, OUTPUT);
   digitalWrite(SX126X_POWER_EN, HIGH);
   delay(10);   // give sx1262 some time to power up
 }
 
-bool TechoBoard::startOTAUpdate() {
+uint16_t TechoBoard::getBattMilliVolts() {
+  int adcvalue = 0;
+
+  analogReference(AR_INTERNAL_3_0);
+  analogReadResolution(12);
+  delay(10);
+
+  // ADC range is 0..3000mV and resolution is 12-bit (0..4095)
+  adcvalue = analogRead(PIN_VBAT_READ);
+  // Convert the raw value to compensated mv, taking the resistor-
+  // divider into account (providing the actual LIPO voltage)
+  return (uint16_t)((float)adcvalue * REAL_VBAT_MV_PER_LSB);
+}
+
+bool TechoBoard::startOTAUpdate(const char* id, char reply[]) {
   // Config the peripheral connection with maximum bandwidth
   // more SRAM required by SoftDevice
   // Note: All config***() function must be called before begin()
@@ -76,5 +97,7 @@ bool TechoBoard::startOTAUpdate() {
   Bluefruit.Advertising.setFastTimeout(30);   // number of seconds in fast mode
   Bluefruit.Advertising.start(0);             // 0 = Don't stop advertising after n seconds
 
+  strcpy(reply, "OK - started");
   return true;
 }
+#endif

src/helpers/nrf52/TechoBoard.h

@@ -17,28 +17,26 @@
 #define SX126X_DIO3_TCXO_VOLTAGE   1.8
 
 // built-ins
-#define  PIN_VBAT_READ    4
-#define  ADC_MULTIPLIER   (2.0)
+#define VBAT_MV_PER_LSB   (0.73242188F)   // 3.0V ADC range and 12-bit ADC resolution = 3000mV/4096
+
+#define VBAT_DIVIDER      (0.5F)          // 150K + 150K voltage divider on VBAT
+#define VBAT_DIVIDER_COMP (2.0F)          // Compensation factor for the VBAT divider
+
+#define PIN_VBAT_READ     (4)
+#define REAL_VBAT_MV_PER_LSB (VBAT_DIVIDER_COMP * VBAT_MV_PER_LSB)
 
 class TechoBoard : public mesh::MainBoard {
 protected:
   uint8_t startup_reason;
 
 public:
+
   void begin();
-  uint8_t getStartupReason() const override { return startup_reason; }
+  uint16_t getBattMilliVolts() override;
+  bool startOTAUpdate(const char* id, char reply[]) override;
 
-  #define BATTERY_SAMPLES 8
-
-  uint16_t getBattMilliVolts() override {
-    analogReadResolution(12);
-    uint32_t raw = 0;
-    for (int i = 0; i < BATTERY_SAMPLES; i++) {
-      raw += analogRead(PIN_VBAT_READ);
-    }
-    raw = raw / BATTERY_SAMPLES;
-
-    return (ADC_MULTIPLIER * raw) / 4096;
+  uint8_t getStartupReason() const override {
+    return startup_reason;
   }
 
   const char* getManufacturerName() const override {
@@ -48,6 +46,4 @@ public:
   void reboot() override {
     NVIC_SystemReset();
   }
-
-  bool startOTAUpdate() override;
 };

src/helpers/ui/DisplayDriver.h

@@ -15,6 +15,7 @@ public:
   virtual bool isOn() = 0;
   virtual void turnOn() = 0;
   virtual void turnOff() = 0;
+  virtual void clear() = 0;
   virtual void startFrame(Color bkg = DARK) = 0;
   virtual void setTextSize(int sz) = 0;
   virtual void setColor(Color c) = 0;

src/helpers/ui/SSD1306Display.cpp

@@ -1,7 +1,13 @@
 #include "SSD1306Display.h"
 
+bool SSD1306Display::i2c_probe(TwoWire& wire, uint8_t addr) {
+  wire.beginTransmission(addr);
+  uint8_t error = wire.endTransmission();
+  return (error == 0);
+}
+
 bool SSD1306Display::begin() {
-  return display.begin(SSD1306_SWITCHCAPVCC, DISPLAY_ADDRESS, true, false);
+  return display.begin(SSD1306_SWITCHCAPVCC, DISPLAY_ADDRESS, true, false) && i2c_probe(Wire, DISPLAY_ADDRESS);
 }
 
 void SSD1306Display::turnOn() {
@@ -14,6 +20,11 @@ void SSD1306Display::turnOff() {
   _isOn = false;
 }
 
+void SSD1306Display::clear() {
+  display.clearDisplay();
+  display.display();
+}
+
 void SSD1306Display::startFrame(Color bkg) {
   display.clearDisplay();  // TODO: apply 'bkg'
   _color = SSD1306_WHITE;

src/helpers/ui/SSD1306Display.h

@@ -3,6 +3,7 @@
 #include "DisplayDriver.h"
 #include <Wire.h>
 #include <Adafruit_GFX.h>
+#define SSD1306_NO_SPLASH
 #include <Adafruit_SSD1306.h>
 
 #ifndef PIN_OLED_RESET
@@ -18,6 +19,7 @@ class SSD1306Display : public DisplayDriver {
   bool _isOn;
   uint8_t _color;
 
+  bool i2c_probe(TwoWire& wire, uint8_t addr);
 public:
   SSD1306Display() : DisplayDriver(128, 64), display(128, 64, &Wire, PIN_OLED_RESET) { _isOn = false; }
   bool begin();
@@ -25,6 +27,7 @@ public:
   bool isOn() override { return _isOn; }
   void turnOn() override;
   void turnOff() override;
+  void clear() override;
   void startFrame(Color bkg = DARK) override;
   void setTextSize(int sz) override;
   void setColor(Color c) override;

variants/generic_espnow/platformio.ini

@@ -0,0 +1,82 @@
+
+; ----------- Generic ESP32-C3 ------------
+
+[Generic_ESPNOW]
+extends = esp32_base
+board = esp32-c3-devkitm-1
+;board = esp32-s3-devkitm-1
+build_flags =
+  ${esp32_base.build_flags}
+  -I variants/generic_espnow
+;  -D ESP32_CPU_FREQ=80
+  -D PIN_BOARD_SDA=-1
+  -D PIN_BOARD_SCL=-1
+;  -D P_LORA_TX_LED=8
+  -D PIN_USER_BTN=0
+;  -D ARDUINO_USB_MODE=1
+;  -D ARDUINO_USB_CDC_ON_BOOT=1
+;  -D ESPNOW_DEBUG_LOGGING=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${esp32_base.build_src_filter}
+  +<helpers/esp32/ESPNowRadio.cpp>
+  +<../variants/generic_espnow>
+
+[env:Generic_ESPNOW_terminal_chat]
+extends = Generic_ESPNOW
+build_flags =
+  ${Generic_ESPNOW.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=1
+build_src_filter = ${Generic_ESPNOW.build_src_filter}
+  +<../examples/simple_secure_chat/main.cpp>
+lib_deps =
+  ${Generic_ESPNOW.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Generic_ESPNOW_repeatr]
+extends = Generic_ESPNOW
+build_flags =
+  ${Generic_ESPNOW.build_flags}
+  -D ADVERT_NAME='"ESPNOW Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+build_src_filter = ${Generic_ESPNOW.build_src_filter}
+  +<../examples/simple_repeater/main.cpp>
+lib_deps =
+  ${Generic_ESPNOW.lib_deps}
+  ${esp32_ota.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Generic_ESPNOW_comp_radio_usb]
+extends = Generic_ESPNOW
+build_flags =
+  ${Generic_ESPNOW.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
+; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
+; NOTE: DO NOT ENABLE -->  -D ESPNOW_DEBUG_LOGGING=1
+build_src_filter = ${Generic_ESPNOW.build_src_filter}
+  +<../examples/companion_radio/main.cpp>
+lib_deps =
+  ${Generic_ESPNOW.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Generic_ESPNOW_room_svr]
+extends = Generic_ESPNOW
+build_flags =
+  ${Generic_ESPNOW.build_flags}
+  -D ADVERT_NAME='"Heltec Room"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D ROOM_PASSWORD='"hello"'
+build_src_filter = ${Generic_ESPNOW.build_src_filter}
+  +<../examples/simple_room_server/main.cpp>
+lib_deps =
+  ${Generic_ESPNOW.lib_deps}
+  ${esp32_ota.lib_deps}

variants/generic_espnow/target.cpp

@@ -0,0 +1,33 @@
+#include <Arduino.h>
+#include "target.h"
+#include <helpers/ArduinoHelpers.h>
+
+ESP32Board board;
+
+ESPNOWRadio radio_driver;
+
+ESP32RTCClock rtc_clock;
+
+bool radio_init() {
+  rtc_clock.begin();
+
+  // NOTE: radio_driver.begin() is called by Dispatcher::begin(), so not needed here
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return millis() + radio_driver.intID();  // TODO: where to get some entropy?
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  // no-op
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio_driver.setTxPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  StdRNG  rng;  // TODO: need stronger True-RNG here
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/generic_espnow/target.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <helpers/ESP32Board.h>
+#include <helpers/esp32/ESPNOWRadio.h>
+
+extern ESP32Board board;
+extern ESPNOWRadio radio_driver;
+extern ESP32RTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/heltec_v2/platformio.ini

@@ -0,0 +1,109 @@
+[Heltec_lora32_v2]
+extends = esp32_base
+board = heltec_wifi_lora_32_V2   ; heltec_wifi_lora_32_V2
+build_flags =
+  ${esp32_base.build_flags}
+  -I variants/heltec_v2
+  -D HELTEC_LORA_V2
+  -D PIN_BOARD_SDA=4
+  -D PIN_BOARD_SCL=15
+  -D PIN_USER_BTN=0
+  -D PIN_OLED_RESET=16
+  -D RADIO_CLASS=CustomSX1276
+  -D WRAPPER_CLASS=CustomSX1276Wrapper
+  -D LORA_TX_POWER=20
+  -D P_LORA_TX_LED=25
+build_src_filter = ${esp32_base.build_src_filter}
+  +<../variants/heltec_v2>
+lib_deps =
+  ${esp32_base.lib_deps}
+  adafruit/Adafruit SSD1306 @ ^2.5.13
+
+[env:Heltec_v2_repeater]
+extends = Heltec_lora32_v2
+build_flags =
+  ${Heltec_lora32_v2.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D ADVERT_NAME='"Heltec Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v2.build_src_filter}
+  +<../examples/simple_repeater>
+  +<helpers/ui/*.cpp>
+lib_deps =
+  ${Heltec_lora32_v2.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:Heltec_v2_room_server]
+extends = Heltec_lora32_v2
+build_flags =
+  ${Heltec_lora32_v2.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D ADVERT_NAME='"Heltec Room"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D ROOM_PASSWORD='"hello"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v2.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/simple_room_server>
+lib_deps =
+  ${Heltec_lora32_v2.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:Heltec_v2_terminal_chat]
+extends = Heltec_lora32_v2
+build_flags =
+  ${Heltec_lora32_v2.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v2.build_src_filter}
+  +<../examples/simple_secure_chat/main.cpp>
+lib_deps =
+  ${Heltec_lora32_v2.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Heltec_v2_companion_radio_usb]
+extends = Heltec_lora32_v2
+build_flags =
+  ${Heltec_lora32_v2.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
+; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v2.build_src_filter}
+  +<helpers/esp32/*.cpp>
+  +<helpers/ui/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${Heltec_lora32_v2.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Heltec_v2_companion_radio_ble]
+extends = Heltec_lora32_v2
+build_flags =
+  ${Heltec_lora32_v2.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D BLE_PIN_CODE=0
+  -D BLE_DEBUG_LOGGING=1
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v2.build_src_filter}
+  +<helpers/esp32/*.cpp>
+  +<helpers/ui/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${Heltec_lora32_v2.lib_deps}
+  densaugeo/base64 @ ~1.4.0

variants/heltec_v2/target.cpp

@@ -0,0 +1,59 @@
+#include <Arduino.h>
+#include "target.h"
+
+HeltecV2Board board;
+
+#if defined(P_LORA_SCLK)
+  static SPIClass spi;
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, spi);
+#else
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY);
+#endif
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+ESP32RTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  fallback_clock.begin();
+  rtc_clock.begin(Wire);
+  
+#if defined(P_LORA_SCLK)
+  spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI);
+#endif
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+
+  radio.setCRC(1);
+  
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/heltec_v2/target.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/HeltecV2Board.h>
+#include <helpers/CustomSX1276Wrapper.h>
+#include <helpers/AutoDiscoverRTCClock.h>
+
+extern HeltecV2Board board;
+extern WRAPPER_CLASS radio_driver;
+extern AutoDiscoverRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/heltec_v3/platformio.ini

@@ -0,0 +1,187 @@
+[Heltec_lora32_v3]
+extends = esp32_base
+board = esp32-s3-devkitc-1
+build_flags =
+  ${esp32_base.build_flags}
+  -I variants/heltec_v3
+  -D HELTEC_LORA_V3
+  -D RADIO_CLASS=CustomSX1262
+  -D WRAPPER_CLASS=CustomSX1262Wrapper
+  -D LORA_TX_POWER=22
+  -D P_LORA_TX_LED=35
+  -D PIN_BOARD_SDA=17
+  -D PIN_BOARD_SCL=18
+  -D PIN_USER_BTN=0
+  -D SX126X_DIO2_AS_RF_SWITCH=true
+  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
+  -D SX126X_CURRENT_LIMIT=130.0f  ; for best TX power!
+  -D SX126X_RX_BOOSTED_GAIN=1
+build_src_filter = ${esp32_base.build_src_filter}
+  +<../variants/heltec_v3>
+lib_deps =
+  ${esp32_base.lib_deps}
+  adafruit/Adafruit SSD1306 @ ^2.5.13
+
+[env:Heltec_v3_repeater]
+extends = Heltec_lora32_v3
+build_flags =
+  ${Heltec_lora32_v3.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D ADVERT_NAME='"Heltec Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v3.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/simple_repeater>
+lib_deps =
+  ${Heltec_lora32_v3.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:Heltec_v3_room_server]
+extends = Heltec_lora32_v3
+build_flags =
+  ${Heltec_lora32_v3.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D ADVERT_NAME='"Heltec Room"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D ROOM_PASSWORD='"hello"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v3.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/simple_room_server>
+lib_deps =
+  ${Heltec_lora32_v3.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:Heltec_v3_terminal_chat]
+extends = Heltec_lora32_v3
+build_flags =
+  ${Heltec_lora32_v3.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v3.build_src_filter}
+  +<../examples/simple_secure_chat/main.cpp>
+lib_deps =
+  ${Heltec_lora32_v3.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Heltec_v3_companion_radio_usb]
+extends = Heltec_lora32_v3
+build_flags =
+  ${Heltec_lora32_v3.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D DISPLAY_CLASS=SSD1306Display
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
+; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v3.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${Heltec_lora32_v3.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Heltec_v3_companion_radio_ble]
+extends = Heltec_lora32_v3
+build_flags =
+  ${Heltec_lora32_v3.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D DISPLAY_CLASS=SSD1306Display
+  -D BLE_PIN_CODE=0   ; dynamic, random PIN
+  -D BLE_DEBUG_LOGGING=1
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v3.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<helpers/esp32/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${Heltec_lora32_v3.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Heltec_v3_companion_radio_wifi]
+extends = Heltec_lora32_v3
+build_flags =
+  ${Heltec_lora32_v3.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D DISPLAY_CLASS=SSD1306Display
+  -D WIFI_DEBUG_LOGGING=1
+  -D WIFI_SSID='"myssid"'
+  -D WIFI_PWD='"mypwd"'
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v3.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<helpers/esp32/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${Heltec_lora32_v3.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Heltec_WSL3_repeater]
+extends = Heltec_lora32_v3
+build_flags =
+  ${Heltec_lora32_v3.build_flags}
+  -D ADVERT_NAME='"Heltec Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v3.build_src_filter}
+  +<../examples/simple_repeater>
+lib_deps =
+  ${Heltec_lora32_v3.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:Heltec_WSL3_room_server]
+extends = Heltec_lora32_v3
+build_src_filter = ${Heltec_lora32_v3.build_src_filter}
+  +<../examples/simple_room_server>
+build_flags =
+  ${Heltec_lora32_v3.build_flags}
+  -D ADVERT_NAME='"Heltec Room"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D ROOM_PASSWORD='"hello"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+lib_deps =
+  ${Heltec_lora32_v3.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:Heltec_WSL3_companion_radio_ble]
+extends = Heltec_lora32_v3
+build_flags =
+  ${Heltec_lora32_v3.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D BLE_PIN_CODE=123456
+  -D BLE_DEBUG_LOGGING=1
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_lora32_v3.build_src_filter}
+  +<helpers/esp32/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${Heltec_lora32_v3.lib_deps}
+  densaugeo/base64 @ ~1.4.0

variants/heltec_v3/target.cpp

@@ -0,0 +1,75 @@
+#include <Arduino.h>
+#include "target.h"
+
+HeltecV3Board board;
+
+#if defined(P_LORA_SCLK)
+  static SPIClass spi;
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, spi);
+#else
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY);
+#endif
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+ESP32RTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  fallback_clock.begin();
+  rtc_clock.begin(Wire);
+  
+#ifdef SX126X_DIO3_TCXO_VOLTAGE
+  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
+#else
+  float tcxo = 1.6f;
+#endif
+
+#if defined(P_LORA_SCLK)
+  spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI);
+#endif
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+  
+  radio.setCRC(1);
+  
+#ifdef SX126X_CURRENT_LIMIT
+  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
+#endif
+#ifdef SX126X_DIO2_AS_RF_SWITCH
+  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
+#endif
+#ifdef SX126X_RX_BOOSTED_GAIN
+  radio.setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
+#endif
+
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/heltec_v3/target.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/HeltecV3Board.h>
+#include <helpers/CustomSX1262Wrapper.h>
+#include <helpers/AutoDiscoverRTCClock.h>
+
+extern HeltecV3Board board;
+extern WRAPPER_CLASS radio_driver;
+extern AutoDiscoverRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/lilygo_t3s3/platformio.ini

@@ -0,0 +1,124 @@
+[LilyGo_T3S3_sx1262]
+extends = esp32_base
+board = t3_s3_v1_x
+build_flags =
+  ${esp32_base.build_flags}
+  -I variants/lilygo_t3s3
+  -D LILYGO_T3S3
+  -D P_LORA_DIO_1=33
+  -D P_LORA_NSS=7
+  -D P_LORA_RESET=8   ; RADIOLIB_NC
+  -D P_LORA_BUSY=34
+  -D P_LORA_SCLK=5
+  -D P_LORA_MISO=3
+  -D P_LORA_MOSI=6
+  -D P_LORA_TX_LED=37
+  -D PIN_VBAT_READ=1
+  -D PIN_USER_BTN=0
+  -D PIN_BOARD_SDA=18
+  -D PIN_BOARD_SCL=17
+  -D P_LORA_TX_LED=37
+  -D PIN_OLED_RESET=21
+  -D SX126X_DIO2_AS_RF_SWITCH=true
+  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
+  -D SX126X_CURRENT_LIMIT=130
+  -D RADIO_CLASS=CustomSX1262
+  -D WRAPPER_CLASS=CustomSX1262Wrapper
+  -D LORA_TX_POWER=22
+  -D SX126X_RX_BOOSTED_GAIN=1
+build_src_filter = ${esp32_base.build_src_filter}
+  +<../variants/lilygo_t3s3>
+lib_deps =
+  ${esp32_base.lib_deps}
+  adafruit/Adafruit SSD1306 @ ^2.5.13
+
+; === LilyGo T3S3 with SX1262 environments ===
+[env:LilyGo_T3S3_sx1262_Repeater]
+extends = LilyGo_T3S3_sx1262
+build_flags =
+  ${LilyGo_T3S3_sx1262.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D ADVERT_NAME='"T3S3-1262 Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${LilyGo_T3S3_sx1262.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/simple_repeater>
+lib_deps =
+  ${LilyGo_T3S3_sx1262.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:LilyGo_T3S3_sx1262_terminal_chat]
+extends = LilyGo_T3S3_sx1262
+build_flags =
+  ${LilyGo_T3S3_sx1262.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${LilyGo_T3S3_sx1262.build_src_filter}
+  +<../examples/simple_secure_chat/main.cpp>
+lib_deps =
+  ${LilyGo_T3S3_sx1262.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:LilyGo_T3S3_sx1262_room_server]
+extends = LilyGo_T3S3_sx1262
+build_flags =
+  ${LilyGo_T3S3_sx1262.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D ADVERT_NAME='"T3S3-1262 Room"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D ROOM_PASSWORD='"hello"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${LilyGo_T3S3_sx1262.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/simple_room_server>
+lib_deps =
+  ${LilyGo_T3S3_sx1262.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:LilyGo_T3S3_sx1262_companion_radio_usb]
+extends = LilyGo_T3S3_sx1262
+build_flags =
+  ${LilyGo_T3S3_sx1262.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
+; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
+build_src_filter = ${LilyGo_T3S3_sx1262.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${LilyGo_T3S3_sx1262.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:LilyGo_T3S3_sx1262_companion_radio_ble]
+extends = LilyGo_T3S3_sx1262
+build_flags =
+  ${LilyGo_T3S3_sx1262.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D BLE_PIN_CODE=123456
+  -D BLE_DEBUG_LOGGING=1
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${LilyGo_T3S3_sx1262.build_src_filter}
+  +<helpers/esp32/*.cpp>
+  +<helpers/ui/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${LilyGo_T3S3_sx1262.lib_deps}
+  densaugeo/base64 @ ~1.4.0

variants/lilygo_t3s3/target.cpp

@@ -0,0 +1,75 @@
+#include <Arduino.h>
+#include "target.h"
+
+ESP32Board board;
+
+#if defined(P_LORA_SCLK)
+  static SPIClass spi;
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, spi);
+#else
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY);
+#endif
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+ESP32RTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  fallback_clock.begin();
+  rtc_clock.begin(Wire);
+  
+#ifdef SX126X_DIO3_TCXO_VOLTAGE
+  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
+#else
+  float tcxo = 1.6f;
+#endif
+
+#if defined(P_LORA_SCLK)
+  spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI);
+#endif
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+  
+  radio.setCRC(1);
+  
+#ifdef SX126X_CURRENT_LIMIT
+  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
+#endif
+#ifdef SX126X_DIO2_AS_RF_SWITCH
+  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
+#endif
+#ifdef SX126X_RX_BOOSTED_GAIN
+  radio.setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
+#endif
+
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/lilygo_t3s3/target.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/ESP32Board.h>
+#include <helpers/CustomSX1262Wrapper.h>
+#include <helpers/AutoDiscoverRTCClock.h>
+
+extern ESP32Board board;
+extern WRAPPER_CLASS radio_driver;
+extern AutoDiscoverRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/lilygo_tbeam/platformio.ini

@@ -0,0 +1,64 @@
+[LilyGo_TBeam]
+extends = esp32_base
+board = ttgo-t-beam
+build_flags =
+  ${esp32_base.build_flags}
+  -I variants/lilygo_tbeam
+  -D LILYGO_TBEAM
+  -D RADIO_CLASS=CustomSX1276
+  -D WRAPPER_CLASS=CustomSX1276Wrapper
+  -D LORA_TX_POWER=20
+  -D P_LORA_TX_LED=4
+  -D PIN_BOARD_SDA=21
+  -D PIN_BOARD_SCL=22
+  -D PIN_USER_BTN=38
+build_src_filter = ${esp32_base.build_src_filter}
+  +<../variants/lilygo_tbeam>
+board_build.partitions = min_spiffs.csv ; get around 4mb flash limit
+lib_deps =
+  ${esp32_base.lib_deps}
+  lewisxhe/XPowersLib@^0.2.7
+  adafruit/Adafruit SSD1306 @ ^2.5.13
+
+[env:Tbeam_companion_radio_ble]
+extends = LilyGo_TBeam
+board_build.upload.maximum_ram_size=2000000
+build_flags =
+  ${LilyGo_TBeam.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=1
+  -D BLE_PIN_CODE=123456
+  -D BLE_DEBUG_LOGGING=1
+  -D MESH_PACKET_LOGGING=1
+  -D MESH_DEBUG=1
+  -D RADIOLIB_DEBUG_BASIC=1
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${LilyGo_TBeam.build_src_filter}
+  +<helpers/esp32/*.cpp>
+  +<helpers/ui/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${LilyGo_TBeam.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Tbeam_repeater]
+extends = LilyGo_TBeam
+build_flags =
+  ${LilyGo_TBeam.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D ADVERT_NAME='"Tbeam Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${LilyGo_TBeam.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/simple_repeater>
+lib_deps =
+  ${LilyGo_TBeam.lib_deps}
+  ${esp32_ota.lib_deps}

variants/lilygo_tbeam/target.cpp

@@ -0,0 +1,59 @@
+#include <Arduino.h>
+#include "target.h"
+
+TBeamBoard board;
+
+#if defined(P_LORA_SCLK)
+  static SPIClass spi;
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_0, P_LORA_RESET, P_LORA_DIO_1, spi);
+#else
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_0, P_LORA_RESET, P_LORA_DIO_1);
+#endif
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+ESP32RTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  fallback_clock.begin();
+  rtc_clock.begin(Wire);
+  
+#if defined(P_LORA_SCLK)
+  spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI);
+#endif
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+
+  radio.setCRC(1);
+  
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/lilygo_tbeam/target.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/TBeamBoard.h>
+#include <helpers/CustomSX1276Wrapper.h>
+#include <helpers/AutoDiscoverRTCClock.h>
+
+extern TBeamBoard board;
+extern WRAPPER_CLASS radio_driver;
+extern AutoDiscoverRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/lilygo_tlora_v2_1/platformio.ini

@@ -0,0 +1,120 @@
+[LilyGo_TLora_V2_1_1_6]
+extends = esp32_base
+board = ttgo-lora32-v1  ; LILYGO T-LoRa V2.1-1.6 ESP32 with SX1276
+build_unflags = -Os
+build_type = release  ; Set build type to release
+board_build.partitions = min_spiffs.csv ; get around 4mb flash limit
+build_flags =
+  ${esp32_base.build_flags}
+  -I variants/lilygo_tlora_v2_1
+  -Os -ffunction-sections -fdata-sections  ; Optimize for size
+  -D LILYGO_TLORA  ; LILYGO T-LoRa V2.1-1.6 ESP32 with SX1276
+  -D P_LORA_DIO_0=26    ; SX1276 DIO0 interrupt pin
+  -D P_LORA_DIO_1=33    ; SX1276 DIO1 interrupt pin
+  -D P_LORA_NSS=18      ; Chip select - SS pin
+  -D P_LORA_RESET=14    ; Reset pin
+  -D P_LORA_SCLK=5      ; SPI clock
+  -D P_LORA_MISO=19     ; SPI MISO
+  -D P_LORA_MOSI=27     ; SPI MOSI
+  -D P_LORA_TX_LED=2    ; LED pin for TX indication
+  -D PIN_VBAT_READ=35   ; Battery voltage reading (analog pin)
+  -D PIN_USER_BTN=0
+  -D RADIO_CLASS=CustomSX1276
+  -D ARDUINO_LOOP_STACK_SIZE=16384
+  -D DISPLAY_CLASS=SSD1306Display
+  -D WRAPPER_CLASS=CustomSX1276Wrapper
+  -D LORA_TX_POWER=20
+build_src_filter = ${esp32_base.build_src_filter}
+  +<../variants/lilygo_tlora_v2_1>
+lib_deps =
+  ${esp32_base.lib_deps}
+  adafruit/Adafruit SSD1306 @ ^2.5.13
+
+; === LILYGO T-LoRa V2.1-1.6 with SX1276 environments ===
+[env:LilyGo_TLora_V2_1_1_6_Repeater]
+extends = LilyGo_TLora_V2_1_1_6
+build_src_filter = ${LilyGo_TLora_V2_1_1_6.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/simple_repeater>
+build_flags =
+  ${LilyGo_TLora_V2_1_1_6.build_flags}
+  -D ADVERT_NAME='"TLora-V2.1-1.6 Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+;  -D CORE_DEBUG_LEVEL=3
+lib_deps =
+  ${LilyGo_TLora_V2_1_1_6.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:LilyGo_TLora_V2_1_1_6_terminal_chat]
+extends = LilyGo_TLora_V2_1_1_6
+build_flags =
+  ${LilyGo_TLora_V2_1_1_6.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${LilyGo_TLora_V2_1_1_6.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/simple_repeater>
+lib_deps =
+  ${LilyGo_TLora_V2_1_1_6.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:LilyGo_TLora_V2_1_1_6_companion_radio_usb]
+extends = LilyGo_TLora_V2_1_1_6
+build_flags =
+  ${LilyGo_TLora_V2_1_1_6.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
+; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
+build_src_filter = ${LilyGo_TLora_V2_1_1_6.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${LilyGo_TLora_V2_1_1_6.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:LilyGo_TLora_V2_1_1_6_companion_radio_ble]
+extends = LilyGo_TLora_V2_1_1_6
+build_flags =
+  ${LilyGo_TLora_V2_1_1_6.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D BLE_PIN_CODE=123456
+;  -D BLE_DEBUG_LOGGING=1
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${LilyGo_TLora_V2_1_1_6.build_src_filter}
+  +<helpers/esp32/*.cpp>
+  +<helpers/ui/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${LilyGo_TLora_V2_1_1_6.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:LilyGo_TLora_V2_1_1_6_room_server]
+extends = LilyGo_TLora_V2_1_1_6
+build_src_filter = ${LilyGo_TLora_V2_1_1_6.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/simple_room_server>
+build_flags =
+  ${LilyGo_TLora_V2_1_1_6.build_flags}
+  -D ADVERT_NAME='"TLora-V2.1-1.6 Room"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D ROOM_PASSWORD='"hello"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+lib_deps =
+  ${LilyGo_TLora_V2_1_1_6.lib_deps}
+  ${esp32_ota.lib_deps}

variants/lilygo_tlora_v2_1/target.cpp

@@ -0,0 +1,53 @@
+#include <Arduino.h>
+#include "target.h"
+
+LilyGoTLoraBoard board;
+
+static SPIClass spi;
+RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_0, P_LORA_RESET, P_LORA_DIO_1, spi);
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+ESP32RTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  fallback_clock.begin();
+  rtc_clock.begin(Wire);
+  
+  spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI);
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+
+  radio.setCRC(1);
+  
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/lilygo_tlora_v2_1/target.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/LilyGoTLoraBoard.h>
+#include <helpers/CustomSX1276Wrapper.h>
+#include <helpers/AutoDiscoverRTCClock.h>
+
+extern LilyGoTLoraBoard board;
+extern WRAPPER_CLASS radio_driver;
+extern AutoDiscoverRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/promicro/platformio.ini

@@ -0,0 +1,187 @@
+[Faketec]
+extends = nrf52840_base
+board = promicro_nrf52840
+build_flags = ${nrf52840_base.build_flags}
+  -I variants/promicro
+  -D FAKETEC
+  -D RADIO_CLASS=CustomSX1262
+  -D WRAPPER_CLASS=CustomSX1262Wrapper
+  -D LORA_TX_POWER=22
+  -D SX126X_CURRENT_LIMIT=130
+  -D SX126X_RX_BOOSTED_GAIN=1
+  -D DISPLAY_CLASS=SSD1306Display
+  -D PIN_BOARD_SCL=7
+  -D PIN_BOARD_SDA=8
+  -D PIN_OLED_RESET=-1
+  -D PIN_USER_BTN=6
+build_src_filter = ${nrf52840_base.build_src_filter}
+  +<helpers/nrf52/PromicroBoard.cpp>
+  +<../variants/promicro>
+lib_deps=
+  ${nrf52840_base.lib_deps}
+	adafruit/Adafruit SSD1306 @ ^2.5.13
+
+[env:Faketec_Repeater]
+extends = Faketec
+build_src_filter = ${Faketec.build_src_filter} +<../examples/simple_repeater> +<helpers/ui/*.cpp>
+build_flags =
+  ${Faketec.build_flags}
+  -D ADVERT_NAME="\"Faketec Repeater\""
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD="\"password\""
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+lib_deps =
+  ${Faketec.lib_deps}
+  adafruit/RTClib @ ^2.1.3
+
+[env:Faketec_room_server]
+extends = Faketec
+build_src_filter = ${Faketec.build_src_filter} +<../examples/simple_room_server> +<helpers/ui/*.cpp>
+build_flags =
+  ${Faketec.build_flags}
+  -D ADVERT_NAME="\"Test Room\""
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD="\"password\""
+  -D ROOM_PASSWORD="\"hello\""
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+lib_deps =
+  ${Faketec.lib_deps}
+  adafruit/RTClib @ ^2.1.3
+
+[env:Faketec_terminal_chat]
+extends = Faketec
+build_flags =
+  ${Faketec.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Faketec.build_src_filter} +<../examples/simple_secure_chat/main.cpp>
+lib_deps =
+  ${Faketec.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+  adafruit/RTClib @ ^2.1.3
+
+[env:Faketec_companion_radio_usb]
+extends = Faketec
+build_flags =
+  ${Faketec.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
+; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
+build_src_filter = ${Faketec.build_src_filter} +<../examples/companion_radio>  +<../examples/companion_radio> +<helpers/ui/*.cpp>
+lib_deps =
+  ${Faketec.lib_deps}
+  adafruit/RTClib @ ^2.1.3
+  densaugeo/base64 @ ~1.4.0
+
+[env:Faketec_companion_radio_ble]
+extends = Faketec
+build_flags =
+  ${Faketec.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D BLE_PIN_CODE=123456
+  -D BLE_DEBUG_LOGGING=1
+  -D ENABLE_PRIVATE_KEY_EXPORT=1
+  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Faketec.build_src_filter} +<helpers/nrf52/SerialBLEInterface.cpp> +<../examples/companion_radio> +<helpers/ui/*.cpp>
+lib_deps =
+  ${Faketec.lib_deps}
+  adafruit/RTClib @ ^2.1.3
+  densaugeo/base64 @ ~1.4.0
+
+[ProMicroLLCC68]
+extends = nrf52840_base
+board = promicro_nrf52840
+build_flags = ${nrf52840_base.build_flags}
+  -I variants/promicro
+  -D PROMICROLLCC68
+  -D RADIO_CLASS=CustomLLCC68
+  -D WRAPPER_CLASS=CustomLLCC68Wrapper
+  -D LORA_TX_POWER=22
+  -D SX126X_CURRENT_LIMIT=130
+  -D SX126X_RX_BOOSTED_GAIN=1
+build_src_filter = ${nrf52840_base.build_src_filter}
+  +<helpers/nrf52/PromicroBoard.cpp>
+  +<../variants/promicro>
+
+[env:ProMicroLLCC68_Repeater]
+extends = ProMicroLLCC68
+build_src_filter = ${ProMicroLLCC68.build_src_filter} +<../examples/simple_repeater/main.cpp>
+build_flags =
+  ${ProMicroLLCC68.build_flags}
+  -D ADVERT_NAME="\"ProMicroLLCC68 Repeater\""
+  -D ADMIN_PASSWORD="\"password\""
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+lib_deps =
+  ${ProMicroLLCC68.lib_deps}
+  adafruit/RTClib @ ^2.1.3
+
+[env:ProMicroLLCC68_room_server]
+extends = ProMicroLLCC68
+build_src_filter = ${ProMicroLLCC68.build_src_filter} +<../examples/simple_room_server/main.cpp>
+build_flags =
+  ${ProMicroLLCC68.build_flags}
+  -D ADVERT_NAME="\"ProMicroLLCC68 Room\""
+  -D ADMIN_PASSWORD="\"password\""
+  -D ROOM_PASSWORD="\"hello\""
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+lib_deps =
+  ${ProMicroLLCC68.lib_deps}
+  adafruit/RTClib @ ^2.1.3
+
+[env:ProMicroLLCC68_terminal_chat]
+extends = ProMicroLLCC68
+build_flags =
+  ${ProMicroLLCC68.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${ProMicroLLCC68.build_src_filter} +<../examples/simple_secure_chat/main.cpp>
+lib_deps =
+  ${ProMicroLLCC68.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+  adafruit/RTClib @ ^2.1.3
+
+[env:ProMicroLLCC68_companion_radio_usb]
+extends = ProMicroLLCC68
+build_flags =
+  ${ProMicroLLCC68.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
+; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
+build_src_filter = ${ProMicroLLCC68.build_src_filter} +<../examples/companion_radio/main.cpp>
+lib_deps =
+  ${ProMicroLLCC68.lib_deps}
+  adafruit/RTClib @ ^2.1.3
+  densaugeo/base64 @ ~1.4.0
+
+[env:ProMicroLLCC68_companion_radio_ble]
+extends = ProMicroLLCC68
+build_flags =
+  ${ProMicroLLCC68.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D BLE_PIN_CODE=123456
+  -D BLE_DEBUG_LOGGING=1
+  -D ENABLE_PRIVATE_KEY_EXPORT=1
+  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${ProMicroLLCC68.build_src_filter} +<helpers/nrf52/SerialBLEInterface.cpp> +<../examples/companion_radio/main.cpp>
+lib_deps =
+  ${ProMicroLLCC68.lib_deps}
+  adafruit/RTClib @ ^2.1.3
+  densaugeo/base64 @ ~1.4.0

variants/promicro/target.cpp

@@ -0,0 +1,75 @@
+#include <Arduino.h>
+#include "target.h"
+#include <helpers/ArduinoHelpers.h>
+
+PromicroBoard board;
+
+RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI);
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+VolatileRTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  rtc_clock.begin(Wire);
+  
+#ifdef SX126X_DIO3_TCXO_VOLTAGE
+  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
+#else
+  float tcxo = 1.6f;
+#endif
+
+  SPI.setPins(P_LORA_MISO, P_LORA_SCLK, P_LORA_MOSI);
+  SPI.begin();
+  radio.setRfSwitchPins(SX126X_RXEN, SX126X_TXEN);
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
+  if (status == RADIOLIB_ERR_SPI_CMD_FAILED || status == RADIOLIB_ERR_SPI_CMD_INVALID) {
+    #define SX126X_DIO3_TCXO_VOLTAGE (0.0f);
+    tcxo = SX126X_DIO3_TCXO_VOLTAGE;
+    status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
+  }
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+  
+  radio.setCRC(1);
+  
+#ifdef SX126X_CURRENT_LIMIT
+  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
+#endif
+#ifdef SX126X_DIO2_AS_RF_SWITCH
+  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
+#endif
+#ifdef SX126X_RX_BOOSTED_GAIN
+  radio.setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
+#endif
+
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/promicro/target.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/nrf52/PromicroBoard.h>
+#include <helpers/CustomSX1262Wrapper.h>
+#include <helpers/CustomLLCC68Wrapper.h>
+#include <helpers/AutoDiscoverRTCClock.h>
+
+extern PromicroBoard board;
+extern WRAPPER_CLASS radio_driver;
+extern AutoDiscoverRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/promicro/variant.cpp

@@ -0,0 +1,15 @@
+#include "variant.h"
+#include "wiring_constants.h"
+#include "wiring_digital.h"
+
+const uint32_t g_ADigitalPinMap[] = {
+  8, 6, 17, 20, 22, 24, 32, 11, 36, 38,
+  9, 10, 43, 45, 47, 2, 29, 31,
+  33, 34, 37,
+  13, 15
+};
+
+void initVariant()
+{
+}
+

variants/promicro/variant.h

@@ -0,0 +1,82 @@
+/*
+ * variant.h
+ * Copyright (C) 2023 Seeed K.K.
+ * MIT License
+ */
+
+ #pragma once
+
+ #include "WVariant.h"
+ 
+ ////////////////////////////////////////////////////////////////////////////////
+ // Low frequency clock source 
+
+#define VARIANT_MCK       (64000000ul)
+
+//#define USE_LFXO      // 32.768 kHz crystal oscillator
+#define USE_LFRC    // 32.768 kHz RC oscillator
+
+////////////////////////////////////////////////////////////////////////////////
+// Power
+
+#define PIN_EXT_VCC          (21)
+#define EXT_VCC              (PIN_EXT_VCC)
+
+#define BATTERY_PIN          (17)
+#define ADC_RESOLUTION       12
+
+////////////////////////////////////////////////////////////////////////////////
+// Number of pins
+
+#define PINS_COUNT           (23)
+#define NUM_DIGITAL_PINS     (23)
+#define NUM_ANALOG_INPUTS    (3)
+#define NUM_ANALOG_OUTPUTS   (0)
+
+////////////////////////////////////////////////////////////////////////////////
+// UART pin definition
+
+#define PIN_SERIAL1_TX       (1)
+#define PIN_SERIAL1_RX       (0)
+
+////////////////////////////////////////////////////////////////////////////////
+// I2C pin definition
+
+#define WIRE_INTERFACES_COUNT 2
+
+#define PIN_WIRE_SDA         (6)
+#define PIN_WIRE_SCL         (7)
+#define PIN_WIRE1_SDA        (13)
+#define PIN_WIRE1_SCL        (14)
+
+////////////////////////////////////////////////////////////////////////////////
+// SPI pin definition
+
+#define SPI_INTERFACES_COUNT 2
+
+#define PIN_SPI_SCK          (2)
+#define PIN_SPI_MISO         (3)
+#define PIN_SPI_MOSI         (4)
+
+#define PIN_SPI_NSS          (5)
+
+#define PIN_SPI1_SCK         (18)
+#define PIN_SPI1_MISO        (19)
+#define PIN_SPI1_MOSI        (20)
+
+////////////////////////////////////////////////////////////////////////////////
+// Builtin LEDs
+
+#define PIN_LED              (22)
+#define LED_PIN              PIN_LED
+#define LED_BLUE             PIN_LED
+#define LED_BUILTIN          PIN_LED
+#define LED_STATE_ON         1
+
+////////////////////////////////////////////////////////////////////////////////
+// Builtin buttons
+
+#define PIN_BUTTON1          (6)
+#define BUTTON_PIN           PIN_BUTTON1
+
+

variants/rak4631/platformio.ini

@@ -0,0 +1,104 @@
+[rak4631]
+extends = nrf52840_base
+platform = https://github.com/maxgerhardt/platform-nordicnrf52.git#rak
+board = wiscore_rak4631
+board_check = true
+build_flags = ${nrf52840_base.build_flags}
+  -I variants/rak4631
+  -D RAK_4631
+  -D PIN_USER_BTN=9
+  -D RADIO_CLASS=CustomSX1262
+  -D WRAPPER_CLASS=CustomSX1262Wrapper
+  -D LORA_TX_POWER=22
+  -D SX126X_CURRENT_LIMIT=130
+  -D SX126X_RX_BOOSTED_GAIN=1
+build_src_filter = ${nrf52840_base.build_src_filter}
+  +<helpers/nrf52/*.cpp>
+  +<../variants/rak4631>
+lib_deps =
+  ${nrf52840_base.lib_deps}
+  adafruit/Adafruit SSD1306 @ ^2.5.13
+
+[env:RAK_4631_Repeater]
+extends = rak4631
+build_flags =
+  ${rak4631.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D ADVERT_NAME='"RAK4631 Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${rak4631.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/simple_repeater>
+
+[env:RAK_4631_room_server]
+extends = rak4631
+build_flags =
+  ${rak4631.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D ADVERT_NAME='"Test Room"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D ROOM_PASSWORD='"hello"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${rak4631.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/simple_room_server>
+
+[env:RAK_4631_companion_radio_usb]
+extends = rak4631
+build_flags =
+  ${rak4631.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+; NOTE: DO NOT ENABLE -->  -D MESH_PACKET_LOGGING=1
+; NOTE: DO NOT ENABLE -->  -D MESH_DEBUG=1
+build_src_filter = ${rak4631.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${rak4631.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:RAK_4631_companion_radio_ble]
+extends = rak4631
+build_flags =
+  ${rak4631.build_flags}
+  -D DISPLAY_CLASS=SSD1306Display
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D BLE_PIN_CODE=123456
+  -D BLE_DEBUG_LOGGING=1
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${rak4631.build_src_filter}
+  +<helpers/ui/*.cpp>
+  +<helpers/nrf52/*.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${rak4631.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:RAK_4631_terminal_chat]
+extends = rak4631
+build_flags =
+  ${rak4631.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=1
+  -D MESH_PACKET_LOGGING=1
+  -D MESH_DEBUG=1
+build_src_filter = ${rak4631.build_src_filter}
+  +<../examples/simple_secure_chat/main.cpp>
+lib_deps =
+  ${rak4631.lib_deps}
+  densaugeo/base64 @ ~1.4.0

variants/rak4631/target.cpp

@@ -0,0 +1,69 @@
+#include <Arduino.h>
+#include "target.h"
+#include <helpers/ArduinoHelpers.h>
+
+RAK4631Board board;
+
+RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI);
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+VolatileRTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  rtc_clock.begin(Wire);
+  
+#ifdef SX126X_DIO3_TCXO_VOLTAGE
+  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
+#else
+  float tcxo = 1.6f;
+#endif
+
+  SPI.setPins(P_LORA_MISO, P_LORA_SCLK, P_LORA_MOSI);
+  SPI.begin();
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+  
+  radio.setCRC(1);
+  
+#ifdef SX126X_CURRENT_LIMIT
+  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
+#endif
+#ifdef SX126X_DIO2_AS_RF_SWITCH
+  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
+#endif
+#ifdef SX126X_RX_BOOSTED_GAIN
+  radio.setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
+#endif
+
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/rak4631/target.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/nrf52/RAK4631Board.h>
+#include <helpers/CustomSX1262Wrapper.h>
+#include <helpers/AutoDiscoverRTCClock.h>
+
+extern RAK4631Board board;
+extern WRAPPER_CLASS radio_driver;
+extern AutoDiscoverRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/station_g2/platformio.ini

@@ -0,0 +1,56 @@
+[Station_G2]
+extends = esp32_base
+board = station-g2
+build_flags =
+  ${esp32_base.build_flags}
+  -I variants/station_g2
+  -D STATION_G2
+  -D RADIO_CLASS=CustomSX1262
+  -D WRAPPER_CLASS=CustomSX1262Wrapper
+  -D LORA_TX_POWER=7
+;  -D P_LORA_TX_LED=35
+;  -D PIN_BOARD_SDA=5
+;  -D PIN_BOARD_SCL=6
+  -D PIN_USER_BTN=0
+  -D SX126X_DIO2_AS_RF_SWITCH=true
+  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
+  -D SX126X_CURRENT_LIMIT=130.0f  ; for best TX power!
+;  -D SX126X_RX_BOOSTED_GAIN=1 - DO NOT ENABLE THIS!
+;  https://wiki.uniteng.com/en/meshtastic/station-g2#impact-of-lora-node-dense-areashigh-noise-environments-on-rf-performance
+build_src_filter = ${esp32_base.build_src_filter}
+  +<../variants/station_g2>
+lib_deps =
+  ${esp32_base.lib_deps}
+
+[env:Station_G2_repeater]
+extends = Station_G2
+build_flags =
+  ${Station_G2.build_flags}
+  -D ADVERT_NAME='"Station G2 Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Station_G2.build_src_filter}
+  +<../examples/simple_repeater>
+lib_deps =
+  ${Station_G2.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:Station_G2_room_server]
+extends = Station_G2
+build_src_filter = ${Station_G2.build_src_filter}
+  +<../examples/simple_room_server>
+build_flags =
+  ${Station_G2.build_flags}
+  -D ADVERT_NAME='"Station G2 Room"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D ROOM_PASSWORD='"hello"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+lib_deps =
+  ${Station_G2.lib_deps}
+  ${esp32_ota.lib_deps}

variants/station_g2/target.cpp

@@ -0,0 +1,75 @@
+#include <Arduino.h>
+#include "target.h"
+
+StationG2Board board;
+
+#if defined(P_LORA_SCLK)
+  static SPIClass spi;
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, spi);
+#else
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY);
+#endif
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+ESP32RTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  fallback_clock.begin();
+  rtc_clock.begin(Wire);
+  
+#ifdef SX126X_DIO3_TCXO_VOLTAGE
+  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
+#else
+  float tcxo = 1.6f;
+#endif
+
+#if defined(P_LORA_SCLK)
+  spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI);
+#endif
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+  
+  radio.setCRC(1);
+  
+#ifdef SX126X_CURRENT_LIMIT
+  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
+#endif
+#ifdef SX126X_DIO2_AS_RF_SWITCH
+  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
+#endif
+#ifdef SX126X_RX_BOOSTED_GAIN
+  radio.setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
+#endif
+
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/station_g2/target.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/StationG2Board.h>
+#include <helpers/CustomSX1262Wrapper.h>
+#include <helpers/AutoDiscoverRTCClock.h>
+
+extern StationG2Board board;
+extern WRAPPER_CLASS radio_driver;
+extern AutoDiscoverRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/t1000-e/platformio.ini

@@ -0,0 +1,53 @@
+; ----------------- NRF52 T1000e---------------------
+[nrf52840_t1000e]
+extends = nrf52_base
+platform_packages = framework-arduinoadafruitnrf52
+build_flags = ${nrf52_base.build_flags}
+  -I src/helpers/nrf52
+  -I lib/nrf52/s140_nrf52_7.3.0_API/include
+  -I lib/nrf52/s140_nrf52_7.3.0_API/include/nrf52
+lib_ignore =
+  BluetoothOTA
+  lvgl
+  lib5b4
+lib_deps =
+  ${nrf52_base.lib_deps}
+  rweather/Crypto @ ^0.4.0
+
+[t1000-e]
+extends = nrf52840_t1000e
+board = tracker-t1000-e
+board_build.ldscript = boards/nrf52840_s140_v7.ld
+build_flags = ${nrf52840_t1000e.build_flags}
+  -I variants/t1000-e
+  -D T1000_E
+  -D PIN_USER_BTN=6
+  -D USER_BTN_PRESSED=HIGH
+  -D PIN_STATUS_LED=24
+  -D RADIO_CLASS=CustomLR1110
+  -D WRAPPER_CLASS=CustomLR1110Wrapper
+  -D LORA_TX_POWER=22
+build_src_filter = ${nrf52840_t1000e.build_src_filter}
+  +<helpers/*.cpp>
+  +<helpers/nrf52/T1000eBoard.cpp>
+  +<../variants/t1000-e>
+debug_tool = jlink
+upload_protocol = nrfutil
+
+[env:t1000e_companion_radio_ble]
+extends = t1000-e
+build_flags = ${t1000-e.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D BLE_PIN_CODE=123456
+  -D BLE_DEBUG_LOGGING=1
+  -D MESH_PACKET_LOGGING=1
+  -D MESH_DEBUG=1
+  -D RX_BOOSTED_GAIN=true
+  -D RF_SWITCH_TABLE
+  -D HAS_UI
+build_src_filter = ${t1000-e.build_src_filter}
+  +<helpers/nrf52/SerialBLEInterface.cpp>
+  +<../examples/companion_radio/*.cpp>
+lib_deps = ${t1000-e.lib_deps}
+  densaugeo/base64 @ ~1.4.0

variants/t1000-e/target.cpp

@@ -0,0 +1,86 @@
+#include <Arduino.h>
+#include "target.h"
+
+T1000eBoard board;
+
+RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI);
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+VolatileRTCClock rtc_clock;
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+#ifdef RF_SWITCH_TABLE
+static const uint32_t rfswitch_dios[Module::RFSWITCH_MAX_PINS] = {
+  RADIOLIB_LR11X0_DIO5,
+  RADIOLIB_LR11X0_DIO6,
+  RADIOLIB_LR11X0_DIO7,
+  RADIOLIB_LR11X0_DIO8, 
+  RADIOLIB_NC
+};
+
+static const Module::RfSwitchMode_t rfswitch_table[] = {
+  // mode                 DIO5  DIO6  DIO7  DIO8
+  { LR11x0::MODE_STBY,   {LOW,  LOW,  LOW,  LOW  }},  
+  { LR11x0::MODE_RX,     {HIGH, LOW,  LOW,  HIGH }},
+  { LR11x0::MODE_TX,     {HIGH, HIGH, LOW,  HIGH }},
+  { LR11x0::MODE_TX_HP,  {LOW,  HIGH, LOW,  HIGH }},
+  { LR11x0::MODE_TX_HF,  {LOW,  LOW,  LOW,  LOW  }}, 
+  { LR11x0::MODE_GNSS,   {LOW,  LOW,  HIGH, LOW  }},
+  { LR11x0::MODE_WIFI,   {LOW,  LOW,  LOW,  LOW  }},  
+  END_OF_MODE_TABLE,
+};
+#endif
+
+bool radio_init() {
+  //rtc_clock.begin(Wire);
+  
+#ifdef LR11X0_DIO3_TCXO_VOLTAGE
+  float tcxo = LR11X0_DIO3_TCXO_VOLTAGE;
+#else
+  float tcxo = 1.6f;
+#endif
+
+  SPI.setPins(P_LORA_MISO, P_LORA_SCLK, P_LORA_MOSI);
+  SPI.begin();
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_LR11X0_LORA_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+  
+  radio.setCRC(1);
+
+#ifdef RF_SWITCH_TABLE
+  radio.setRfSwitchTable(rfswitch_dios, rfswitch_table);
+#endif
+#ifdef RX_BOOSTED_GAIN
+  radio.setRxBoostedGainMode(RX_BOOSTED_GAIN);
+#endif
+
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/t1000-e/target.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/nrf52/T1000eBoard.h>
+#include <helpers/CustomLR1110Wrapper.h>
+#include <helpers/ArduinoHelpers.h>
+
+extern T1000eBoard board;
+extern WRAPPER_CLASS radio_driver;
+extern VolatileRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/t114/platformio.ini

@@ -0,0 +1,76 @@
+[nrf52840_t114]
+extends = nrf52_base
+platform_packages = framework-arduinoadafruitnrf52
+build_flags = ${nrf52_base.build_flags}
+  -I src/helpers/nrf52
+  -I lib/nrf52/s140_nrf52_6.1.1_API/include
+  -I lib/nrf52/s140_nrf52_6.1.1_API/include/nrf52
+lib_deps =
+  ${nrf52_base.lib_deps}
+  rweather/Crypto @ ^0.4.0
+
+[Heltec_t114]
+extends = nrf52840_t114
+board = heltec_t114
+board_build.ldscript = boards/nrf52840_s140_v6.ld
+build_flags = ${nrf52840_t114.build_flags}
+  -I variants/t114
+  -DHELTEC_T114
+  -D P_LORA_TX_LED=35
+  -D RADIO_CLASS=CustomSX1262
+  -D WRAPPER_CLASS=CustomSX1262Wrapper
+  -D LORA_TX_POWER=22
+  -D SX126X_CURRENT_LIMIT=130
+  -D SX126X_RX_BOOSTED_GAIN=1
+build_src_filter = ${nrf52840_t114.build_src_filter}
+  +<helpers/*.cpp>
+  +<helpers/nrf52/T114Board.cpp>
+  +<../variants/t114>
+debug_tool = jlink
+upload_protocol = nrfutil
+
+[env:Heltec_t114_repeater]
+extends = Heltec_t114
+build_src_filter = ${Heltec_t114.build_src_filter}
+  +<../examples/simple_repeater/main.cpp>
+build_flags =
+  ${Heltec_t114.build_flags}
+  -D ADVERT_NAME='"Heltec_T114 Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+
+[env:Heltec_t114_room_server]
+extends = Heltec_t114
+build_src_filter = ${Heltec_t114.build_src_filter}
+  +<../examples/simple_room_server>
+build_flags =
+  ${Heltec_t114.build_flags}
+  -D ADVERT_NAME='"Heltec_T114 Room"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D ROOM_PASSWORD='"hello"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+
+[env:Heltec_t114_companion_radio_ble]
+extends = Heltec_t114
+build_flags =
+  ${Heltec_t114.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D BLE_PIN_CODE=123456
+  -D BLE_DEBUG_LOGGING=1
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Heltec_t114.build_src_filter}
+  +<helpers/nrf52/*.cpp>
+  +<../examples/companion_radio/main.cpp>
+lib_deps =
+  ${Heltec_t114.lib_deps}
+  densaugeo/base64 @ ~1.4.0

variants/t114/target.cpp

@@ -0,0 +1,69 @@
+#include <Arduino.h>
+#include "target.h"
+#include <helpers/ArduinoHelpers.h>
+
+T114Board board;
+
+RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI);
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+VolatileRTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  rtc_clock.begin(Wire);
+  
+#ifdef SX126X_DIO3_TCXO_VOLTAGE
+  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
+#else
+  float tcxo = 1.6f;
+#endif
+
+  SPI.setPins(P_LORA_MISO, P_LORA_SCLK, P_LORA_MOSI);
+  SPI.begin();
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+  
+  radio.setCRC(1);
+  
+#ifdef SX126X_CURRENT_LIMIT
+  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
+#endif
+#ifdef SX126X_DIO2_AS_RF_SWITCH
+  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
+#endif
+#ifdef SX126X_RX_BOOSTED_GAIN
+  radio.setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
+#endif
+
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/t114/target.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/nrf52/T114Board.h>
+#include <helpers/CustomSX1262Wrapper.h>
+#include <helpers/AutoDiscoverRTCClock.h>
+
+extern T114Board board;
+extern WRAPPER_CLASS radio_driver;
+extern AutoDiscoverRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/techo/platformio.ini

@@ -0,0 +1,72 @@
+[nrf52840_techo]
+extends = nrf52_base
+platform_packages = framework-arduinoadafruitnrf52
+build_flags = ${nrf52_base.build_flags}
+  -I src/helpers/nrf52
+  -I lib/nrf52/s140_nrf52_6.1.1_API/include
+  -I lib/nrf52/s140_nrf52_6.1.1_API/include/nrf52
+lib_deps =
+  ${nrf52_base.lib_deps}
+  rweather/Crypto @ ^0.4.0
+
+[LilyGo_Techo]
+extends = nrf52840_techo
+board = t-echo
+board_build.ldscript = boards/nrf52840_s140_v6.ld
+build_flags = ${nrf52840_techo.build_flags}
+  -I variants/techo
+  -DLILYGO_TECHO
+  -D RADIO_CLASS=CustomSX1262
+  -D WRAPPER_CLASS=CustomSX1262Wrapper
+  -D LORA_TX_POWER=22
+  -D SX126X_CURRENT_LIMIT=130
+  -D SX126X_RX_BOOSTED_GAIN=1
+build_src_filter = ${nrf52840_techo.build_src_filter}
+  +<helpers/*.cpp>
+  +<helpers/nrf52/TechoBoard.cpp>
+  +<../variants/techo>
+debug_tool = jlink
+upload_protocol = nrfutil
+
+[env:LilyGo_T-Echo_repeater]
+extends = LilyGo_Techo
+build_src_filter = ${LilyGo_Techo.build_src_filter} +<../examples/simple_repeater/main.cpp>
+build_flags =
+  ${LilyGo_Techo.build_flags}
+  -D ADVERT_NAME='"T-Echo Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+
+[env:LilyGo_T-Echo_room_server]
+extends = LilyGo_Techo
+build_src_filter = ${LilyGo_Techo.build_src_filter} +<../examples/simple_room_server/main.cpp>
+build_flags =
+  ${LilyGo_Techo.build_flags}
+  -D ADVERT_NAME='"T-Echo Room"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+
+[env:LilyGo_T-Echo_companion_radio_ble]
+extends = LilyGo_Techo
+build_flags =
+  ${LilyGo_Techo.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D BLE_PIN_CODE=123456
+  -D BLE_DEBUG_LOGGING=1
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${LilyGo_Techo.build_src_filter}
+  +<helpers/nrf52/*.cpp>
+  +<../examples/companion_radio/main.cpp>
+lib_deps =
+  ${LilyGo_Techo.lib_deps}
+  densaugeo/base64 @ ~1.4.0

variants/techo/target.cpp

@@ -0,0 +1,69 @@
+#include <Arduino.h>
+#include "target.h"
+#include <helpers/ArduinoHelpers.h>
+
+TechoBoard board;
+
+RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, SPI);
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+VolatileRTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  rtc_clock.begin(Wire);
+  
+#ifdef SX126X_DIO3_TCXO_VOLTAGE
+  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
+#else
+  float tcxo = 1.6f;
+#endif
+
+  SPI.setPins(P_LORA_MISO, P_LORA_SCLK, P_LORA_MOSI);
+  SPI.begin();
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+  
+  radio.setCRC(1);
+  
+#ifdef SX126X_CURRENT_LIMIT
+  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
+#endif
+#ifdef SX126X_DIO2_AS_RF_SWITCH
+  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
+#endif
+#ifdef SX126X_RX_BOOSTED_GAIN
+  radio.setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
+#endif
+
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/techo/target.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/nrf52/TechoBoard.h>
+#include <helpers/CustomSX1262Wrapper.h>
+#include <helpers/AutoDiscoverRTCClock.h>
+
+extern TechoBoard board;
+extern WRAPPER_CLASS radio_driver;
+extern AutoDiscoverRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/techo/variant.h

@@ -14,12 +14,12 @@
 #define USE_LFXO    // 32.768 kHz crystal oscillator
 #define VARIANT_MCK (64000000ul)
 
-#define WIRE_INTERFACES_COUNT 	(1)
-
+#define WIRE_INTERFACES_COUNT   (1)
+#define PIN_TXCO                (21)
 ////////////////////////////////////////////////////////////////////////////////
 // Power
 
-#define PIN_PWR_EN              (6)
+#define PIN_PWR_EN              (12)
 
 #define BATTERY_PIN             (4)
 #define ADC_MULTIPLIER          (4.90F)
@@ -62,11 +62,11 @@
 ////////////////////////////////////////////////////////////////////////////////
 // Builtin LEDs
 
-#define LED_RED                 (13)
+#define LED_RED                 (34)
+#define LED_GREEN               (33)
 #define LED_BLUE                (14)
-#define LED_GREEN               (15)
 
-#define LED_BUILTIN             (15)
+#define LED_BUILTIN             LED_GREEN
 #define PIN_LED                 LED_BUILTIN
 #define LED_PIN                 LED_BUILTIN
 #define LED_STATE_ON            LOW
@@ -80,7 +80,7 @@
 #define PIN_BUTTON1             (42)
 #define BUTTON_PIN              PIN_BUTTON1
 
-#define PIN_BUTTON2             (18)
+#define PIN_BUTTON2             (11)
 #define BUTTON_PIN2             PIN_BUTTON2
 
 #define EXTERNAL_FLASH_DEVICES MX25R1635F

variants/xiao_c3/platformio.ini

@@ -0,0 +1,59 @@
+[Xiao_esp32_C3]
+extends = esp32_base
+board = seeed_xiao_esp32c3
+build_flags =
+  ${esp32_base.build_flags}
+  -I variants/xiao_c3
+  -D LORA_TX_BOOST_PIN=D3
+  -D P_LORA_TX_LED=D5
+  -D PIN_VBAT_READ=D0
+  -D P_LORA_DIO_1=D2
+  -D P_LORA_NSS=D4
+  -D P_LORA_RESET=RADIOLIB_NC
+  -D P_LORA_BUSY=D1
+  -D PIN_BOARD_SDA=D6
+  -D PIN_BOARD_SCL=D7
+  -D SX126X_DIO2_AS_RF_SWITCH=true
+  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
+  -D SX126X_CURRENT_LIMIT=130.0f  ; for best TX power!
+build_src_filter = ${esp32_base.build_src_filter}
+  +<../variants/xiao_c3>
+
+[env:Xiao_C3_Repeater_sx1262]
+extends = Xiao_esp32_C3
+build_src_filter = ${Xiao_esp32_C3.build_src_filter}
+  +<../examples/simple_repeater/main.cpp>
+build_flags =
+  ${Xiao_esp32_C3.build_flags}
+  -D RADIO_CLASS=CustomSX1262
+  -D WRAPPER_CLASS=CustomSX1262Wrapper
+  -D SX126X_RX_BOOSTED_GAIN=1
+  -D LORA_TX_POWER=22
+  -D ADVERT_NAME='"Xiao Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+lib_deps =
+  ${Xiao_esp32_C3.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:Xiao_C3_Repeater_sx1268]
+extends = Xiao_esp32_C3
+build_src_filter = ${Xiao_esp32_C3.build_src_filter}
+  +<../examples/simple_repeater/main.cpp>
+build_flags =
+  ${Xiao_esp32_C3.build_flags}
+  -D RADIO_CLASS=CustomSX1268
+  -D WRAPPER_CLASS=CustomSX1268Wrapper
+  -D LORA_TX_POWER=22
+  -D ADVERT_NAME='"Xiao Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+ ; -D MESH_PACKET_LOGGING=1
+ ; -D MESH_DEBUG=1
+lib_deps =
+  ${Xiao_esp32_C3.lib_deps}
+  ${esp32_ota.lib_deps}

variants/xiao_c3/target.cpp

@@ -0,0 +1,75 @@
+#include <Arduino.h>
+#include "target.h"
+
+XiaoC3Board board;
+
+#if defined(P_LORA_SCLK)
+  static SPIClass spi;
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, spi);
+#else
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY);
+#endif
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+ESP32RTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  fallback_clock.begin();
+  rtc_clock.begin(Wire);
+  
+#ifdef SX126X_DIO3_TCXO_VOLTAGE
+  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
+#else
+  float tcxo = 1.6f;
+#endif
+
+#if defined(P_LORA_SCLK)
+  spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI);
+#endif
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+  
+  radio.setCRC(1);
+  
+#ifdef SX126X_CURRENT_LIMIT
+  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
+#endif
+#ifdef SX126X_DIO2_AS_RF_SWITCH
+  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
+#endif
+#ifdef SX126X_RX_BOOSTED_GAIN
+  radio.setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
+#endif
+
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}

variants/xiao_c3/target.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/XiaoC3Board.h>
+#include <helpers/CustomSX1262Wrapper.h>
+#include <helpers/CustomSX1268Wrapper.h>
+#include <helpers/AutoDiscoverRTCClock.h>
+
+extern XiaoC3Board board;
+extern WRAPPER_CLASS radio_driver;
+extern AutoDiscoverRTCClock rtc_clock;
+
+bool radio_init();
+uint32_t radio_get_rng_seed();
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);
+void radio_set_tx_power(uint8_t dbm);
+mesh::LocalIdentity radio_new_identity();

variants/xiao_s3_wio/platformio.ini

@@ -0,0 +1,107 @@
+[Xiao_S3_WIO]
+extends = esp32_base
+board = seeed_xiao_esp32s3
+board_check = true
+board_build.mcu = esp32s3
+build_flags = ${esp32_base.build_flags}
+  -I variants/xiao_s3_wio
+  -D SEEED_XIAO_S3
+  -D P_LORA_DIO_1=39
+  -D P_LORA_NSS=41
+  -D P_LORA_RESET=42   ; RADIOLIB_NC
+  -D P_LORA_BUSY=40   ;  DIO2 = 38
+  -D P_LORA_SCLK=7
+  -D P_LORA_MISO=8
+  -D P_LORA_MOSI=9
+  -D SX126X_DIO2_AS_RF_SWITCH=true
+  -D SX126X_DIO3_TCXO_VOLTAGE=1.8
+  -D SX126X_CURRENT_LIMIT=130
+  -D RADIO_CLASS=CustomSX1262
+  -D WRAPPER_CLASS=CustomSX1262Wrapper
+  -D LORA_TX_POWER=22
+  -D SX126X_RX_BOOSTED_GAIN=1
+build_src_filter = ${esp32_base.build_src_filter}
+  +<../variants/xiao_s3_wio>
+
+[env:Xiao_S3_WIO_Repeater]
+extends = Xiao_S3_WIO
+build_src_filter = ${Xiao_S3_WIO.build_src_filter}
+  +<../examples/simple_repeater/main.cpp>
+build_flags =
+  ${Xiao_S3_WIO.build_flags}
+  -D ADVERT_NAME='"XiaoS3 Repeater"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+lib_deps =
+  ${Xiao_S3_WIO.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:Xiao_S3_WIO_room_server]
+extends = Xiao_S3_WIO
+build_src_filter = ${Xiao_S3_WIO.build_src_filter}
+  +<../examples/simple_room_server>
+build_flags =
+  ${Xiao_S3_WIO.build_flags}
+  -D ADVERT_NAME='"XiaoS3 Room"'
+  -D ADVERT_LAT=0.0
+  -D ADVERT_LON=0.0
+  -D ADMIN_PASSWORD='"password"'
+  -D ROOM_PASSWORD='"hello"'
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+lib_deps =
+  ${Xiao_S3_WIO.lib_deps}
+  ${esp32_ota.lib_deps}
+
+[env:Xiao_S3_WIO_terminal_chat]
+extends = Xiao_S3_WIO
+build_flags =
+  ${Xiao_S3_WIO.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Xiao_S3_WIO.build_src_filter}
+  +<../examples/simple_secure_chat/main.cpp>
+lib_deps =
+  ${Xiao_S3_WIO.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Xiao_S3_WIO_companion_radio_ble]
+extends = Xiao_S3_WIO
+build_flags =
+  ${Xiao_S3_WIO.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D BLE_PIN_CODE=123456
+;  -D BLE_DEBUG_LOGGING=1
+;  -D ENABLE_PRIVATE_KEY_IMPORT=1
+;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Xiao_S3_WIO.build_src_filter}
+  +<helpers/esp32/*.cpp>
+  +<../examples/companion_radio/main.cpp>
+lib_deps =
+  ${Xiao_S3_WIO.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:Xiao_S3_WIO_companion_radio_serial]
+extends = Xiao_S3_WIO
+build_flags =
+  ${Xiao_S3_WIO.build_flags}
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+  -D SERIAL_TX=D6
+  -D SERIAL_RX=D7
+;  -D MESH_PACKET_LOGGING=1
+;  -D MESH_DEBUG=1
+build_src_filter = ${Xiao_S3_WIO.build_src_filter}
+  +<helpers/esp32/*.cpp>
+  +<../examples/companion_radio/main.cpp>
+lib_deps =
+  ${Xiao_S3_WIO.lib_deps}
+  densaugeo/base64 @ ~1.4.0

variants/xiao_s3_wio/target.cpp

@@ -0,0 +1,75 @@
+#include <Arduino.h>
+#include "target.h"
+
+ESP32Board board;
+
+#if defined(P_LORA_SCLK)
+  static SPIClass spi;
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY, spi);
+#else
+  RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BUSY);
+#endif
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+ESP32RTCClock fallback_clock;
+AutoDiscoverRTCClock rtc_clock(fallback_clock);
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  fallback_clock.begin();
+  rtc_clock.begin(Wire);
+  
+#ifdef SX126X_DIO3_TCXO_VOLTAGE
+  float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
+#else
+  float tcxo = 1.6f;
+#endif
+
+#if defined(P_LORA_SCLK)
+  spi.begin(P_LORA_SCLK, P_LORA_MISO, P_LORA_MOSI);
+#endif
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, tcxo);
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+  
+  radio.setCRC(1);
+  
+#ifdef SX126X_CURRENT_LIMIT
+  radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
+#endif
+#ifdef SX126X_DIO2_AS_RF_SWITCH
+  radio.setDio2AsRfSwitch(SX126X_DIO2_AS_RF_SWITCH);
+#endif
+#ifdef SX126X_RX_BOOSTED_GAIN
+  radio.setRxBoostedGainMode(SX126X_RX_BOOSTED_GAIN);
+#endif
+
+  return true;  // success
+}
+
+uint32_t radio_get_rng_seed() {
+  return radio.random(0x7FFFFFFF);
+}
+
+void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr) {
+  radio.setFrequency(freq);
+  radio.setSpreadingFactor(sf);
+  radio.setBandwidth(bw);
+  radio.setCodingRate(cr);
+}
+
+void radio_set_tx_power(uint8_t dbm) {
+  radio.setOutputPower(dbm);
+}
+
+mesh::LocalIdentity radio_new_identity() {
+  RadioNoiseListener rng(radio);
+  return mesh::LocalIdentity(&rng);  // create new random identity
+}