Merge branch 'dev'

add basic alert system to companion UI

.clang-format

@@ -0,0 +1,84 @@
+# .clang-format
+Language:        Cpp
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignConsecutiveMacros:
+  Enabled: true
+  AcrossEmptyLines: true
+  AcrossComments: true
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: No
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     true
+  BeforeElse:      true
+  IndentBraces:    false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+ColumnLimit:     110
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+Cpp11BracedListStyle: false
+DerivePointerAlignment: false
+DisableFormat:   false
+IncludeBlocks:   Regroup
+IndentCaseLabels: false
+IndentPPDirectives: None
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 100000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Auto
+TabWidth:        2
+UseTab:          Never
+AlignEscapedNewlines: LeftWithLastLine

.gitignore

@@ -8,3 +8,4 @@ out/
 .direnv/
 .DS_Store
 .vscode/settings.json
+.vscode/extensions.json

README.md

@@ -95,6 +95,11 @@ MeshCore is open-source software released under the MIT License. You are free to
 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.
 
+Here are some general principals you should try to adhere to:
+* Keep it simple. Please, don't think like a high-level lang programmer. Think embedded, and keep code concise, without any unecessary layers.
+* No dynamic memory allocation, except during setup/begin functions.
+* Use the same brace and indenting style that's in the core source modules. (A .clang-format is prob going to be added soon, but please do NOT retroactively re-format existing code. This just creates unnecessary diffs that make finding problems harder)
+
 ## 📞 Get Support
 
 - Report bugs and request features on the [GitHub Issues](https://github.com/ripplebiz/MeshCore/issues) page.

docs/faq.md

@@ -65,7 +65,8 @@ author: https://github.com/LitBomb<!-- omit from toc -->
   - [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)
+  - [7.2 Q: How to update ESP32-based devices over the air?](#72-q-how-to-update-esp32-based-devices-over-the-air)
+  - [7.1 Q: How to update nRF (RAK, T114, Seed XIAO) repeater and room server firmware over the air using the new simpler DFU app?](#71-q-how-to-update-nrf-rak-t114-seed-xiao-repeater-and-room-server-firmware-over-the-air-using-the-new-simpler-dfu-app)
 
 ## 1. Introduction
 
@@ -534,74 +535,35 @@ You can get the epoch time on <https://www.epochconverter.com/> and use it to se
 
 ---
 ## 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.
+### 7.2 Q: How to update ESP32-based devices over the air?
 
-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)
+**A:** For ESP32-based devices (e.g. Heltec V3):
+1. On flasher.meshcore.co.uk, download the **non-merged** version of the firmware for your ESP32 device (e.g. `Heltec_v3_repeater-v1.6.2-4449fd3.bin`, no `"merged"` in the file name)
+2. From the MeshCore app, login remotely to the repeater you want to update with admin priviledge
+4. Go to the Command Line tab, type `start ota` and hit enter.
+5. you should see `OK` to confirm the repeater device is now in OTA mode
+6. The command `start ota` on an ESP32-based device starts a wifi hotspot named `MeshCore OTA`
+7. From your phone or computer connect to the 'MeshCore OTA' hotspot 
+8. From a browser, go to http://192.168.4.1/update and upload the non-merged bin from the flasher
 
 
+### 7.1 Q: How to update nRF (RAK, T114, Seed XIAO) repeater and room server firmware over the air using the new simpler DFU app?
 
-**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`
+**A:** The steps below work on both Android and iOS as nRF has made both apps' user interface the same on both platforms:
 
-![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
+1. Download nRF's DFU app from iOS App Store or Android's Play Store, you can find the app by searching for `nrf dfu`, the app's full name is `nRF Device Firmware Update`
+2. On flasher.meshcore.co.uk, download the **ZIP** version of the firmware for your nRF device (e.g. RAK or Heltec T114 or Seeed Studio's Xiao)
+3. From the MeshCore app, login remotely to the repeater you want to update with admin priviledge
+4. Go to the Command Line tab, type `start ota` and hit enter.
+5. you should see `OK` to confirm the repeater device is now in OTA mode
+6. Run the DFU app,tab `Settings` on the top right corner
+7. Enable `Packets receipt notifications` and change `Number of Packets` to 10 for RAK, 8 for T114.  8 also works for RAK.  
+8. Select the firmware zip file you downloaded
+9. Select the device you want to update. If the device you want to updat is not on the list, try enabling`OTA` on the device again
+10. Tab the `Upload` to begin OTA update
+11. If it fails, try turning off and on Bluetooth on your phone.  If that doesn't work, try rebooting your phone.  
+12. Wait for the update to complete.  It can take a few minutes.
 
 
 ---
-    

docs/packet_structure.md

@@ -0,0 +1,51 @@
+# Packet Structure
+
+| Field    | Size (bytes)                     | Description                                               |
+|----------|----------------------------------|-----------------------------------------------------------|
+| header   | 1                                | Contains routing type, payload type, and payload version. |
+| path_len | 1                                | Length of the path field in bytes.                        |
+| path     | up to 64 (`MAX_PATH_SIZE`)       | Stores the routing path if applicable.                    |
+| payload  | up to 184 (`MAX_PACKET_PAYLOAD`) | The actual data being transmitted.                        |
+
+Note: see the [payloads doc](./payloads.md) for more information about the content of payload.
+
+## Header Breakdown
+
+| Bits  | Mask   | Field           | Description                                   |
+|-------|--------|-----------------|-----------------------------------------------|
+| 0-1   | `0x03` | Route Type      | Flood, Direct, Reserved - see below.          |
+| 2-5   | `0x0F` | Payload Type    | Request, Response, ACK, etc. - see below.     |
+| 6-7   | `0x03` | Payload Version | Versioning of the payload format - see below. |
+
+## Route Type Values
+
+| Value  | Name                   | Description                          |
+|--------|------------------------|--------------------------------------|
+| `0x00` | `ROUTE_TYPE_RESERVED1` | Reserved for future use.             |
+| `0x01` | `ROUTE_TYPE_FLOOD`     | Flood routing mode (builds up path). |
+| `0x02` | `ROUTE_TYPE_DIRECT`    | Direct route (path is supplied).     |
+| `0x03` | `ROUTE_TYPE_RESERVED2` | Reserved for future use.             |
+
+## Payload Type Values
+
+| Value  | Name                      | Description                                   |
+|--------|---------------------------|-----------------------------------------------|
+| `0x00` | `PAYLOAD_TYPE_REQ`        | Request (destination/source hashes + MAC).    |
+| `0x01` | `PAYLOAD_TYPE_RESPONSE`   | Response to REQ or ANON_REQ.                  |
+| `0x02` | `PAYLOAD_TYPE_TXT_MSG`    | Plain text message.                           |
+| `0x03` | `PAYLOAD_TYPE_ACK`        | Acknowledgment.                               |
+| `0x04` | `PAYLOAD_TYPE_ADVERT`     | Node advertisement.                           |
+| `0x05` | `PAYLOAD_TYPE_GRP_TXT`    | Group text message (unverified).              |
+| `0x06` | `PAYLOAD_TYPE_GRP_DATA`   | Group datagram (unverified).                  |
+| `0x07` | `PAYLOAD_TYPE_ANON_REQ`   | Anonymous request.                            |
+| `0x08` | `PAYLOAD_TYPE_PATH`       | Returned path.                                |
+| `0x0F` | `PAYLOAD_TYPE_RAW_CUSTOM` | Custom packet (raw bytes, custom encryption). |
+
+## Payload Version Values
+
+| Value  | Version | Description                                       |
+|--------|---------|---------------------------------------------------|
+| `0x00` | 1       | 1-byte src/dest hashes, 2-byte MAC.               |
+| `0x01` | 2       | Future version (e.g., 2-byte hashes, 4-byte MAC). |
+| `0x02` | 3       | Future version.                                   |
+| `0x03` | 4       | Future version.                                   |

docs/payloads.md

@@ -0,0 +1,176 @@
+# Meshcore payloads
+Inside of each [meshcore packet](./packet_structure.md) is a payload, identified by the payload type in the packet header. The types of payloads are:
+
+* Request (destination/source hashes + MAC).
+* Response to REQ or ANON_REQ.
+* Plain text message.
+* Acknowledgment.
+* Node advertisement.
+* Group text message (unverified).
+* Group datagram (unverified).
+* Anonymous request.
+* Returned path.
+* Custom packet (raw bytes, custom encryption).
+
+This document defines the structure of each of these payload types
+
+# Node advertisement
+This kind of payload notifies receivers that a node exists, and gives information about the node
+
+| Field         | Size (bytes)    | Description                                              |
+|---------------|-----------------|----------------------------------------------------------|
+| public key    | 32              | Ed25519 public key                                       |
+| timestamp     | 4               | unix timestamp of advertisement                          |
+| signature     | 64              | Ed25519 signature of public key, timestamp, and app data |
+| appdata       | rest of payload | optional, see below                                      |
+
+Appdata
+
+| Field         | Size (bytes)    | Description                                           |
+|---------------|-----------------|-------------------------------------------------------|
+| flags         | 1               | specifies which of the fields are present, see below  |
+| latitude      | 4               | decimal latitude multiplied by 1000000, integer       |
+| longitude     | 4               | decimal longitude multiplied by 1000000, integer      |
+| feature 1     | 2               | reserved for future use                               |
+| feature 2     | 2               | reserved for future use                               |
+| name          | rest of appdata | name of the node                                      |
+
+Appdata Flags
+
+| Value  | Name      | Description                           |
+|--------|-----------|---------------------------------------|
+| `0x10` | location  | appdata contains lat/long information |
+| `0x20` | feature 1 | Reserved for future use.              |
+| `0x40` | feature 2 | Reserved for future use.              |
+| `0x80` | name      | appdata contains a node name          |
+
+# Acknowledgement
+| Field    | Size (bytes) | Description                                                |
+|----------|--------------|------------------------------------------------------------|
+| checksum | 4            | CRC checksum of message timestamp, text, and sender pubkey |
+
+
+# Returned path, request, response, and plain text message
+| Field            | Size (bytes)    | Description                                          |
+|------------------|-----------------|------------------------------------------------------|
+| destination hash | 1               | first byte of destination node public key            |
+| source hash      | 1               | first byte of source node public key                 |
+| cipher MAC       | 2               | MAC for encrypted data in next field                 |
+| ciphertext       | rest of payload | encrypted message, see subsections below for details |
+
+## Returned path
+
+| Field       | Size (bytes) | Description                                                                                  |
+|-------------|--------------|----------------------------------------------------------------------------------------------|
+| path length | 1            | length of next field                                                                         |
+| path        | see above    | a list of node hashes (one byte each) describing the route from us to the packet author      |
+| extra type  | 1            | extra, bundled payload type, eg., acknowledgement or response. See packet structure spec     |
+| extra       | rest of data | extra, bundled payload content, follows same format as main content defined by this document |
+
+## Request
+
+| Field        | Size (bytes)    | Description                |
+|--------------|-----------------|----------------------------|
+| timestamp    | 4               | send time (unix timestamp) |
+| request type | 1               | see below                  |
+| request data | rest of payload | depends on request type    |
+
+Request type
+
+| Value  | Name               | Description                           |
+|--------|--------------------|---------------------------------------|
+| `0x01` | get status         | get status of repeater or room server |
+| `0x02` | keepalive          | TODO |
+| `0x03` | get telemetry data | TODO |
+
+### Get status
+
+Gets information about the node, possibly including the following:
+
+* Battery level (millivolts)
+* Current transmit queue length
+* Current free queue length
+* Last RSSI value
+* Number of received packets
+* Number of sent packets
+* Total airtime (seconds)
+* Total uptime (seconds)
+* Number of packets sent as flood
+* Number of packets sent directly
+* Number of packets received as flood
+* Number of packets received directly
+* Error flags
+* Last SNR value
+* Number of direct route duplicates
+* Number of flood route duplicates
+* Number posted (?)
+* Number of post pushes (?)
+
+### Keepalive
+
+No-op request.
+
+### Get telemetry data
+
+Request data about sensors on the node, including battery level.
+
+## Response
+
+| Field   | Size (bytes)    | Description |
+|---------|-----------------|-------------|
+| tag     | 4               | TODO        |
+| content | rest of payload | TODO        |
+
+## Plain text message
+
+| Field        | Size (bytes)    | Description                                                  |
+|--------------|-----------------|--------------------------------------------------------------|
+| timestamp    | 4               | send time (unix timestamp)                                   |
+| flags + TODO | 1               | first six bits are flags (see below), last two bits are TODO |
+| message      | rest of payload | the message content, see next table                          |
+
+Flags
+
+| Value  | Description               | Message content                                            |
+|--------|---------------------------|------------------------------------------------------------|
+| `0x00` | plain text message        | the plain text of the message                              |
+| `0x01` | CLI command               | the command text of the message                            |
+| `0x02` | signed plain text message | two bytes of sender prefix, followed by plain text message |
+
+# Anonymous request
+
+| Field            | Size (bytes)    | Description                               |
+|------------------|-----------------|-------------------------------------------|
+| destination hash | 1               | first byte of destination node public key |
+| public key       | 32              | sender's Ed25519 public key               |
+| cipher MAC       | 2               | MAC for encrypted data in next field      |
+| ciphertext       | rest of payload | encrypted message, see below for details  |
+
+Plaintext message
+
+| Field          | Size (bytes)    | Description                                                                   |
+|----------------|-----------------|-------------------------------------------------------------------------------|
+| timestamp      | 4               | send time (unix timestamp)                                                    |
+| sync timestamp | 4               | for room server, otherwise absent: sender's "sync messages SINCE x" timestamp |
+| password       | rest of message | password for repeater/room                                                    |
+
+# Group text message / datagram
+
+| Field        | Size (bytes)    | Description                              |
+|--------------|-----------------|------------------------------------------|
+| channel hash | 1               | TODO                                     | 
+| cipher MAC   | 2               | MAC for encrypted data in next field     |
+| ciphertext   | rest of payload | encrypted message, see below for details |
+
+Plaintext for text message
+
+| Field     | Size (bytes)    | Description                      |
+|-----------|-----------------|----------------------------------|
+| timestamp | 4               | send time (unix timestamp)       |
+| content   | rest of message | plain group text message content |
+
+TODO: describe what datagram looks like
+
+# Custom packet
+
+Custom packets have no defined format.

examples/companion_radio/Button.cpp

@@ -0,0 +1,125 @@
+#include "Button.h"
+
+Button::Button(uint8_t pin, bool activeState) 
+    : _pin(pin), _activeState(activeState), _isAnalog(false), _analogThreshold(20) {
+    _currentState = false;  // Initialize as not pressed
+    _lastState = _currentState;
+}
+
+Button::Button(uint8_t pin, bool activeState, bool isAnalog, uint16_t analogThreshold)
+    : _pin(pin), _activeState(activeState), _isAnalog(isAnalog), _analogThreshold(analogThreshold) {
+    _currentState = false;  // Initialize as not pressed
+    _lastState = _currentState;
+}
+
+void Button::begin() {
+    _currentState = readButton();
+    _lastState = _currentState;
+}
+
+void Button::update() {
+    uint32_t now = millis();
+    
+    // Read button at specified interval
+    if (now - _lastReadTime < BUTTON_READ_INTERVAL_MS) {
+        return;
+    }
+    _lastReadTime = now;
+    
+    bool newState = readButton();
+    
+    // Check if state has changed
+    if (newState != _lastState) {
+        _stateChangeTime = now;
+    }
+    
+    // Debounce check
+    if ((now - _stateChangeTime) > BUTTON_DEBOUNCE_TIME_MS) {
+        if (newState != _currentState) {
+            _currentState = newState;
+            handleStateChange();
+        }
+    }
+    
+    _lastState = newState;
+    
+    // Handle multi-click timeout
+    if (_state == WAITING_FOR_MULTI_CLICK && (now - _releaseTime) > BUTTON_CLICK_TIMEOUT_MS) {
+        // Timeout reached, process the clicks
+        if (_clickCount == 1) {
+            triggerEvent(SHORT_PRESS);
+        } else if (_clickCount == 2) {
+            triggerEvent(DOUBLE_PRESS);
+        } else if (_clickCount >= 3) {
+            triggerEvent(TRIPLE_PRESS);
+        }
+        _clickCount = 0;
+        _state = IDLE;
+    }
+    
+    // Handle long press while button is held
+    if (_state == PRESSED && (now - _pressTime) > BUTTON_LONG_PRESS_TIME_MS) {
+        triggerEvent(LONG_PRESS);
+        _state = IDLE;  // Prevent multiple press events
+        _clickCount = 0;
+    }
+}
+
+bool Button::readButton() {
+    if (_isAnalog) {
+        return (analogRead(_pin) < _analogThreshold);
+    } else {
+        return (digitalRead(_pin) == _activeState);
+    }
+}
+
+void Button::handleStateChange() {
+    uint32_t now = millis();
+    
+    if (_currentState) {
+        // Button pressed
+        _pressTime = now;
+        _state = PRESSED;
+        triggerEvent(ANY_PRESS);
+    } else {
+        // Button released
+        if (_state == PRESSED) {
+            uint32_t pressDuration = now - _pressTime;
+            
+            if (pressDuration < BUTTON_LONG_PRESS_TIME_MS) {
+                // Short press detected
+                _clickCount++;
+                _releaseTime = now;
+                _state = WAITING_FOR_MULTI_CLICK;
+            } else {
+                // Long press already handled in update()
+                _state = IDLE;
+                _clickCount = 0;
+            }
+        }
+    }
+}
+
+void Button::triggerEvent(EventType event) {
+    _lastEvent = event;
+    
+    switch (event) {
+        case ANY_PRESS:
+            if (_onAnyPress) _onAnyPress();
+            break;
+        case SHORT_PRESS:
+            if (_onShortPress) _onShortPress();
+            break;
+        case DOUBLE_PRESS:
+            if (_onDoublePress) _onDoublePress();
+            break;
+        case TRIPLE_PRESS:
+            if (_onTriplePress) _onTriplePress();
+            break;
+        case LONG_PRESS:
+            if (_onLongPress) _onLongPress();
+            break;
+        default:
+            break;
+    }
+}

examples/companion_radio/Button.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <Arduino.h>
+#include <functional>
+
+// Button timing configuration
+#define BUTTON_DEBOUNCE_TIME_MS    50      // Debounce time in ms
+#define BUTTON_CLICK_TIMEOUT_MS    500     // Max time between clicks for multi-click
+#define BUTTON_LONG_PRESS_TIME_MS  3000    // Time to trigger long press (3 seconds)
+#define BUTTON_READ_INTERVAL_MS    10      // How often to read the button
+
+class Button {
+public:
+    enum EventType {
+        NONE,
+        SHORT_PRESS,
+        DOUBLE_PRESS,
+        TRIPLE_PRESS,
+        LONG_PRESS,
+        ANY_PRESS
+    };
+
+    using EventCallback = std::function<void()>;
+
+    Button(uint8_t pin, bool activeState = LOW);
+    Button(uint8_t pin, bool activeState, bool isAnalog, uint16_t analogThreshold = 20);
+    
+    void begin();
+    void update();
+    
+    // Set callbacks for different events
+    void onShortPress(EventCallback callback) { _onShortPress = callback; }
+    void onDoublePress(EventCallback callback) { _onDoublePress = callback; }
+    void onTriplePress(EventCallback callback) { _onTriplePress = callback; }
+    void onLongPress(EventCallback callback) { _onLongPress = callback; }
+    void onAnyPress(EventCallback callback) { _onAnyPress = callback; }
+    
+    // State getters
+    bool isPressed() const { return _currentState; }
+    EventType getLastEvent() const { return _lastEvent; }
+
+private:
+    enum State {
+        IDLE,
+        PRESSED,
+        RELEASED,
+        WAITING_FOR_MULTI_CLICK
+    };
+
+    uint8_t _pin;
+    bool _activeState;
+    bool _isAnalog;
+    uint16_t _analogThreshold;
+    
+    State _state = IDLE;
+    bool _currentState;
+    bool _lastState;
+    
+    uint32_t _stateChangeTime = 0;
+    uint32_t _pressTime = 0;
+    uint32_t _releaseTime = 0;
+    uint32_t _lastReadTime = 0;
+    
+    uint8_t _clickCount = 0;
+    EventType _lastEvent = NONE;
+    
+    // Callbacks
+    EventCallback _onShortPress = nullptr;
+    EventCallback _onDoublePress = nullptr;
+    EventCallback _onTriplePress = nullptr;
+    EventCallback _onLongPress = nullptr;
+    EventCallback _onAnyPress = nullptr;
+    
+    bool readButton();
+    void handleStateChange();
+    void triggerEvent(EventType event);
+};

examples/companion_radio/DataStore.cpp

@@ -0,0 +1,391 @@
+#include <Arduino.h>
+#include "DataStore.h"
+
+DataStore::DataStore(FILESYSTEM& fs, mesh::RTCClock& clock) : _fs(&fs), _clock(&clock),
+#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
+    identity_store(fs, "")
+#elif defined(RP2040_PLATFORM)
+    identity_store(fs, "/identity")
+#else
+    identity_store(fs, "/identity")
+#endif
+{
+}
+
+static File openWrite(FILESYSTEM* _fs, const char* filename) {
+#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
+  _fs->remove(filename);
+  return _fs->open(filename, FILE_O_WRITE);
+#elif defined(RP2040_PLATFORM)
+  return _fs->open(filename, "w");
+#else
+  return _fs->open(filename, "w", true);
+#endif
+}
+
+void DataStore::begin() {
+#if defined(RP2040_PLATFORM)
+  identity_store.begin();
+#endif
+
+#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
+  checkAdvBlobFile();
+#else
+  // init 'blob store' support
+  _fs->mkdir("/bl");
+#endif
+}
+
+#if defined(ESP32)
+  #include <SPIFFS.h>
+#elif defined(RP2040_PLATFORM)
+  #include <LittleFS.h>
+#endif
+
+File DataStore::openRead(const char* filename) {
+#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
+  return _fs->open(filename, FILE_O_READ);
+#elif defined(RP2040_PLATFORM)
+  return _fs->open(filename, "r");
+#else
+  return _fs->open(filename, "r", false);
+#endif
+}
+
+bool DataStore::removeFile(const char* filename) {
+  return _fs->remove(filename);
+}
+
+bool DataStore::formatFileSystem() {
+#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
+  return _fs->format();
+#elif defined(RP2040_PLATFORM)
+  return LittleFS.format();
+#elif defined(ESP32)
+  return ((fs::SPIFFSFS *)_fs)->format();
+#else
+  #error "need to implement format()"
+#endif
+}
+
+bool DataStore::loadMainIdentity(mesh::LocalIdentity &identity) {
+  return identity_store.load("_main", identity);
+}
+
+bool DataStore::saveMainIdentity(const mesh::LocalIdentity &identity) {
+  return identity_store.save("_main", identity);
+}
+
+void DataStore::loadPrefs(NodePrefs& prefs, double& node_lat, double& node_lon) {
+  if (_fs->exists("/new_prefs")) {
+    loadPrefsInt("/new_prefs", prefs, node_lat, node_lon); // new filename
+  } else if (_fs->exists("/node_prefs")) {
+    loadPrefsInt("/node_prefs", prefs, node_lat, node_lon);
+    savePrefs(prefs, node_lat, node_lon);                // save to new filename
+    _fs->remove("/node_prefs"); // remove old
+  }
+}
+
+void DataStore::loadPrefsInt(const char *filename, NodePrefs& _prefs, double& node_lat, double& node_lon) {
+#if defined(RP2040_PLATFORM)
+  File file = _fs->open(filename, "r");
+#else
+  File file = _fs->open(filename);
+#endif
+  if (file) {
+    uint8_t pad[8];
+
+    file.read((uint8_t *)&_prefs.airtime_factor, sizeof(float));                           // 0
+    file.read((uint8_t *)_prefs.node_name, sizeof(_prefs.node_name));                      // 4
+    file.read(pad, 4);                                                                     // 36
+    file.read((uint8_t *)&node_lat, sizeof(node_lat));                                     // 40
+    file.read((uint8_t *)&node_lon, sizeof(node_lon));                                     // 48
+    file.read((uint8_t *)&_prefs.freq, sizeof(_prefs.freq));                               // 56
+    file.read((uint8_t *)&_prefs.sf, sizeof(_prefs.sf));                                   // 60
+    file.read((uint8_t *)&_prefs.cr, sizeof(_prefs.cr));                                   // 61
+    file.read((uint8_t *)&_prefs.reserved1, sizeof(_prefs.reserved1));                     // 62
+    file.read((uint8_t *)&_prefs.manual_add_contacts, sizeof(_prefs.manual_add_contacts)); // 63
+    file.read((uint8_t *)&_prefs.bw, sizeof(_prefs.bw));                                   // 64
+    file.read((uint8_t *)&_prefs.tx_power_dbm, sizeof(_prefs.tx_power_dbm));               // 68
+    file.read((uint8_t *)&_prefs.telemetry_mode_base, sizeof(_prefs.telemetry_mode_base)); // 69
+    file.read((uint8_t *)&_prefs.telemetry_mode_loc, sizeof(_prefs.telemetry_mode_loc));   // 70
+    file.read((uint8_t *)&_prefs.telemetry_mode_env, sizeof(_prefs.telemetry_mode_env));   // 71
+    file.read((uint8_t *)&_prefs.rx_delay_base, sizeof(_prefs.rx_delay_base));             // 72
+    file.read(pad, 4);                                                                     // 76
+    file.read((uint8_t *)&_prefs.ble_pin, sizeof(_prefs.ble_pin));                         // 80
+
+    file.close();
+  }
+}
+
+void DataStore::savePrefs(const NodePrefs& _prefs, double node_lat, double node_lon) {
+  File file = openWrite(_fs, "/new_prefs");
+  if (file) {
+    uint8_t pad[8];
+    memset(pad, 0, sizeof(pad));
+
+    file.write((uint8_t *)&_prefs.airtime_factor, sizeof(float));                           // 0
+    file.write((uint8_t *)_prefs.node_name, sizeof(_prefs.node_name));                      // 4
+    file.write(pad, 4);                                                                     // 36
+    file.write((uint8_t *)&node_lat, sizeof(node_lat));                                     // 40
+    file.write((uint8_t *)&node_lon, sizeof(node_lon));                                     // 48
+    file.write((uint8_t *)&_prefs.freq, sizeof(_prefs.freq));                               // 56
+    file.write((uint8_t *)&_prefs.sf, sizeof(_prefs.sf));                                   // 60
+    file.write((uint8_t *)&_prefs.cr, sizeof(_prefs.cr));                                   // 61
+    file.write((uint8_t *)&_prefs.reserved1, sizeof(_prefs.reserved1));                     // 62
+    file.write((uint8_t *)&_prefs.manual_add_contacts, sizeof(_prefs.manual_add_contacts)); // 63
+    file.write((uint8_t *)&_prefs.bw, sizeof(_prefs.bw));                                   // 64
+    file.write((uint8_t *)&_prefs.tx_power_dbm, sizeof(_prefs.tx_power_dbm));               // 68
+    file.write((uint8_t *)&_prefs.telemetry_mode_base, sizeof(_prefs.telemetry_mode_base)); // 69
+    file.write((uint8_t *)&_prefs.telemetry_mode_loc, sizeof(_prefs.telemetry_mode_loc));   // 70
+    file.write((uint8_t *)&_prefs.telemetry_mode_env, sizeof(_prefs.telemetry_mode_env));   // 71
+    file.write((uint8_t *)&_prefs.rx_delay_base, sizeof(_prefs.rx_delay_base));             // 72
+    file.write(pad, 4);                                                                     // 76
+    file.write((uint8_t *)&_prefs.ble_pin, sizeof(_prefs.ble_pin));                         // 80
+
+    file.close();
+  }
+}
+
+void DataStore::loadContacts(DataStoreHost* host) {
+  if (_fs->exists("/contacts3")) {
+#if defined(RP2040_PLATFORM)
+    File file = _fs->open("/contacts3", "r");
+#else
+    File file = _fs->open("/contacts3");
+#endif
+    if (file) {
+      bool full = false;
+      while (!full) {
+        ContactInfo c;
+        uint8_t pub_key[32];
+        uint8_t unused;
+
+        bool success = (file.read(pub_key, 32) == 32);
+        success = success && (file.read((uint8_t *)&c.name, 32) == 32);
+        success = success && (file.read(&c.type, 1) == 1);
+        success = success && (file.read(&c.flags, 1) == 1);
+        success = success && (file.read(&unused, 1) == 1);
+        success = success && (file.read((uint8_t *)&c.sync_since, 4) == 4); // was 'reserved'
+        success = success && (file.read((uint8_t *)&c.out_path_len, 1) == 1);
+        success = success && (file.read((uint8_t *)&c.last_advert_timestamp, 4) == 4);
+        success = success && (file.read(c.out_path, 64) == 64);
+        success = success && (file.read((uint8_t *)&c.lastmod, 4) == 4);
+        success = success && (file.read((uint8_t *)&c.gps_lat, 4) == 4);
+        success = success && (file.read((uint8_t *)&c.gps_lon, 4) == 4);
+
+        if (!success) break; // EOF
+
+        c.id = mesh::Identity(pub_key);
+        if (!host->onContactLoaded(c)) full = true;
+      }
+      file.close();
+    }
+  }
+}
+
+void DataStore::saveContacts(DataStoreHost* host) {
+  File file = openWrite(_fs, "/contacts3");
+  if (file) {
+    uint32_t idx = 0;
+    ContactInfo c;
+    uint8_t unused = 0;
+
+    while (host->getContactForSave(idx, c)) {
+      bool success = (file.write(c.id.pub_key, 32) == 32);
+      success = success && (file.write((uint8_t *)&c.name, 32) == 32);
+      success = success && (file.write(&c.type, 1) == 1);
+      success = success && (file.write(&c.flags, 1) == 1);
+      success = success && (file.write(&unused, 1) == 1);
+      success = success && (file.write((uint8_t *)&c.sync_since, 4) == 4);
+      success = success && (file.write((uint8_t *)&c.out_path_len, 1) == 1);
+      success = success && (file.write((uint8_t *)&c.last_advert_timestamp, 4) == 4);
+      success = success && (file.write(c.out_path, 64) == 64);
+      success = success && (file.write((uint8_t *)&c.lastmod, 4) == 4);
+      success = success && (file.write((uint8_t *)&c.gps_lat, 4) == 4);
+      success = success && (file.write((uint8_t *)&c.gps_lon, 4) == 4);
+
+      if (!success) break; // write failed
+
+      idx++;  // advance to next contact
+    }
+    file.close();
+  }
+}
+
+void DataStore::loadChannels(DataStoreHost* host) {
+  if (_fs->exists("/channels2")) {
+#if defined(RP2040_PLATFORM)
+    File file = _fs->open("/channels2", "r");
+#else
+    File file = _fs->open("/channels2");
+#endif
+    if (file) {
+      bool full = false;
+      uint8_t channel_idx = 0;
+      while (!full) {
+        ChannelDetails ch;
+        uint8_t unused[4];
+
+        bool success = (file.read(unused, 4) == 4);
+        success = success && (file.read((uint8_t *)ch.name, 32) == 32);
+        success = success && (file.read((uint8_t *)ch.channel.secret, 32) == 32);
+
+        if (!success) break; // EOF
+
+        if (host->onChannelLoaded(channel_idx, ch)) {
+          channel_idx++;
+        } else {
+          full = true;
+        }
+      }
+      file.close();
+    }
+  }
+}
+
+void DataStore::saveChannels(DataStoreHost* host) {
+  File file = openWrite(_fs, "/channels2");
+  if (file) {
+    uint8_t channel_idx = 0;
+    ChannelDetails ch;
+    uint8_t unused[4];
+    memset(unused, 0, 4);
+
+    while (host->getChannelForSave(channel_idx, ch)) {
+      bool success = (file.write(unused, 4) == 4);
+      success = success && (file.write((uint8_t *)ch.name, 32) == 32);
+      success = success && (file.write((uint8_t *)ch.channel.secret, 32) == 32);
+
+      if (!success) break; // write failed
+      channel_idx++;
+    }
+    file.close();
+  }
+}
+
+#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
+
+#define MAX_ADVERT_PKT_LEN   (2 + 32 + PUB_KEY_SIZE + 4 + SIGNATURE_SIZE + MAX_ADVERT_DATA_SIZE)
+
+struct BlobRec {
+  uint32_t timestamp;
+  uint8_t  key[7];
+  uint8_t  len;
+  uint8_t  data[MAX_ADVERT_PKT_LEN];
+};
+
+void DataStore::checkAdvBlobFile() {
+  if (!_fs->exists("/adv_blobs")) {
+    File file = openWrite(_fs, "/adv_blobs");
+    if (file) {
+      BlobRec zeroes;
+      memset(&zeroes, 0, sizeof(zeroes));
+      for (int i = 0; i < 20; i++) {     // pre-allocate to fixed size
+        file.write((uint8_t *) &zeroes, sizeof(zeroes));
+      }
+      file.close();
+    }
+  }
+}
+
+uint8_t DataStore::getBlobByKey(const uint8_t key[], int key_len, uint8_t dest_buf[]) {
+  File file = _fs->open("/adv_blobs");
+  uint8_t len = 0;  // 0 = not found
+
+  if (file) {
+    BlobRec tmp;
+    while (file.read((uint8_t *) &tmp, sizeof(tmp)) == sizeof(tmp)) {
+      if (memcmp(key, tmp.key, sizeof(tmp.key)) == 0) {  // only match by 7 byte prefix
+        len = tmp.len;
+        memcpy(dest_buf, tmp.data, len);
+        break;
+      }
+    }
+    file.close();
+  }
+  return len;
+}
+
+bool DataStore::putBlobByKey(const uint8_t key[], int key_len, const uint8_t src_buf[], uint8_t len) {
+  if (len < PUB_KEY_SIZE+4+SIGNATURE_SIZE || len > MAX_ADVERT_PKT_LEN) return false;
+
+  checkAdvBlobFile();
+
+  File file = _fs->open("/adv_blobs", FILE_O_WRITE);
+  if (file) {
+    uint32_t pos = 0, found_pos = 0;
+    uint32_t min_timestamp = 0xFFFFFFFF;
+
+    // search for matching key OR evict by oldest timestmap
+    BlobRec tmp;
+    file.seek(0);
+    while (file.read((uint8_t *) &tmp, sizeof(tmp)) == sizeof(tmp)) {
+      if (memcmp(key, tmp.key, sizeof(tmp.key)) == 0) {  // only match by 7 byte prefix
+        found_pos = pos;
+        break;
+      }
+      if (tmp.timestamp < min_timestamp) {
+        min_timestamp = tmp.timestamp;
+        found_pos = pos;
+      }
+
+      pos += sizeof(tmp);
+    }
+
+    memcpy(tmp.key, key, sizeof(tmp.key));  // just record 7 byte prefix of key
+    memcpy(tmp.data, src_buf, len);
+    tmp.len = len;
+    tmp.timestamp = _clock->getCurrentTime();
+
+    file.seek(found_pos);
+    file.write((uint8_t *) &tmp, sizeof(tmp));
+
+    file.close();
+    return true;
+  }
+  return false; // error
+}
+#else
+uint8_t DataStore::getBlobByKey(const uint8_t key[], int key_len, uint8_t dest_buf[]) {
+  char path[64];
+  char fname[18];
+
+  if (key_len > 8) key_len = 8; // just use first 8 bytes (prefix)
+  mesh::Utils::toHex(fname, key, key_len);
+  sprintf(path, "/bl/%s", fname);
+
+  if (_fs->exists(path)) {
+#if defined(RP2040_PLATFORM)
+    File f = _fs->open(path, "r");
+#else
+    File f = _fs->open(path);
+#endif
+    if (f) {
+      int len = f.read(dest_buf, 255); // currently MAX 255 byte blob len supported!!
+      f.close();
+      return len;
+    }
+  }
+  return 0; // not found
+}
+
+bool DataStore::putBlobByKey(const uint8_t key[], int key_len, const uint8_t src_buf[], uint8_t len) {
+  char path[64];
+  char fname[18];
+
+  if (key_len > 8) key_len = 8; // just use first 8 bytes (prefix)
+  mesh::Utils::toHex(fname, key, key_len);
+  sprintf(path, "/bl/%s", fname);
+
+  File f = openWrite(_fs, path);
+  if (f) {
+    int n = f.write(src_buf, len);
+    f.close();
+    if (n == len) return true; // success!
+
+    _fs->remove(path); // blob was only partially written!
+  }
+  return false; // error
+}
+#endif

examples/companion_radio/DataStore.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <helpers/IdentityStore.h>
+#include <helpers/ContactInfo.h>
+#include <helpers/ChannelDetails.h>
+#include "NodePrefs.h"
+
+class DataStoreHost {
+public:
+  virtual bool onContactLoaded(const ContactInfo& contact) =0;
+  virtual bool getContactForSave(uint32_t idx, ContactInfo& contact) =0;
+  virtual bool onChannelLoaded(uint8_t channel_idx, const ChannelDetails& ch) =0;
+  virtual bool getChannelForSave(uint8_t channel_idx, ChannelDetails& ch) =0;
+};
+
+class DataStore {
+  FILESYSTEM* _fs;
+  mesh::RTCClock* _clock;
+  IdentityStore identity_store;
+
+  void loadPrefsInt(const char *filename, NodePrefs& prefs, double& node_lat, double& node_lon);
+#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
+  void checkAdvBlobFile();
+#endif
+
+public:
+  DataStore(FILESYSTEM& fs, mesh::RTCClock& clock);
+  void begin();
+  bool formatFileSystem();
+  bool loadMainIdentity(mesh::LocalIdentity &identity);
+  bool saveMainIdentity(const mesh::LocalIdentity &identity);
+  void loadPrefs(NodePrefs& prefs, double& node_lat, double& node_lon);
+  void savePrefs(const NodePrefs& prefs, double node_lat, double node_lon);
+  void loadContacts(DataStoreHost* host);
+  void saveContacts(DataStoreHost* host);
+  void loadChannels(DataStoreHost* host);
+  void saveChannels(DataStoreHost* host);
+  uint8_t getBlobByKey(const uint8_t key[], int key_len, uint8_t dest_buf[]);
+  bool putBlobByKey(const uint8_t key[], int key_len, const uint8_t src_buf[], uint8_t len);
+  File openRead(const char* filename);
+  bool removeFile(const char* filename);
+};

examples/companion_radio/MyMesh.h

@@ -0,0 +1,201 @@
+#pragma once
+
+#include <Arduino.h>
+#include <Mesh.h>
+#ifdef DISPLAY_CLASS
+#include "UITask.h"
+#endif
+
+/*------------ Frame Protocol --------------*/
+#define FIRMWARE_VER_CODE 5
+
+#ifndef FIRMWARE_BUILD_DATE
+#define FIRMWARE_BUILD_DATE "7 Jun 2025"
+#endif
+
+#ifndef FIRMWARE_VERSION
+#define FIRMWARE_VERSION "v1.7.0"
+#endif
+
+#if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
+#include <InternalFileSystem.h>
+#elif defined(RP2040_PLATFORM)
+#include <LittleFS.h>
+#elif defined(ESP32)
+#include <SPIFFS.h>
+#endif
+
+#include "DataStore.h"
+#include "NodePrefs.h"
+
+#include <RTClib.h>
+#include <helpers/ArduinoHelpers.h>
+#include <helpers/BaseSerialInterface.h>
+#include <helpers/IdentityStore.h>
+#include <helpers/SimpleMeshTables.h>
+#include <helpers/StaticPoolPacketManager.h>
+#include <target.h>
+
+/* ---------------------------------- CONFIGURATION ------------------------------------- */
+
+#ifndef LORA_FREQ
+#define LORA_FREQ 915.0
+#endif
+#ifndef LORA_BW
+#define LORA_BW 250
+#endif
+#ifndef LORA_SF
+#define LORA_SF 10
+#endif
+#ifndef LORA_CR
+#define LORA_CR 5
+#endif
+#ifndef LORA_TX_POWER
+#define LORA_TX_POWER 20
+#endif
+#ifndef MAX_LORA_TX_POWER
+#define MAX_LORA_TX_POWER LORA_TX_POWER
+#endif
+
+#ifndef MAX_CONTACTS
+#define MAX_CONTACTS 100
+#endif
+
+#ifndef OFFLINE_QUEUE_SIZE
+#define OFFLINE_QUEUE_SIZE 16
+#endif
+
+#ifndef BLE_NAME_PREFIX
+#define BLE_NAME_PREFIX "MeshCore-"
+#endif
+
+#include <helpers/BaseChatMesh.h>
+
+/* -------------------------------------------------------------------------------------- */
+
+#define REQ_TYPE_GET_STATUS             0x01 // same as _GET_STATS
+#define REQ_TYPE_KEEP_ALIVE             0x02
+#define REQ_TYPE_GET_TELEMETRY_DATA     0x03
+
+class MyMesh : public BaseChatMesh, public DataStoreHost {
+public:
+  MyMesh(mesh::Radio &radio, mesh::RNG &rng, mesh::RTCClock &rtc, SimpleMeshTables &tables, DataStore& store);
+
+  void begin(bool has_display);
+  void startInterface(BaseSerialInterface &serial);
+
+  const char *getNodeName();
+  NodePrefs *getNodePrefs();
+  uint32_t getBLEPin();
+
+  void loop();
+  void handleCmdFrame(size_t len);
+  bool advert();
+  void enterCLIRescue();
+
+protected:
+  float getAirtimeBudgetFactor() const override;
+  int getInterferenceThreshold() const override;
+  int calcRxDelay(float score, uint32_t air_time) const override;
+
+  void logRxRaw(float snr, float rssi, const uint8_t raw[], int len) override;
+  bool isAutoAddEnabled() const override;
+  void onDiscoveredContact(ContactInfo &contact, bool is_new) override;
+  void onContactPathUpdated(const ContactInfo &contact) override;
+  bool processAck(const uint8_t *data) override;
+  void queueMessage(const ContactInfo &from, uint8_t txt_type, mesh::Packet *pkt, uint32_t sender_timestamp,
+                    const uint8_t *extra, int extra_len, const char *text);
+
+  void onMessageRecv(const ContactInfo &from, mesh::Packet *pkt, 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, mesh::Packet *pkt, uint32_t sender_timestamp,
+                           const uint8_t *sender_prefix, const char *text) override;
+  void onChannelMessageRecv(const mesh::GroupChannel &channel, mesh::Packet *pkt, uint32_t timestamp,
+                            const char *text) override;
+
+  uint8_t onContactRequest(const ContactInfo &contact, uint32_t sender_timestamp, const uint8_t *data,
+                           uint8_t len, uint8_t *reply) override;
+  void onContactResponse(const ContactInfo &contact, const uint8_t *data, uint8_t len) override;
+  void onRawDataRecv(mesh::Packet *packet) override;
+  void onTraceRecv(mesh::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) override;
+
+  uint32_t calcFloodTimeoutMillisFor(uint32_t pkt_airtime_millis) const override;
+  uint32_t calcDirectTimeoutMillisFor(uint32_t pkt_airtime_millis, uint8_t path_len) const override;
+  void onSendTimeout() override;
+
+  // DataStoreHost methods
+  bool onContactLoaded(const ContactInfo& contact) override { return addContact(contact); }
+  bool getContactForSave(uint32_t idx, ContactInfo& contact) override { return getContactByIdx(idx, contact); }
+  bool onChannelLoaded(uint8_t channel_idx, const ChannelDetails& ch) override { return setChannel(channel_idx, ch); }
+  bool getChannelForSave(uint8_t channel_idx, ChannelDetails& ch) override { return getChannel(channel_idx, ch); }
+
+private:
+  void writeOKFrame();
+  void writeErrFrame(uint8_t err_code);
+  void writeDisabledFrame();
+  void writeContactRespFrame(uint8_t code, const ContactInfo &contact);
+  void updateContactFromFrame(ContactInfo &contact, const uint8_t *frame, int len);
+  void addToOfflineQueue(const uint8_t frame[], int len);
+  int getFromOfflineQueue(uint8_t frame[]);
+  int getBlobByKey(const uint8_t key[], int key_len, uint8_t dest_buf[]) override { 
+    return _store->getBlobByKey(key, key_len, dest_buf);
+  }
+  bool putBlobByKey(const uint8_t key[], int key_len, const uint8_t src_buf[], int len) override {
+    return _store->putBlobByKey(key, key_len, src_buf, len);
+  }
+
+  void checkCLIRescueCmd();
+  void checkSerialInterface();
+
+  // helpers, short-cuts
+  void savePrefs() { _store->savePrefs(_prefs, sensors.node_lat, sensors.node_lon); }
+  void saveChannels() { _store->saveChannels(this); }
+  void saveContacts() { _store->saveContacts(this); }
+
+private:
+  DataStore* _store;
+  NodePrefs _prefs;
+  uint32_t pending_login;
+  uint32_t pending_status;
+  uint32_t pending_telemetry;
+  BaseSerialInterface *_serial;
+
+  ContactsIterator _iter;
+  uint32_t _iter_filter_since;
+  uint32_t _most_recent_lastmod;
+  uint32_t _active_ble_pin;
+  bool _iter_started;
+  bool _cli_rescue;
+  char cli_command[80];
+  uint8_t app_target_ver;
+  uint8_t *sign_data;
+  uint32_t sign_data_len;
+  unsigned long dirty_contacts_expiry;
+
+  uint8_t cmd_frame[MAX_FRAME_SIZE + 1];
+  uint8_t out_frame[MAX_FRAME_SIZE + 1];
+  CayenneLPP telemetry;
+
+  struct Frame {
+    uint8_t len;
+    uint8_t buf[MAX_FRAME_SIZE];
+  };
+  int offline_queue_len;
+  Frame offline_queue[OFFLINE_QUEUE_SIZE];
+
+  struct AckTableEntry {
+    unsigned long msg_sent;
+    uint32_t ack;
+  };
+#define EXPECTED_ACK_TABLE_SIZE 8
+  AckTableEntry expected_ack_table[EXPECTED_ACK_TABLE_SIZE]; // circular table
+  int next_ack_idx;
+};
+
+extern MyMesh the_mesh;
+#ifdef DISPLAY_CLASS
+extern UITask ui_task;
+#endif

examples/companion_radio/NodePrefs.h

@@ -1,6 +1,4 @@
-#ifndef NODE_PREFS_H
-#define NODE_PREFS_H
-
+#pragma once
 #include <cstdint> // For uint8_t, uint32_t
 
 #define TELEM_MODE_DENY            0
@@ -22,6 +20,4 @@ struct NodePrefs {  // persisted to file
   uint8_t telemetry_mode_env;
   float rx_delay_base;
   uint32_t ble_pin;
-};
-
-#endif // NODE_PREFS_H
+};

examples/companion_radio/UITask.cpp

@@ -2,6 +2,7 @@
 #include <Arduino.h>
 #include <helpers/TxtDataHelpers.h>
 #include "NodePrefs.h"
+#include "MyMesh.h"
 
 #define AUTO_OFF_MILLIS     15000   // 15 seconds
 #define BOOT_SCREEN_MILLIS   4000   // 4 seconds
@@ -33,30 +34,48 @@ 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(DisplayDriver* display, NodePrefs* node_prefs, const char* build_date, const char* firmware_version, uint32_t pin_code) {
+void UITask::begin(DisplayDriver* display, NodePrefs* node_prefs) {
   _display = display;
   _auto_off = millis() + AUTO_OFF_MILLIS;
   clearMsgPreview();
   _node_prefs = node_prefs;
-  _pin_code = pin_code;
   if (_display != NULL) {
     _display->turnOn();
   }
 
   // strip off dash and commit hash by changing dash to null terminator
   // e.g: v1.2.3-abcdef -> v1.2.3
-  char *version = strdup(firmware_version);
+  char *version = strdup(FIRMWARE_VERSION);
   char *dash = strchr(version, '-');
-  if(dash){
+  if (dash) {
     *dash = 0;
   }
 
   // v1.2.3 (1 Jan 2025)
-  sprintf(_version_info, "%s (%s)", version, build_date);
+  sprintf(_version_info, "%s (%s)", version, FIRMWARE_BUILD_DATE);
 
 #ifdef PIN_BUZZER
   buzzer.begin();
 #endif
+
+  // Initialize button with appropriate configuration
+#if defined(PIN_USER_BTN) || defined(PIN_USER_BTN_ANA)
+  #ifdef PIN_USER_BTN
+    _userButton = new Button(PIN_USER_BTN, USER_BTN_PRESSED);
+  #else
+    _userButton = new Button(PIN_USER_BTN_ANA, USER_BTN_PRESSED, true, 20);
+  #endif
+  
+  _userButton->begin();
+  
+  // Set up button callbacks
+  _userButton->onShortPress([this]() { handleButtonShortPress(); });
+  _userButton->onDoublePress([this]() { handleButtonDoublePress(); });
+  _userButton->onTriplePress([this]() { handleButtonTriplePress(); });
+  _userButton->onLongPress([this]() { handleButtonLongPress(); });
+  _userButton->onAnyPress([this]() { handleButtonAnyPress(); });
+#endif
+  ui_started_at = millis();
 }
 
 void UITask::soundBuzzer(UIEventType bet) {
@@ -69,6 +88,9 @@ switch(bet){
   case UIEventType::channelMessage:
     buzzer.play("kerplop:d=16,o=6,b=120:32g#,32c#");
     break;
+  case UIEventType::ack:
+    buzzer.play("ack:d=32,o=8,b=120:c");
+    break;
   case UIEventType::roomMessage:
   case UIEventType::newContactMessage:
   case UIEventType::none:
@@ -140,7 +162,16 @@ void UITask::renderCurrScreen() {
   if (_display == NULL) return;  // assert() ??
 
   char tmp[80];
-  if (_origin[0] && _msg[0]) { // message preview
+  if (_alert[0]) {
+    uint16_t textWidth = _display->getTextWidth(_alert);
+    _display->setCursor((_display->width() - textWidth) / 2, 22);
+    _display->setTextSize(1.4);
+    _display->setColor(DisplayDriver::GREEN);
+    _display->print(_alert);
+    _alert[0] = 0;
+    _need_refresh = true;
+    return;
+  } else if (_origin[0] && _msg[0]) { // message preview
     // render message preview
     _display->setCursor(0, 0);
     _display->setTextSize(1);
@@ -194,11 +225,11 @@ void UITask::renderCurrScreen() {
     _display->print(tmp);
 
     // BT pin
-    if (!_connected && _pin_code != 0) {
+    if (!_connected && the_mesh.getBLEPin() != 0) {
       _display->setColor(DisplayDriver::RED);
       _display->setTextSize(2);
       _display->setCursor(0, 43);
-      sprintf(tmp, "Pin:%d", _pin_code);
+      sprintf(tmp, "Pin:%d", the_mesh.getBLEPin());
       _display->print(tmp);
       _display->setColor(DisplayDriver::GREEN);
     } else {
@@ -233,53 +264,36 @@ void UITask::userLedHandler() {
 #endif
 }
 
-void UITask::buttonHandler() {
-  #if defined(PIN_USER_BTN) || defined(PIN_USER_BTN_ANA)
-    static int prev_btn_state = !USER_BTN_PRESSED;
-    static int prev_btn_state_ana = !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 = 0;
-      int btn_state_ana = 0;
-      #ifdef PIN_USER_BTN
-      btn_state = digitalRead(PIN_USER_BTN);
-      #endif
-      #ifdef PIN_USER_BTN_ANA
-      btn_state_ana = (analogRead(PIN_USER_BTN_ANA) < 20); // analogRead returns a value hopefully below 20 when button is pressed. 
-      #endif
-      if (btn_state != prev_btn_state || btn_state_ana != prev_btn_state_ana) { // check for either digital or analogue button change of state
-        if (btn_state == USER_BTN_PRESSED || btn_state_ana == USER_BTN_PRESSED) {  // pressed?
-          if (_display != NULL) {
-            if (_display->isOn()) {
-              clearMsgPreview();
-            } else {
-              _display->turnOn();
-              _need_refresh = true;
-            }
-            _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;
-        prev_btn_state_ana = btn_state_ana;
-      }
-      next_read = millis() + 100;  // 10 reads per second
-    }
-  #endif
-  }
+/* 
+  hardware-agnostic pre-shutdown activity should be done here 
+*/
+void UITask::shutdown(bool restart){
+
+  #ifdef PIN_BUZZER
+  /* note: we have a choice here -
+     we can do a blocking buzzer.loop() with non-deterministic consequences
+     or we can set a flag and delay the shutdown for a couple of seconds
+     while a non-blocking buzzer.loop() plays out in UITask::loop()
+  */
+  buzzer.shutdown();
+  uint32_t buzzer_timer = millis(); // fail-safe shutdown
+  while (buzzer.isPlaying() && (millis() - 2500) < buzzer_timer)
+    buzzer.loop();
+
+  #endif // PIN_BUZZER
+
+  if (restart)
+    _board->reboot();
+  else
+    _board->powerOff();
+}
 
 void UITask::loop() {
-  buttonHandler();
+  #if defined(PIN_USER_BTN) || defined(PIN_USER_BTN_ANA)
+    if (_userButton) {
+      _userButton->update();
+    }
+  #endif
   userLedHandler();
 
 #ifdef PIN_BUZZER
@@ -304,3 +318,72 @@ void UITask::loop() {
     }
   }
 }
+
+void UITask::handleButtonAnyPress() {
+  MESH_DEBUG_PRINTLN("UITask: any press triggered");
+  // called on any button press before other events, to wake up the display quickly
+  // do not refresh the display here, as it may block the button handler
+  if (_display != NULL) {
+    _displayWasOn = _display->isOn();  // Track display state before any action
+    if (!_displayWasOn) {
+      _display->turnOn();
+    }
+    _auto_off = millis() + AUTO_OFF_MILLIS;   // extend auto-off timer
+  }
+}
+
+void UITask::handleButtonShortPress() {
+  MESH_DEBUG_PRINTLN("UITask: short press triggered");
+  if (_display != NULL) {
+    // Only clear message preview if display was already on before button press
+    if (_displayWasOn) {
+      // If display was on and showing message preview, clear it
+      if (_origin[0] && _msg[0]) {
+        clearMsgPreview();
+      } else {
+        // Otherwise, refresh the display
+        _need_refresh = true;
+      }
+    }
+    // Note: Display turn-on and auto-off timer extension are handled by handleButtonAnyPress
+  }
+}
+
+void UITask::handleButtonDoublePress() {
+  MESH_DEBUG_PRINTLN("UITask: double press triggered, sending advert");
+  // ADVERT
+  #ifdef PIN_BUZZER
+      soundBuzzer(UIEventType::ack);
+  #endif
+  if (the_mesh.advert()) {
+    MESH_DEBUG_PRINTLN("Advert sent!");
+    sprintf(_alert, "Advert sent!");
+  } else {
+    MESH_DEBUG_PRINTLN("Advert failed!");
+    sprintf(_alert, "Advert failed..");
+  }
+  _need_refresh = true;
+}
+
+void UITask::handleButtonTriplePress() {
+  MESH_DEBUG_PRINTLN("UITask: triple press triggered");
+  // Toggle buzzer quiet mode
+  #ifdef PIN_BUZZER
+    if (buzzer.isQuiet()) {
+      buzzer.quiet(false);
+      soundBuzzer(UIEventType::ack);
+    } else {
+      soundBuzzer(UIEventType::ack);
+      buzzer.quiet(true);
+    }
+  #endif
+}
+
+void UITask::handleButtonLongPress() {
+  MESH_DEBUG_PRINTLN("UITask: long press triggered");
+  if (millis() - ui_started_at < 8000) {   // long press in first 8 seconds since startup -> CLI/rescue
+    the_mesh.enterCLIRescue();
+  } else {
+    shutdown();
+  }
+}

examples/companion_radio/UITask.h

@@ -9,6 +9,7 @@
 #endif
 
 #include "NodePrefs.h"
+#include "Button.h"
 
  enum class UIEventType
 {
@@ -16,7 +17,8 @@
     contactMessage,
     channelMessage,
     roomMessage,
-    newContactMessage
+    newContactMessage,
+    ack
 };
 
 class UITask {
@@ -27,27 +29,41 @@ class UITask {
 #endif
   unsigned long _next_refresh, _auto_off;
   bool _connected;
-  uint32_t _pin_code;
   NodePrefs* _node_prefs;
   char _version_info[32];
   char _origin[62];
   char _msg[80];
+  char _alert[80];
   int _msgcount;
   bool _need_refresh = true;
+  bool _displayWasOn = false;  // Track display state before button press
+  unsigned long ui_started_at;
+
+  // Button handlers
+#if defined(PIN_USER_BTN) || defined(PIN_USER_BTN_ANA)
+  Button* _userButton = nullptr;
+#endif
 
   void renderCurrScreen();
-  void buttonHandler();
   void userLedHandler();
   void renderBatteryIndicator(uint16_t batteryMilliVolts);
+  
+  // Button action handlers
+  void handleButtonAnyPress();
+  void handleButtonShortPress();
+  void handleButtonDoublePress();
+  void handleButtonTriplePress();
+  void handleButtonLongPress();
 
  
 public:
 
   UITask(mesh::MainBoard* board) : _board(board), _display(NULL) {
-      _next_refresh = 0; 
+      _next_refresh = 0;
+      ui_started_at = 0;
       _connected = false;
   }
-  void begin(DisplayDriver* display, NodePrefs* node_prefs, const char* build_date, const char* firmware_version, uint32_t pin_code);
+  void begin(DisplayDriver* display, NodePrefs* node_prefs);
 
   void setHasConnection(bool connected) { _connected = connected; }
   bool hasDisplay() const { return _display != NULL; }
@@ -55,5 +71,6 @@ public:
   void msgRead(int msgcount);
   void newMsg(uint8_t path_len, const char* from_name, const char* text, int msgcount);
   void soundBuzzer(UIEventType bet = UIEventType::none);
+  void shutdown(bool restart = false);
   void loop();
 };

examples/simple_repeater/main.cpp

@@ -22,11 +22,11 @@
 /* ------------------------------ Config -------------------------------- */
 
 #ifndef FIRMWARE_BUILD_DATE
-  #define FIRMWARE_BUILD_DATE   "24 May 2025"
+  #define FIRMWARE_BUILD_DATE   "7 Jun 2025"
 #endif
 
 #ifndef FIRMWARE_VERSION
-  #define FIRMWARE_VERSION   "v1.6.2"
+  #define FIRMWARE_VERSION   "v1.7.0"
 #endif
 
 #ifndef LORA_FREQ
@@ -59,6 +59,14 @@
   #define  ADMIN_PASSWORD  "password"
 #endif
 
+#ifndef SERVER_RESPONSE_DELAY
+  #define SERVER_RESPONSE_DELAY   300
+#endif
+
+#ifndef TXT_ACK_DELAY
+  #define TXT_ACK_DELAY     200
+#endif
+
 #ifdef DISPLAY_CLASS
   #include "UITask.h"
   static UITask ui_task(display);
@@ -79,7 +87,7 @@
 struct RepeaterStats {
   uint16_t batt_milli_volts;
   uint16_t curr_tx_queue_len;
-  uint16_t curr_free_queue_len;
+  int16_t  noise_floor;
   int16_t  last_rssi;
   uint32_t n_packets_recv;
   uint32_t n_packets_sent;
@@ -112,8 +120,7 @@ struct NeighbourInfo {
   int8_t snr; // multiplied by 4, user should divide to get float value
 };
 
-// NOTE: need to space the ACK and the reply text apart (in CLI)
-#define CLI_REPLY_DELAY_MILLIS  1500
+#define CLI_REPLY_DELAY_MILLIS  1000
 
 class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
   FILESYSTEM* _fs;
@@ -183,7 +190,7 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
         RepeaterStats stats;
         stats.batt_milli_volts = board.getBattMilliVolts();
         stats.curr_tx_queue_len = _mgr->getOutboundCount(0xFFFFFFFF);
-        stats.curr_free_queue_len = _mgr->getFreeCount();
+        stats.noise_floor = (int16_t)_radio->getNoiseFloor();
         stats.last_rssi = (int16_t) radio_driver.getLastRSSI();
         stats.n_packets_recv = radio_driver.getPacketsRecv();
         stats.n_packets_sent = radio_driver.getPacketsSent();
@@ -327,6 +334,9 @@ protected:
     uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
     return getRNG()->nextInt(0, 6)*t;
   }
+  int getInterferenceThreshold() const override {
+    return _prefs.interference_threshold;
+  }
 
   void onAnonDataRecv(mesh::Packet* packet, uint8_t type, const mesh::Identity& sender, uint8_t* data, size_t len) override {
     if (type == PAYLOAD_TYPE_ANON_REQ) {  // received an initial request by a possible admin client (unknown at this stage)
@@ -373,14 +383,14 @@ protected:
         // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
         mesh::Packet* path = createPathReturn(sender, client->secret, packet->path, packet->path_len,
                                               PAYLOAD_TYPE_RESPONSE, reply_data, 12);
-        if (path) sendFlood(path);
+        if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
       } else {
         mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, client->secret, reply_data, 12);
         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);
+            sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
           } else {
-            sendFlood(reply);
+            sendFlood(reply, SERVER_RESPONSE_DELAY);
           }
         }
       }
@@ -443,14 +453,14 @@ protected:
           // 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);
+          if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
         } 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);
+              sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
             } else {
-              sendFlood(reply);
+              sendFlood(reply, SERVER_RESPONSE_DELAY);
             }
           }
         }
@@ -479,9 +489,9 @@ protected:
           mesh::Packet* ack = createAck(ack_hash);
           if (ack) {
             if (client->out_path_len < 0) {
-              sendFlood(ack);
+              sendFlood(ack, TXT_ACK_DELAY);
             } else {
-              sendDirect(ack, client->out_path, client->out_path_len);
+              sendDirect(ack, client->out_path, client->out_path_len, TXT_ACK_DELAY);
             }
           }
         }
@@ -565,6 +575,7 @@ public:
     _prefs.advert_interval = 1;  // default to 2 minutes for NEW installs
     _prefs.flood_advert_interval = 3;   // 3 hours
     _prefs.flood_max = 64;
+    _prefs.interference_threshold = 14;  // DB
   }
 
   CommonCLI* getCLI() { return &_cli; }

examples/simple_room_server/main.cpp

@@ -22,11 +22,11 @@
 /* ------------------------------ Config -------------------------------- */
 
 #ifndef FIRMWARE_BUILD_DATE
-  #define FIRMWARE_BUILD_DATE   "24 May 2025"
+  #define FIRMWARE_BUILD_DATE   "7 Jun 2025"
 #endif
 
 #ifndef FIRMWARE_VERSION
-  #define FIRMWARE_VERSION   "v1.6.2"
+  #define FIRMWARE_VERSION   "v1.7.0"
 #endif
 
 #ifndef LORA_FREQ
@@ -67,6 +67,14 @@
   #define MAX_UNSYNCED_POSTS    32
 #endif
 
+#ifndef SERVER_RESPONSE_DELAY
+  #define SERVER_RESPONSE_DELAY   300
+#endif
+
+#ifndef TXT_ACK_DELAY
+  #define TXT_ACK_DELAY     200
+#endif
+
 #ifdef DISPLAY_CLASS
   #include "UITask.h"
   static UITask ui_task(display);
@@ -126,7 +134,7 @@ struct PostInfo {
 struct ServerStats {
   uint16_t batt_milli_volts;
   uint16_t curr_tx_queue_len;
-  uint16_t curr_free_queue_len;
+  int16_t  noise_floor;
   int16_t  last_rssi;
   uint32_t n_packets_recv;
   uint32_t n_packets_sent;
@@ -204,7 +212,10 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
   void pushPostToClient(ClientInfo* client, PostInfo& post) {
     int len = 0;
     memcpy(&reply_data[len], &post.post_timestamp, 4); len += 4;   // this is a PAST timestamp... but should be accepted by client
-    reply_data[len++] = (TXT_TYPE_SIGNED_PLAIN << 2);  // 'signed' plain text
+
+    uint8_t attempt;
+    getRNG()->random(&attempt, 1);   // need this for re-tries, so packet hash (and ACK) will be different
+    reply_data[len++] = (TXT_TYPE_SIGNED_PLAIN << 2) | (attempt & 3);  // 'signed' plain text
 
     // encode prefix of post.author.pub_key
     memcpy(&reply_data[len], post.author.pub_key, 4); len += 4;   // just first 4 bytes
@@ -287,7 +298,7 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
         ServerStats stats;
         stats.batt_milli_volts = board.getBattMilliVolts();
         stats.curr_tx_queue_len = _mgr->getOutboundCount(0xFFFFFFFF);
-        stats.curr_free_queue_len = _mgr->getFreeCount();
+        stats.noise_floor = (int16_t)_radio->getNoiseFloor();
         stats.last_rssi = (int16_t) radio_driver.getLastRSSI();
         stats.n_packets_recv = radio_driver.getPacketsRecv();
         stats.n_packets_sent = radio_driver.getPacketsSent();
@@ -406,6 +417,9 @@ protected:
     uint32_t t = (_radio->getEstAirtimeFor(packet->path_len + packet->payload_len + 2) * _prefs.direct_tx_delay_factor);
     return getRNG()->nextInt(0, 6)*t;
   }
+  int getInterferenceThreshold() const override {
+    return _prefs.interference_threshold;
+  }
 
   bool allowPacketForward(const mesh::Packet* packet) override {
     if (_prefs.disable_fwd) return false;
@@ -465,14 +479,14 @@ protected:
         // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
         mesh::Packet* path = createPathReturn(sender, client->secret, packet->path, packet->path_len,
                                               PAYLOAD_TYPE_RESPONSE, reply_data, 8 + 2);
-        if (path) sendFlood(path);
+        if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
       } else {
         mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, client->secret, reply_data, 8 + 2);
         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);
+            sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
           } else {
-            sendFlood(reply);
+            sendFlood(reply, SERVER_RESPONSE_DELAY);
           }
         }
       }
@@ -562,12 +576,12 @@ protected:
           mesh::Packet* ack = createAck(ack_hash);
           if (ack) {
             if (client->out_path_len < 0) {
-              sendFlood(ack);
+              sendFlood(ack, TXT_ACK_DELAY);
             } else {
-              sendDirect(ack, client->out_path, client->out_path_len);
+              sendDirect(ack, client->out_path, client->out_path_len, TXT_ACK_DELAY);
             }
           }
-          delay_millis = REPLY_DELAY_MILLIS;
+          delay_millis = TXT_ACK_DELAY + REPLY_DELAY_MILLIS;
         } else {
           delay_millis = 0;
         }
@@ -586,9 +600,9 @@ protected:
           auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, secret, temp, 5 + text_len);
           if (reply) {
             if (client->out_path_len < 0) {
-              sendFlood(reply, delay_millis);
+              sendFlood(reply, delay_millis + SERVER_RESPONSE_DELAY);
             } else {
-              sendDirect(reply, client->out_path, client->out_path_len, delay_millis);
+              sendDirect(reply, client->out_path, client->out_path_len, delay_millis + SERVER_RESPONSE_DELAY);
             }
           }
         }
@@ -631,7 +645,7 @@ protected:
             auto reply = createAck(ack_hash);
             if (reply) {
               reply->payload[reply->payload_len++] = getUnsyncedCount(client);  // NEW: add unsynced counter to end of ACK packet
-              sendDirect(reply, client->out_path, client->out_path_len);
+              sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
             }
           }
         } else {
@@ -641,14 +655,14 @@ protected:
               // 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);
+              if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
             } 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);
+                  sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
                 } else {
-                  sendFlood(reply);
+                  sendFlood(reply, SERVER_RESPONSE_DELAY);
                 }
               }
             }
@@ -711,6 +725,7 @@ public:
     _prefs.advert_interval = 1;  // default to 2 minutes for NEW installs
     _prefs.flood_advert_interval = 3;   // 3 hours
     _prefs.flood_max = 64;
+    _prefs.interference_threshold = 14;  // DB
   #ifdef ROOM_PASSWORD
     StrHelper::strncpy(_prefs.guest_password, ROOM_PASSWORD, sizeof(_prefs.guest_password));
   #endif

logo/meshcore.svg

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="100%" height="100%" viewBox="0 0 134 15" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
+    <path d="M3.277,0.053C2.829,0.053 2.401,0.41 2.321,0.851L0.013,13.623C-0.067,14.064 0.232,14.421 0.681,14.421L3.13,14.421C3.578,14.421 4.006,14.064 4.086,13.623L5.004,8.54L6.684,13.957C6.766,14.239 7.02,14.421 7.337,14.421L10.58,14.421C10.897,14.421 11.217,14.239 11.401,13.957L15.043,8.513L14.119,13.623C14.038,14.064 14.338,14.421 14.787,14.421L17.236,14.421C17.684,14.421 18.112,14.064 18.192,13.623L20.5,0.851C20.582,0.41 20.283,0.053 19.834,0.053L16.69,0.053C16.373,0.053 16.053,0.235 15.87,0.517L9.897,9.473C9.803,9.616 9.578,9.578 9.528,9.41L7.074,0.517C6.992,0.235 6.738,0.053 6.421,0.053L3.277,0.053Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M21.146,14.421C21.146,14.421 33.257,14.421 33.257,14.421C33.526,14.421 33.784,14.205 33.831,13.942L34.337,11.128C34.385,10.863 34.206,10.649 33.936,10.649L25.519,10.649C25.429,10.649 25.37,10.576 25.385,10.488L25.635,9.105C25.65,9.017 25.736,8.944 25.826,8.944L32.596,8.944C32.865,8.944 33.123,8.728 33.171,8.465L33.621,5.974C33.669,5.709 33.49,5.495 33.221,5.495L26.45,5.495C26.361,5.495 26.301,5.423 26.317,5.335L26.584,3.852C26.599,3.764 26.685,3.691 26.775,3.691L35.192,3.691C35.462,3.691 35.719,3.476 35.767,3.21L36.258,0.498C36.306,0.235 36.126,0.019 35.857,0.019L23.746,0.019C23.297,0.019 22.867,0.378 22.788,0.819L20.474,13.621C20.396,14.062 20.695,14.421 21.146,14.421Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M45.926,14.419L45.926,14.421L46.346,14.421C48.453,14.421 50.465,12.742 50.839,10.67L51.081,9.327C51.456,7.256 50.05,5.576 47.943,5.576L41.455,5.576C41.186,5.576 41.007,5.363 41.054,5.097L41.218,4.192C41.266,3.927 41.524,3.713 41.793,3.713L50.569,3.713C51.018,3.713 51.446,3.356 51.526,2.915L51.9,0.85C51.98,0.407 51.68,0.05 51.232,0.05L41.638,0.05C39.531,0.05 37.519,1.73 37.145,3.801L36.88,5.267C36.505,7.339 37.91,9.018 40.018,9.018L46.506,9.018C46.775,9.018 46.954,9.231 46.907,9.497L46.785,10.176C46.737,10.441 46.479,10.655 46.21,10.655L37.189,10.655C36.741,10.655 36.313,11.012 36.233,11.453L35.841,13.621C35.761,14.062 36.061,14.419 36.51,14.419L45.926,14.419Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M68.008,0.046C68.008,0.046 65.296,0.046 65.296,0.046C64.847,0.046 64.42,0.403 64.34,0.844L63.532,5.31C63.517,5.398 63.431,5.469 63.341,5.469L58.085,5.469C57.995,5.469 57.936,5.398 57.951,5.31L58.758,0.844C58.837,0.403 58.539,0.046 58.09,0.046L55.378,0.046C54.93,0.046 54.502,0.403 54.422,0.844L52.112,13.623C52.032,14.064 52.331,14.421 52.78,14.421L55.492,14.421C55.941,14.421 56.369,14.064 56.449,13.623L57.272,9.074C57.287,8.986 57.373,8.914 57.462,8.914L62.719,8.914C62.809,8.914 62.868,8.985 62.853,9.074L62.032,13.623C61.952,14.064 62.252,14.421 62.7,14.421L65.413,14.421C65.861,14.421 66.289,14.064 66.369,13.623L68.678,0.844C68.755,0.403 68.457,0.046 68.008,0.046Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M72.099,14.421C72.099,14.421 80.066,14.421 80.066,14.421C80.515,14.421 80.943,14.064 81.022,13.623L81.414,11.453C81.494,11.012 81.194,10.655 80.746,10.655L73.828,10.655C73.559,10.655 73.38,10.441 73.427,10.176L74.51,4.215C74.558,3.951 74.815,3.736 75.082,3.736L82,3.736C82.448,3.736 82.876,3.379 82.956,2.938L83.34,0.817C83.42,0.376 83.12,0.019 82.672,0.019L74.724,0.019C72.622,0.019 70.614,1.691 70.236,3.757L68.965,10.665C68.587,12.738 69.99,14.421 72.099,14.421Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M97.176,-0C97.176,0 88.882,0 88.882,0C86.775,0 84.763,1.68 84.389,3.751L83.139,10.67C82.765,12.741 84.169,14.421 86.277,14.421L94.571,14.421C96.678,14.421 98.69,12.741 99.064,10.67L100.314,3.751C100.689,1.68 99.284,-0 97.176,-0ZM94.798,10.178C94.75,10.443 94.492,10.657 94.223,10.657L87.978,10.657C87.709,10.657 87.529,10.443 87.577,10.178L88.659,4.192C88.707,3.927 88.964,3.713 89.234,3.713L95.477,3.713C95.747,3.713 95.926,3.927 95.878,4.192L94.798,10.178Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M101.284,14.421L103.995,14.421C104.443,14.421 104.871,14.065 104.951,13.624L105.43,10.97C105.446,10.882 105.531,10.81 105.621,10.81L108.902,10.806C109.064,10.806 109.2,10.886 109.267,11.018L110.813,14.035C110.992,14.392 111.319,14.434 112.303,14.419C112.88,14.426 113.756,14.382 115.169,14.382C115.623,14.382 115.902,13.907 115.678,13.51L113.989,10.569C113.945,10.491 113.993,10.386 114.086,10.34C115.39,9.707 116.423,8.477 116.681,7.055L117.27,3.785C117.646,1.713 116.242,0.033 114.134,0.033L103.884,0.033C103.436,0.033 103.008,0.39 102.928,0.831L100.616,13.623C100.536,14.064 100.836,14.421 101.284,14.421L101.284,14.421ZM106.73,3.791C106.745,3.703 106.831,3.631 106.921,3.631L112.225,3.631C112.626,3.631 112.891,3.949 112.821,4.343L112.431,6.494C112.359,6.885 111.979,7.204 111.58,7.204L106.276,7.204C106.186,7.204 106.127,7.133 106.142,7.043L106.73,3.791Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M118.277,14.421C118.277,14.421 130.388,14.421 130.388,14.421C130.657,14.421 130.915,14.205 130.963,13.942L131.468,11.128C131.516,10.863 131.337,10.649 131.068,10.649L122.65,10.649C122.56,10.649 122.501,10.576 122.516,10.488L122.766,9.105C122.781,9.017 122.867,8.944 122.957,8.944L129.728,8.944C129.997,8.944 130.254,8.728 130.302,8.465L130.753,5.974C130.801,5.709 130.621,5.495 130.352,5.495L123.581,5.495C123.492,5.495 123.432,5.423 123.448,5.335L123.715,3.852C123.73,3.764 123.816,3.691 123.906,3.691L132.324,3.691C132.593,3.691 132.851,3.476 132.898,3.21L133.389,0.498C133.437,0.235 133.257,0.019 132.988,0.019L120.877,0.019C120.428,0.019 119.999,0.378 119.919,0.819L117.605,13.621C117.527,14.062 117.827,14.421 118.277,14.421Z" style="fill:white;fill-rule:nonzero;"/>
+</svg>

logo/meshcore_tm.svg

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="100%" height="100%" viewBox="0 0 139 18" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
+    <path d="M3.232,3.582C2.789,3.582 2.368,3.934 2.289,4.369L0.013,16.964C-0.066,17.399 0.229,17.751 0.671,17.751L3.087,17.751C3.529,17.751 3.951,17.399 4.03,16.964L4.935,11.951L6.592,17.293C6.672,17.572 6.923,17.751 7.235,17.751L10.434,17.751C10.746,17.751 11.062,17.572 11.243,17.293L14.835,11.925L13.924,16.964C13.844,17.399 14.14,17.751 14.583,17.751L16.998,17.751C17.44,17.751 17.862,17.399 17.941,16.964L20.217,4.369C20.298,3.934 20.002,3.582 19.56,3.582L16.46,3.582C16.147,3.582 15.831,3.761 15.65,4.04L9.76,12.872C9.668,13.013 9.446,12.975 9.397,12.81L6.976,4.04C6.895,3.761 6.645,3.582 6.332,3.582L3.232,3.582Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M20.853,17.751C20.853,17.751 32.797,17.751 32.797,17.751C33.063,17.751 33.317,17.538 33.364,17.278L33.863,14.504C33.91,14.242 33.733,14.031 33.467,14.031L25.166,14.031C25.077,14.031 25.019,13.96 25.034,13.873L25.281,12.508C25.296,12.421 25.38,12.35 25.469,12.35L32.146,12.35C32.411,12.35 32.665,12.137 32.712,11.877L33.157,9.421C33.204,9.159 33.027,8.949 32.761,8.949L26.085,8.949C25.996,8.949 25.938,8.877 25.953,8.79L26.216,7.328C26.232,7.241 26.316,7.17 26.405,7.17L34.706,7.17C34.971,7.17 35.226,6.957 35.272,6.695L35.756,4.021C35.804,3.761 35.627,3.548 35.361,3.548L23.417,3.548C22.975,3.548 22.551,3.902 22.473,4.337L20.191,16.962C20.114,17.397 20.409,17.751 20.853,17.751Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M45.291,17.749L45.291,17.751L45.705,17.751C47.783,17.751 49.767,16.095 50.136,14.052L50.375,12.727C50.744,10.685 49.359,9.029 47.28,9.029L40.882,9.029C40.617,9.029 40.44,8.818 40.487,8.556L40.649,7.664C40.696,7.402 40.95,7.191 41.215,7.191L49.87,7.191C50.313,7.191 50.735,6.839 50.814,6.404L51.183,4.368C51.262,3.931 50.966,3.579 50.523,3.579L41.063,3.579C38.985,3.579 37,5.235 36.631,7.278L36.37,8.723C36.001,10.767 37.386,12.422 39.465,12.422L45.863,12.422C46.128,12.422 46.305,12.633 46.258,12.895L46.138,13.565C46.091,13.826 45.837,14.037 45.571,14.037L36.675,14.037C36.233,14.037 35.811,14.389 35.732,14.824L35.346,16.962C35.267,17.397 35.562,17.749 36.005,17.749L45.291,17.749Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M67.068,3.575C67.068,3.575 64.393,3.575 64.393,3.575C63.951,3.575 63.529,3.927 63.45,4.361L62.654,8.766C62.639,8.853 62.554,8.923 62.466,8.923L57.282,8.923C57.193,8.923 57.135,8.853 57.15,8.766L57.946,4.361C58.023,3.927 57.73,3.575 57.287,3.575L54.613,3.575C54.17,3.575 53.748,3.927 53.669,4.361L51.392,16.964C51.313,17.399 51.608,17.751 52.05,17.751L54.725,17.751C55.168,17.751 55.589,17.399 55.668,16.964L56.48,12.478C56.495,12.392 56.58,12.32 56.668,12.32L61.852,12.32C61.941,12.32 61.999,12.39 61.984,12.478L61.174,16.964C61.096,17.399 61.391,17.751 61.834,17.751L64.508,17.751C64.951,17.751 65.372,17.399 65.451,16.964L67.729,4.361C67.804,3.927 67.511,3.575 67.068,3.575Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M71.102,17.751C71.102,17.751 78.96,17.751 78.96,17.751C79.402,17.751 79.824,17.399 79.903,16.964L80.288,14.824C80.367,14.389 80.072,14.037 79.629,14.037L72.808,14.037C72.542,14.037 72.365,13.826 72.412,13.565L73.48,7.686C73.527,7.426 73.781,7.213 74.045,7.213L80.866,7.213C81.309,7.213 81.73,6.861 81.81,6.427L82.188,4.335C82.267,3.9 81.971,3.548 81.529,3.548L73.691,3.548C71.618,3.548 69.638,5.197 69.265,7.234L68.011,14.046C67.639,16.091 69.022,17.751 71.102,17.751Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M95.833,3.529C95.833,3.529 87.654,3.529 87.654,3.529C85.576,3.529 83.592,5.186 83.223,7.228L81.99,14.052C81.621,16.094 83.006,17.751 85.084,17.751L93.263,17.751C95.341,17.751 97.326,16.095 97.695,14.052L98.928,7.228C99.297,5.186 97.911,3.529 95.833,3.529ZM93.488,13.567C93.44,13.828 93.186,14.039 92.921,14.039L86.762,14.039C86.496,14.039 86.319,13.828 86.366,13.567L87.434,7.663C87.481,7.402 87.735,7.191 88,7.191L94.157,7.191C94.423,7.191 94.6,7.402 94.553,7.663L93.488,13.567Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M99.884,17.751L102.557,17.751C102.999,17.751 103.421,17.399 103.5,16.965L103.973,14.348C103.988,14.261 104.073,14.19 104.161,14.19L107.397,14.186C107.557,14.186 107.69,14.265 107.756,14.395L109.281,17.37C109.458,17.722 109.78,17.764 110.751,17.749C111.32,17.756 112.184,17.713 113.577,17.713C114.025,17.713 114.3,17.244 114.079,16.853L112.413,13.953C112.37,13.876 112.417,13.772 112.509,13.727C113.795,13.102 114.814,11.889 115.068,10.487L115.649,7.262C116.02,5.218 114.635,3.562 112.557,3.562L102.448,3.562C102.006,3.562 101.584,3.914 101.505,4.349L99.225,16.964C99.146,17.399 99.442,17.751 99.884,17.751L99.884,17.751ZM105.255,7.268C105.27,7.181 105.354,7.11 105.443,7.11L110.674,7.11C111.069,7.11 111.331,7.424 111.261,7.812L110.877,9.933C110.806,10.319 110.431,10.634 110.038,10.634L104.806,10.634C104.718,10.634 104.66,10.564 104.675,10.475L105.255,7.268Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M116.642,17.751C116.642,17.751 128.586,17.751 128.586,17.751C128.851,17.751 129.105,17.538 129.152,17.278L129.651,14.504C129.698,14.242 129.521,14.031 129.256,14.031L120.955,14.031C120.866,14.031 120.808,13.96 120.823,13.873L121.069,12.508C121.084,12.421 121.169,12.35 121.257,12.35L127.934,12.35C128.2,12.35 128.454,12.137 128.501,11.877L128.945,9.421C128.992,9.159 128.815,8.949 128.55,8.949L121.873,8.949C121.785,8.949 121.726,8.877 121.741,8.79L122.005,7.328C122.02,7.241 122.105,7.17 122.193,7.17L130.495,7.17C130.76,7.17 131.014,6.957 131.061,6.695L131.545,4.021C131.592,3.761 131.415,3.548 131.15,3.548L119.206,3.548C118.763,3.548 118.34,3.902 118.261,4.337L115.98,16.962C115.902,17.397 116.198,17.751 116.642,17.751Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M134.674,0C134.674,0 132.059,0 132.059,0C131.965,0 131.877,0.074 131.86,0.166L131.783,0.594C131.766,0.686 131.828,0.76 131.921,0.76L132.745,0.76C132.764,0.76 132.776,0.775 132.773,0.793L132.406,2.819C132.39,2.91 132.452,2.984 132.545,2.984L133.108,2.984C133.201,2.984 133.29,2.91 133.307,2.819L133.673,0.793C133.676,0.775 133.694,0.76 133.713,0.76L134.536,0.76C134.629,0.76 134.718,0.686 134.735,0.594L134.812,0.166C134.828,0.074 134.767,0 134.674,0Z" style="fill:white;fill-rule:nonzero;"/>
+    <path d="M135.278,0.002C135.185,0.002 135.096,0.076 135.079,0.167L134.6,2.819C134.583,2.91 134.646,2.984 134.739,2.984L135.247,2.984C135.34,2.984 135.429,2.91 135.446,2.819L135.636,1.763L135.985,2.888C136.002,2.947 136.055,2.984 136.121,2.984L136.794,2.984C136.86,2.984 136.926,2.947 136.964,2.888L137.72,1.758L137.528,2.819C137.512,2.91 137.574,2.984 137.667,2.984L138.176,2.984C138.269,2.984 138.358,2.91 138.374,2.819L138.853,0.167C138.87,0.076 138.808,0.002 138.715,0.002L138.062,0.002C137.997,0.002 137.93,0.039 137.892,0.098L136.652,1.957C136.633,1.987 136.586,1.979 136.575,1.944L136.066,0.098C136.049,0.039 135.996,0.002 135.93,0.002L135.278,0.002Z" style="fill:white;fill-rule:nonzero;"/>
+</svg>

platformio.ini

@@ -27,6 +27,8 @@ build_flags = -w -DNDEBUG -DRADIOLIB_STATIC_ONLY=1 -DRADIOLIB_GODMODE=1
   -D LORA_FREQ=869.525
   -D LORA_BW=250
   -D LORA_SF=11
+  -D ENABLE_PRIVATE_KEY_IMPORT=1   ; NOTE: comment these out for more secure firmware
+  -D ENABLE_PRIVATE_KEY_EXPORT=1
 build_src_filter =
   +<*.cpp>
   +<helpers/*.cpp>
@@ -54,6 +56,7 @@ extends = arduino_base
 platform = nordicnrf52
 build_flags = ${arduino_base.build_flags}
   -D NRF52_PLATFORM
+  -D LFS_NO_ASSERT=1
 
 [nrf52840_base]
 extends = nrf52_base
@@ -83,4 +86,4 @@ build_flags = ${arduino_base.build_flags}
 build_src_filter = ${arduino_base.build_src_filter}
   +<helpers/stm32>
 lib_deps = ${arduino_base.lib_deps}
-  file://arch/stm32/Adafruit_LittleFS_stm32
+  file://arch/stm32/Adafruit_LittleFS_stm32

src/Dispatcher.cpp

@@ -10,6 +10,10 @@ namespace mesh {
 
 #define MAX_RX_DELAY_MILLIS   32000  // 32 seconds
 
+#ifndef NOISE_FLOOR_CALIB_INTERVAL
+  #define NOISE_FLOOR_CALIB_INTERVAL   2000     // 2 seconds
+#endif
+
 void Dispatcher::begin() {
   n_sent_flood = n_sent_direct = 0;
   n_recv_flood = n_recv_direct = 0;
@@ -36,6 +40,12 @@ uint32_t Dispatcher::getCADFailMaxDuration() const {
 }
 
 void Dispatcher::loop() {
+  if (millisHasNowPassed(next_floor_calib_time)) {
+    _radio->triggerNoiseFloorCalibrate(getInterferenceThreshold());
+    next_floor_calib_time = futureMillis(NOISE_FLOOR_CALIB_INTERVAL);
+  }
+  _radio->loop();
+
   // check for radio 'stuck' in mode other than Rx
   bool is_recv = _radio->isInRecvMode();
   if (is_recv != prev_isrecv_mode) {

src/Dispatcher.h

@@ -56,6 +56,15 @@ public:
   */
   virtual void onSendFinished() = 0;
 
+  /**
+   * \brief  do any processing needed on each loop cycle
+   */
+  virtual void loop() { }
+
+  virtual int getNoiseFloor() const { return 0; }
+
+  virtual void triggerNoiseFloorCalibrate(int threshold) { }
+
   virtual bool isInRecvMode() const = 0;
 
   /**
@@ -107,6 +116,7 @@ class Dispatcher {
   unsigned long next_tx_time;
   unsigned long cad_busy_start;
   unsigned long radio_nonrx_start;
+  unsigned long next_floor_calib_time;
   bool  prev_isrecv_mode;
   uint32_t n_sent_flood, n_sent_direct;
   uint32_t n_recv_flood, n_recv_direct;
@@ -124,6 +134,7 @@ protected:
   {
     outbound = NULL; total_air_time = 0; next_tx_time = 0;
     cad_busy_start = 0;
+    next_floor_calib_time = 0;
     _err_flags = 0;
     radio_nonrx_start = 0;
     prev_isrecv_mode = true;
@@ -142,6 +153,7 @@ protected:
   virtual int calcRxDelay(float score, uint32_t air_time) const;
   virtual uint32_t getCADFailRetryDelay() const;
   virtual uint32_t getCADFailMaxDuration() const;
+  virtual int getInterferenceThreshold() const { return 0; }    // disabled by default
 
 public:
   void begin();

src/Mesh.cpp

@@ -142,7 +142,7 @@ DispatcherAction Mesh::onRecvPacket(Packet* pkt) {
                   if (pkt->isRouteFlood()) {
                     // send a reciprocal return path to sender, but send DIRECTLY!
                     mesh::Packet* rpath = createPathReturn(&src_hash, secret, pkt->path, pkt->path_len, 0, NULL, 0);
-                    if (rpath) sendDirect(rpath, path, path_len);
+                    if (rpath) sendDirect(rpath, path, path_len, 500);
                   }
                 }
               } else {
@@ -518,7 +518,11 @@ void Mesh::sendDirect(Packet* packet, const uint8_t* path, uint8_t path_len, uin
     pri = 5;   // maybe make this configurable
   } else {
     memcpy(packet->path, path, packet->path_len = path_len);
-    pri = 0;
+    if (packet->getPayloadType() == PAYLOAD_TYPE_PATH) {
+      pri = 1;   // slightly less priority
+    } else {
+      pri = 0;
+    }
   }
   _tables->hasSeen(packet); // mark this packet as already sent in case it is rebroadcast back to us
   sendPacket(packet, pri, delay_millis);

src/helpers/BaseChatMesh.cpp

@@ -1,6 +1,14 @@
 #include <helpers/BaseChatMesh.h>
 #include <Utils.h>
 
+#ifndef SERVER_RESPONSE_DELAY
+  #define SERVER_RESPONSE_DELAY   300
+#endif
+
+#ifndef TXT_ACK_DELAY
+  #define TXT_ACK_DELAY     200
+#endif
+
 mesh::Packet* BaseChatMesh::createSelfAdvert(const char* name, double lat, double lon) {
   uint8_t app_data[MAX_ADVERT_DATA_SIZE];
   uint8_t app_data_len;
@@ -131,14 +139,14 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
         // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the ACK
         mesh::Packet* path = createPathReturn(from.id, secret, packet->path, packet->path_len,
                                                 PAYLOAD_TYPE_ACK, (uint8_t *) &ack_hash, 4);
-        if (path) sendFlood(path);
+        if (path) sendFlood(path, TXT_ACK_DELAY);
       } else {
         mesh::Packet* ack = createAck(ack_hash);
         if (ack) {
           if (from.out_path_len < 0) {
-            sendFlood(ack);
+            sendFlood(ack, TXT_ACK_DELAY);
           } else {
-            sendDirect(ack, from.out_path, from.out_path_len);
+            sendDirect(ack, from.out_path, from.out_path_len, TXT_ACK_DELAY);
           }
         }
       }
@@ -164,14 +172,14 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
         // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the ACK
         mesh::Packet* path = createPathReturn(from.id, secret, packet->path, packet->path_len,
                                                 PAYLOAD_TYPE_ACK, (uint8_t *) &ack_hash, 4);
-        if (path) sendFlood(path);
+        if (path) sendFlood(path, TXT_ACK_DELAY);
       } else {
         mesh::Packet* ack = createAck(ack_hash);
         if (ack) {
           if (from.out_path_len < 0) {
-            sendFlood(ack);
+            sendFlood(ack, TXT_ACK_DELAY);
           } else {
-            sendDirect(ack, from.out_path, from.out_path_len);
+            sendDirect(ack, from.out_path, from.out_path_len, TXT_ACK_DELAY);
           }
         }
       }
@@ -187,14 +195,14 @@ void BaseChatMesh::onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender
         // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
         mesh::Packet* path = createPathReturn(from.id, secret, packet->path, packet->path_len,
                                               PAYLOAD_TYPE_RESPONSE, temp_buf, reply_len);
-        if (path) sendFlood(path);
+        if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
       } else {
         mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, from.id, secret, temp_buf, reply_len);
         if (reply) {
           if (from.out_path_len >= 0) {  // we have an out_path, so send DIRECT
-            sendDirect(reply, from.out_path, from.out_path_len);
+            sendDirect(reply, from.out_path, from.out_path_len, SERVER_RESPONSE_DELAY);
           } else {
-            sendFlood(reply);
+            sendFlood(reply, SERVER_RESPONSE_DELAY);
           }
         }
       }
@@ -691,6 +699,13 @@ int BaseChatMesh::findChannelIdx(const mesh::GroupChannel& ch) {
 }
 #endif
 
+bool BaseChatMesh::getContactByIdx(uint32_t idx, ContactInfo& contact) {
+  if (idx >= num_contacts) return false;
+
+  contact = contacts[idx];
+  return true;
+}
+
 ContactsIterator BaseChatMesh::startContactsIterator() {
   return ContactsIterator();
 }

src/helpers/BaseChatMesh.h

@@ -7,19 +7,7 @@
 
 #define MAX_TEXT_LEN    (10*CIPHER_BLOCK_SIZE)  // must be LESS than (MAX_PACKET_PAYLOAD - 4 - CIPHER_MAC_SIZE - 1)
 
-struct ContactInfo {
-  mesh::Identity id;
-  char name[32];
-  uint8_t type;   // on of ADV_TYPE_*
-  uint8_t flags;
-  int8_t out_path_len;
-  uint8_t out_path[MAX_PATH_SIZE];
-  uint32_t last_advert_timestamp;   // by THEIR clock
-  uint8_t shared_secret[PUB_KEY_SIZE];
-  uint32_t lastmod;  // by OUR clock
-  int32_t gps_lat, gps_lon;    // 6 dec places
-  uint32_t sync_since;
-};
+#include "ContactInfo.h"
 
 #define MAX_SEARCH_RESULTS   8
 
@@ -61,10 +49,7 @@ struct ConnectionInfo {
   uint32_t expected_ack;
 };
 
-struct ChannelDetails {
-  mesh::GroupChannel channel;
-  char name[32];
-};
+#include "ChannelDetails.h"
 
 /**
  *  \brief  abstract Mesh class for common 'chat' client
@@ -158,6 +143,7 @@ public:
   bool  removeContact(ContactInfo& contact);
   bool  addContact(const ContactInfo& contact);
   int getNumContacts() const { return num_contacts; }
+  bool getContactByIdx(uint32_t idx, ContactInfo& contact);
   ContactsIterator startContactsIterator();
   ChannelDetails* addChannel(const char* name, const char* psk_base64);
   bool getChannel(int idx, ChannelDetails& dest);

src/helpers/ChannelDetails.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <Arduino.h>
+#include <Mesh.h>
+
+struct ChannelDetails {
+  mesh::GroupChannel channel;
+  char name[32];
+};

src/helpers/CommonCLI.cpp

@@ -56,6 +56,7 @@ void CommonCLI::loadPrefsInt(FILESYSTEM* fs, const char* filename) {
     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.read((uint8_t *) &_prefs->interference_threshold, sizeof(_prefs->interference_threshold));  // 126
 
     // sanitise bad pref values
     _prefs->rx_delay_base = constrain(_prefs->rx_delay_base, 0, 20.0f);
@@ -109,6 +110,7 @@ void CommonCLI::savePrefs(FILESYSTEM* fs) {
     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.write((uint8_t *) &_prefs->interference_threshold, sizeof(_prefs->interference_threshold));  // 126
 
     file.close();
   }
@@ -176,6 +178,8 @@ 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, "int.thresh", 10) == 0) {
+        sprintf(reply, "> %d", (uint32_t) _prefs->interference_threshold);
       } 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) {
@@ -223,6 +227,10 @@ 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, "int.thresh ", 11) == 0) {
+        _prefs->interference_threshold = atoi(&config[11]);
+        savePrefs();
+        strcpy(reply, "OK");
       } else if (memcmp(config, "allow.read.only ", 16) == 0) {
         _prefs->allow_read_only = memcmp(&config[16], "on", 2) == 0;
         savePrefs();

src/helpers/CommonCLI.h

@@ -24,6 +24,7 @@ struct NodePrefs {  // persisted to file
     uint8_t reserved2;
     float bw;
     uint8_t flood_max;
+    uint8_t interference_threshold;
 };
 
 class CommonCLICallbacks {

src/helpers/ContactInfo.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <Arduino.h>
+#include <Mesh.h>
+
+struct ContactInfo {
+  mesh::Identity id;
+  char name[32];
+  uint8_t type;   // on of ADV_TYPE_*
+  uint8_t flags;
+  int8_t out_path_len;
+  uint8_t out_path[MAX_PATH_SIZE];
+  uint32_t last_advert_timestamp;   // by THEIR clock
+  uint8_t shared_secret[PUB_KEY_SIZE];
+  uint32_t lastmod;  // by OUR clock
+  int32_t gps_lat, gps_lon;    // 6 dec places
+  uint32_t sync_since;
+};

src/helpers/CustomLLCC68Wrapper.h

@@ -6,18 +6,11 @@
 class CustomLLCC68Wrapper : public RadioLibWrapper {
 public:
   CustomLLCC68Wrapper(CustomLLCC68& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
-  bool isReceiving() override { 
-    if (((CustomLLCC68 *)_radio)->isReceiving()) return true;
-
-    idle();  // put sx126x into standby
-    // do some basic CAD (blocks for ~12780 micros (on SF 10)!)
-    bool activity = (((CustomLLCC68 *)_radio)->scanChannel() == RADIOLIB_LORA_DETECTED);
-    if (activity) {
-      startRecv();
-    } else {
-      idle();
-    }
-    return activity;
+  bool isReceivingPacket() override { 
+    return ((CustomLLCC68 *)_radio)->isReceiving();
+  }
+  float getCurrentRSSI() override {
+    return ((CustomLLCC68 *)_radio)->getRSSI(false);
   }
   float getLastRSSI() const override { return ((CustomLLCC68 *)_radio)->getRSSI(); }
   float getLastSNR() const override { return ((CustomLLCC68 *)_radio)->getSNR(); }

src/helpers/CustomLR1110Wrapper.h

@@ -6,18 +6,13 @@
 class CustomLR1110Wrapper : public RadioLibWrapper {
 public:
   CustomLR1110Wrapper(CustomLR1110& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
-  bool isReceiving() override { 
-    if (((CustomLR1110 *)_radio)->isReceiving()) return true;
-
-    idle();  // put sx126x into standby
-    // do some basic CAD (blocks for ~12780 micros (on SF 10)!)
-    bool activity = (((CustomLR1110 *)_radio)->scanChannel() == RADIOLIB_LORA_DETECTED);
-    if (activity) {
-      startRecv();
-    } else {
-      idle();
-    }
-    return activity;
+  bool isReceivingPacket() override { 
+    return ((CustomLR1110 *)_radio)->isReceiving();
+  }
+  float getCurrentRSSI() override {
+    float rssi = -110;
+    ((CustomLR1110 *)_radio)->getRssiInst(&rssi);
+    return rssi;
   }
 
   void onSendFinished() override {

src/helpers/CustomSTM32WLxWrapper.h

@@ -7,18 +7,11 @@
 class CustomSTM32WLxWrapper : public RadioLibWrapper {
 public:
   CustomSTM32WLxWrapper(CustomSTM32WLx& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
-  bool isReceiving() override { 
-    if (((CustomSTM32WLx *)_radio)->isReceiving()) return true;
-
-    idle();  // put sx126x into standby
-    // do some basic CAD (blocks for ~12780 micros (on SF 10)!)
-    bool activity = (((CustomSTM32WLx *)_radio)->scanChannel() == RADIOLIB_LORA_DETECTED);
-    if (activity) {
-      startRecv();
-    } else {
-      idle();
-    }
-    return activity;
+  bool isReceivingPacket() override { 
+    return ((CustomSTM32WLx *)_radio)->isReceiving();
+  }
+  float getCurrentRSSI() override {
+    return ((CustomSTM32WLx *)_radio)->getRSSI(false);
   }
   float getLastRSSI() const override { return ((CustomSTM32WLx *)_radio)->getRSSI(); }
   float getLastSNR() const override { return ((CustomSTM32WLx *)_radio)->getSNR(); }

src/helpers/CustomSX1262Wrapper.h

@@ -2,23 +2,15 @@
 
 #include "CustomSX1262.h"
 #include "RadioLibWrappers.h"
-#include <math.h>
 
 class CustomSX1262Wrapper : public RadioLibWrapper {
 public:
   CustomSX1262Wrapper(CustomSX1262& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
-  bool isReceiving() override { 
-    if (((CustomSX1262 *)_radio)->isReceiving()) return true;
-
-    idle();  // put sx126x into standby
-    // do some basic CAD (blocks for ~12780 micros (on SF 10)!)
-    bool activity = (((CustomSX1262 *)_radio)->scanChannel() == RADIOLIB_LORA_DETECTED);
-    if (activity) {
-      startRecv();
-    } else {
-      idle();
-    }
-    return activity;
+  bool isReceivingPacket() override { 
+    return ((CustomSX1262 *)_radio)->isReceiving();
+  }
+  float getCurrentRSSI() override {
+    return ((CustomSX1262 *)_radio)->getRSSI(false);
   }
   float getLastRSSI() const override { return ((CustomSX1262 *)_radio)->getRSSI(); }
   float getLastSNR() const override { return ((CustomSX1262 *)_radio)->getSNR(); }

src/helpers/CustomSX1268Wrapper.h

@@ -6,18 +6,11 @@
 class CustomSX1268Wrapper : public RadioLibWrapper {
 public:
   CustomSX1268Wrapper(CustomSX1268& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
-  bool isReceiving() override { 
-    if (((CustomSX1268 *)_radio)->isReceiving()) return true;
-
-    idle();  // put sx126x into standby
-    // do some basic CAD (blocks for ~12780 micros (on SF 10)!)
-    bool activity = (((CustomSX1268 *)_radio)->scanChannel() == RADIOLIB_LORA_DETECTED);
-    if (activity) {
-      startRecv();
-    } else {
-      idle();
-    }
-    return activity;
+  bool isReceivingPacket() override { 
+    return ((CustomSX1268 *)_radio)->isReceiving();
+  }
+  float getCurrentRSSI() override {
+    return ((CustomSX1268 *)_radio)->getRSSI(false);
   }
   float getLastRSSI() const override { return ((CustomSX1268 *)_radio)->getRSSI(); }
   float getLastSNR() const override { return ((CustomSX1268 *)_radio)->getSNR(); }

src/helpers/CustomSX1276Wrapper.h

@@ -6,18 +6,11 @@
 class CustomSX1276Wrapper : public RadioLibWrapper {
 public:
   CustomSX1276Wrapper(CustomSX1276& radio, mesh::MainBoard& board) : RadioLibWrapper(radio, board) { }
-  bool isReceiving() override { 
-    if (((CustomSX1276 *)_radio)->isReceiving()) return true;
-
-    idle();  // put into standby
-    // do some basic CAD (blocks for ~12780 micros (on SF 10)!)
-    bool activity = (((CustomSX1276 *)_radio)->tryScanChannel() == RADIOLIB_PREAMBLE_DETECTED);
-    if (activity) {
-      startRecv();
-    } else {
-      idle();
-    }
-    return activity;
+  bool isReceivingPacket() override { 
+    return ((CustomSX1276 *)_radio)->isReceiving();
+  }
+  float getCurrentRSSI() override {
+    return ((CustomSX1276 *)_radio)->getRSSI(false);
   }
   float getLastRSSI() const override { return ((CustomSX1276 *)_radio)->getRSSI(); }
   float getLastSNR() const override { return ((CustomSX1276 *)_radio)->getSNR(); }

src/helpers/ESP32Board.cpp

@@ -2,7 +2,7 @@
 
 #include "ESP32Board.h"
 
-#if defined(ADMIN_PASSWORD)   // Repeater or Room Server only
+#if defined(ADMIN_PASSWORD) && !defined(DISABLE_WIFI_OTA)   // Repeater or Room Server only
 #include <WiFi.h>
 #include <AsyncTCP.h>
 #include <ESPAsyncWebServer.h>

src/helpers/RadioLibWrappers.cpp

@@ -8,6 +8,8 @@
 #define STATE_TX_DONE    4
 #define STATE_INT_READY 16
 
+#define NUM_NOISE_FLOOR_SAMPLES  64
+
 static volatile uint8_t state = STATE_IDLE;
 
 // this function is called when a complete packet
@@ -28,6 +30,13 @@ void RadioLibWrapper::begin() {
   if (_board->getStartupReason() == BD_STARTUP_RX_PACKET) {  // received a LoRa packet (while in deep sleep)
     setFlag(); // LoRa packet is already received
   }
+
+  _noise_floor = 0;
+  _threshold = 0;
+
+  // start average out some samples
+  _num_floor_samples = 0;
+  _floor_sample_sum = 0;
 }
 
 void RadioLibWrapper::idle() {
@@ -35,6 +44,34 @@ void RadioLibWrapper::idle() {
   state = STATE_IDLE;   // need another startReceive()
 }
 
+void RadioLibWrapper::triggerNoiseFloorCalibrate(int threshold) {
+  _threshold = threshold;
+  if (threshold > 0 && _num_floor_samples >= NUM_NOISE_FLOOR_SAMPLES) {  // ignore trigger if currently sampling
+    _num_floor_samples = 0;
+    _floor_sample_sum = 0;
+  }
+}
+
+void RadioLibWrapper::loop() {
+  if (state == STATE_RX && _num_floor_samples < NUM_NOISE_FLOOR_SAMPLES) {
+    if (!isReceivingPacket()) {
+      int rssi = getCurrentRSSI();
+      if (rssi < _noise_floor + _threshold) {  // only consider samples below current floor+THRESHOLD
+        _num_floor_samples++;
+        _floor_sample_sum += rssi;
+      }
+    }
+  } else if (_num_floor_samples >= NUM_NOISE_FLOOR_SAMPLES && _floor_sample_sum != 0) {
+    _noise_floor = _floor_sample_sum / NUM_NOISE_FLOOR_SAMPLES;
+    if (_noise_floor < -120) {
+      _noise_floor = -120;    // clamp to lower bound of -120dBi
+    }
+    _floor_sample_sum = 0;
+
+    MESH_DEBUG_PRINTLN("RadioLibWrapper: noise_floor = %d", (int)_noise_floor);
+  }
+}
+
 void RadioLibWrapper::startRecv() {
   int err = _radio->startReceive();
   if (err == RADIOLIB_ERR_NONE) {
@@ -108,6 +145,12 @@ void RadioLibWrapper::onSendFinished() {
   state = STATE_IDLE;
 }
 
+bool RadioLibWrapper::isChannelActive() {
+  return _threshold == 0 
+          ? false    // interference check is disabled
+          : getCurrentRSSI() > _noise_floor + _threshold;
+}
+
 float RadioLibWrapper::getLastRSSI() const {
   return _radio->getRSSI();
 }

src/helpers/RadioLibWrappers.h

@@ -8,10 +8,14 @@ protected:
   PhysicalLayer* _radio;
   mesh::MainBoard* _board;
   uint32_t n_recv, n_sent;
+  int16_t _noise_floor, _threshold;
+  uint16_t _num_floor_samples;
+  int32_t _floor_sample_sum;
 
   void idle();
   void startRecv();
   float packetScoreInt(float snr, int sf, int packet_len);
+  virtual bool isReceivingPacket() =0;
 
 public:
   RadioLibWrapper(PhysicalLayer& radio, mesh::MainBoard& board) : _radio(&radio), _board(&board) { n_recv = n_sent = 0; }
@@ -23,6 +27,20 @@ public:
   bool isSendComplete() override;
   void onSendFinished() override;
   bool isInRecvMode() const override;
+  bool isChannelActive();
+
+  bool isReceiving() override { 
+    if (isReceivingPacket()) return true;
+
+    return isChannelActive();
+  }
+
+  virtual float getCurrentRSSI() =0;
+
+  int getNoiseFloor() const override { return _noise_floor; }
+  void triggerNoiseFloorCalibrate(int threshold) override;
+
+  void loop() override;
 
   uint32_t getPacketsRecv() const { return n_recv; }
   uint32_t getPacketsSent() const { return n_sent; }

src/helpers/TBeamBoard.h

@@ -7,6 +7,9 @@
 
 // Defined using AXP2102
 #define XPOWERS_CHIP_AXP2101
+#define PIN_BOARD_SDA1 42  //SDA for PMU and PFC8563 (RTC)
+#define PIN_BOARD_SCL1 41  //SCL for PMU and PFC8563 (RTC)
+#define PIN_PMU_IRQ 40     //IRQ pin for PMU
 
 // LoRa radio module pins for TBeam
 #define  P_LORA_DIO_0   26
@@ -28,15 +31,13 @@
 #include <driver/rtc_io.h>
 
 class TBeamBoard : public ESP32Board {
-  XPowersAXP2101 power;
-
+  XPowersLibInterface *PMU = NULL;
 public:
+  bool power_init();
+  void printPMU();
+
   void begin() {
     ESP32Board::begin();
-
-    power.setALDO2Voltage(3300);
-    power.enableALDO2();
-
     pinMode(38, INPUT_PULLUP);
 
     esp_reset_reason_t reason = esp_reset_reason();
@@ -49,6 +50,7 @@ public:
       rtc_gpio_hold_dis((gpio_num_t)P_LORA_NSS);
       rtc_gpio_deinit((gpio_num_t)P_LORA_DIO_1);
     }
+    power_init();
   }
 
   void enterDeepSleep(uint32_t secs, int pin_wake_btn = -1) {
@@ -75,7 +77,8 @@ public:
   }
 
   uint16_t getBattMilliVolts() override {
-    return power.getBattVoltage();
+    if(PMU) return PMU->getBattVoltage();
+    else return 0;
   }
 
   const char* getManufacturerName() const override {

src/helpers/TBeamS3SupremeBoard.h

@@ -22,7 +22,7 @@
 #define PIN_BOARD_SCL1 41  //SCL for PMU and PFC8563 (RTC)
 #define PIN_PMU_IRQ 40     //IRQ pin for PMU
 
-#define PIN_USER_BTN 0
+//#define PIN_USER_BTN 0
 
 #define P_BOARD_SPI_MOSI 35  //SPI for SD Card and QMI8653 (IMU)
 #define P_BOARD_SPI_MISO 37  //SPI for SD Card and QMI8653 (IMU)
@@ -61,10 +61,10 @@ public:
 
   void begin() {
 
-    power_init();
-
     ESP32Board::begin();
 
+    power_init();
+
     esp_reset_reason_t reason = esp_reset_reason();
     if (reason == ESP_RST_DEEPSLEEP) {
       long wakeup_source = esp_sleep_get_ext1_wakeup_status();
@@ -75,6 +75,7 @@ public:
       rtc_gpio_hold_dis((gpio_num_t)P_LORA_NSS);
       rtc_gpio_deinit((gpio_num_t)P_LORA_DIO_1);
     }
+    power_init();
   }
 
   void enterDeepSleep(uint32_t secs, int pin_wake_btn = -1) {

src/helpers/nrf52/RAK4631Board.cpp

@@ -80,6 +80,11 @@ bool RAK4631Board::startOTAUpdate(const char* id, char reply[]) {
   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");
+  uint8_t mac_addr[6];
+  memset(mac_addr, 0, sizeof(mac_addr));
+  Bluefruit.getAddr(mac_addr);
+  sprintf(reply, "OK - mac: %02X:%02X:%02X:%02X:%02X:%02X", 
+      mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
+
   return true;
 }

src/helpers/nrf52/RAK4631Board.h

@@ -12,6 +12,17 @@
 #define  P_LORA_MISO    45
 #define  P_LORA_MOSI    44
 #define  SX126X_POWER_EN  37
+
+#define P_GPS_SDA       13  //GPS SDA pin (output option)
+#define P_GPS_SCL       14  //GPS SCL pin (output option)
+#define P_GPS_TX        16  //GPS TX pin
+#define P_GPS_RX        15  //GPS RX pin
+#define P_GPS_STANDBY_A 34  //GPS Reset/Standby pin (IO2 for socket A)
+#define P_GPS_STANDBY_C 4   //GPS Reset/Standby pin (IO4 for socket C)
+#define P_GPS_STANDBY_F 9   //GPS Reset/Standby pin (IO5 for socket F)
+#define P_GPS_1PPS      17  //GPS PPS pin
+#define GPS_BAUD_RATE   9600
+#define GPS_ADDRESS   0x42  //i2c address for GPS
  
 #define SX126X_DIO2_AS_RF_SWITCH  true
 #define SX126X_DIO3_TCXO_VOLTAGE   1.8

src/helpers/sensors/LocationProvider.h

@@ -4,13 +4,19 @@
 
 
 class LocationProvider {
+protected:
+    bool _time_sync_needed = true;
 
 public:
+    virtual void syncTime() { _time_sync_needed = true; }
+    virtual bool waitingTimeSync() { return _time_sync_needed; }
     virtual long getLatitude() = 0;
     virtual long getLongitude() = 0;
     virtual long getAltitude() = 0;
+    virtual long satellitesCount() = 0;
     virtual bool isValid() = 0;
     virtual long getTimestamp() = 0;
+    virtual void sendSentence(const char * sentence);
     virtual void reset();
     virtual void begin();
     virtual void stop();

src/helpers/sensors/MicroNMEALocationProvider.h

@@ -19,13 +19,16 @@
 class MicroNMEALocationProvider : public LocationProvider {
     char _nmeaBuffer[100];
     MicroNMEA nmea;
+    mesh::RTCClock* _clock;
     Stream* _gps_serial;
     int _pin_reset;
     int _pin_en;
+    long next_check = 0;
+    long time_valid = 0;
 
 public :
-    MicroNMEALocationProvider(Stream& ser, int pin_reset = GPS_RESET, int pin_en = GPS_EN) :
-    _gps_serial(&ser), nmea(_nmeaBuffer, sizeof(_nmeaBuffer)), _pin_reset(pin_reset), _pin_en(pin_en) {
+    MicroNMEALocationProvider(Stream& ser, mesh::RTCClock* clock = NULL, int pin_reset = GPS_RESET, int pin_en = GPS_EN) :
+    _gps_serial(&ser), nmea(_nmeaBuffer, sizeof(_nmeaBuffer)), _pin_reset(pin_reset), _pin_en(pin_en), _clock(clock) {
         if (_pin_reset != -1) {
             pinMode(_pin_reset, OUTPUT);
             digitalWrite(_pin_reset, GPS_RESET_FORCE);
@@ -59,6 +62,7 @@ public :
         }        
     }
 
+    void syncTime() override { nmea.clear(); LocationProvider::syncTime(); }
     long getLatitude() override { return nmea.getLatitude(); }
     long getLongitude() override { return nmea.getLongitude(); }
     long getAltitude() override { 
@@ -66,6 +70,7 @@ public :
         nmea.getAltitude(alt);
         return alt;
     }
+    long satellitesCount() override { return nmea.getNumSatellites(); }
     bool isValid() override { return nmea.isValid(); }
 
     long getTimestamp() override { 
@@ -73,7 +78,12 @@ public :
         return dt.unixtime();
     } 
 
+    void sendSentence(const char *sentence) override {
+        nmea.sendSentence(*_gps_serial, sentence);
+    }
+
     void loop() override {
+
         while (_gps_serial->available()) {
             char c = _gps_serial->read();
             #ifdef GPS_NMEA_DEBUG
@@ -81,5 +91,20 @@ public :
             #endif
             nmea.process(c);
         }
+
+        if (!isValid()) time_valid = 0;
+
+        if (millis() > next_check) {
+            next_check = millis() + 1000;
+            if (_time_sync_needed && time_valid > 2) {
+                if (_clock != NULL) {
+                    _clock->setCurrentTime(getTimestamp());
+                    _time_sync_needed = false;
+                }
+            }
+            if (isValid()) {
+                time_valid ++;
+            }
+        }
     }
 };

src/helpers/stm32/InternalFileSystem.cpp

@@ -126,11 +126,14 @@ InternalFileSystem::InternalFileSystem(void)
 
 bool InternalFileSystem::begin(void)
 {
+  volatile bool format_fs;
   #ifdef FORMAT_FS
-  this->format();
+  format_fs = true;
+  #else
+  format_fs = false; // you can always use debugger to force formatting ;)
   #endif
   // failed to mount, erase all sector then format and mount again
-  if ( !Adafruit_LittleFS::begin() )
+  if ( format_fs || !Adafruit_LittleFS::begin() )
   {
     // lfs format
     this->format();

src/helpers/ui/GxEPDDisplay.cpp

@@ -5,22 +5,15 @@
   #define DISPLAY_ROTATION 3
 #endif
 
-#ifdef TECHO_ZOOM
-  #define SCALE_X   (1.5625f * 1.5f)   //  200 / 128  (with 1.5 scale)
-  #define SCALE_Y   (1.5625f * 1.5f)   //  200 / 128  (with 1.5 scale)
-#else
-  #define SCALE_X   1.5625f   //  200 / 128
-  #define SCALE_Y   1.5625f   //  200 / 128
-#endif
+#define SCALE_X   1.5625f   //  200 / 128
+#define SCALE_Y   1.5625f   //  200 / 128
 
 bool GxEPDDisplay::begin() {
   display.epd2.selectSPI(SPI1, SPISettings(4000000, MSBFIRST, SPI_MODE0));
   SPI1.begin();
   display.init(115200, true, 2, false);
   display.setRotation(DISPLAY_ROTATION);
-  #ifdef TECHO_ZOOM
-    display.setFont(&FreeMono9pt7b);
-  #endif
+  setTextSize(1);  // Default to size 1
   display.setPartialWindow(0, 0, display.width(), display.height());
 
   display.fillScreen(GxEPD_WHITE);
@@ -57,7 +50,20 @@ void GxEPDDisplay::startFrame(Color bkg) {
 }
 
 void GxEPDDisplay::setTextSize(int sz) {
-  display.setTextSize(sz);
+  switch(sz) {
+    case 1:  // Small
+      display.setFont(&FreeSans9pt7b);
+      break;
+    case 2:  // Medium Bold
+      display.setFont(&FreeSansBold12pt7b);
+      break;
+    case 3:  // Large
+      display.setFont(&FreeSans18pt7b);
+      break;
+    default:
+      display.setFont(&FreeSans9pt7b);
+      break;
+  }
 }
 
 void GxEPDDisplay::setColor(Color c) {
@@ -81,7 +87,39 @@ void GxEPDDisplay::drawRect(int x, int y, int w, int h) {
 }
 
 void GxEPDDisplay::drawXbm(int x, int y, const uint8_t* bits, int w, int h) {
-  display.drawBitmap(x*SCALE_X, (y*SCALE_Y) + 10, bits, w, h, GxEPD_BLACK);
+  // Calculate the base position in display coordinates
+  uint16_t startX = x * SCALE_X;
+  uint16_t startY = y * SCALE_Y;
+  
+  // Width in bytes for bitmap processing
+  uint16_t widthInBytes = (w + 7) / 8;
+  
+  // Process the bitmap row by row
+  for (uint16_t by = 0; by < h; by++) {
+    // Calculate the target y-coordinates for this logical row
+    int y1 = startY + (int)(by * SCALE_Y);
+    int y2 = startY + (int)((by + 1) * SCALE_Y);
+    int block_h = y2 - y1;
+    
+    // Scan across the row bit by bit
+    for (uint16_t bx = 0; bx < w; bx++) {
+      // Calculate the target x-coordinates for this logical column
+      int x1 = startX + (int)(bx * SCALE_X);
+      int x2 = startX + (int)((bx + 1) * SCALE_X);
+      int block_w = x2 - x1;
+      
+      // Get the current bit
+      uint16_t byteOffset = (by * widthInBytes) + (bx / 8);
+      uint8_t bitMask = 0x80 >> (bx & 7);
+      bool bitSet = pgm_read_byte(bits + byteOffset) & bitMask;
+      
+      // If the bit is set, draw a block of pixels
+      if (bitSet) {
+        // Draw the block as a filled rectangle
+        display.fillRect(x1, y1, block_w, block_h, GxEPD_BLACK);
+      }
+    }
+  }
 }
 
 uint16_t GxEPDDisplay::getTextWidth(const char* str) {

src/helpers/ui/GxEPDDisplay.h

@@ -9,7 +9,9 @@
 #include <GxEPD2_3C.h>
 #include <GxEPD2_4C.h>
 #include <GxEPD2_7C.h>
-#include <Fonts/FreeMono9pt7b.h>
+#include <Fonts/FreeSans9pt7b.h>
+#include <Fonts/FreeSansBold12pt7b.h>
+#include <Fonts/FreeSans18pt7b.h>
 
 #define GxEPD2_DISPLAY_CLASS GxEPD2_BW
 #define GxEPD2_DRIVER_CLASS GxEPD2_150_BN  // DEPG0150BN 200x200, SSD1681, (FPC8101), TTGO T5 V2.4.1

src/helpers/ui/buzzer.cpp

@@ -11,6 +11,7 @@ void genericBuzzer::begin() {
 
     quiet(false);
     pinMode(PIN_BUZZER, OUTPUT);
+    digitalWrite(PIN_BUZZER, LOW); // need to pull low by default to avoid extreme power draw
     startup();
 }
 

variants/generic_espnow/platformio.ini

@@ -56,13 +56,11 @@ 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>
+  +<../examples/companion_radio>
 lib_deps =
   ${Generic_ESPNOW.lib_deps}
   densaugeo/base64 @ ~1.4.0

variants/heltec_tracker/platformio.ini

@@ -39,7 +39,7 @@ extends = Heltec_tracker_base
 build_flags =
   ${Heltec_tracker_base.build_flags}
   -I src/helpers/ui
- ; -D ARDUINO_USB_CDC_ON_BOOT=1      ; need for debugging
+  -D ARDUINO_USB_CDC_ON_BOOT=1      ; need for Serial
   -D DISPLAY_ROTATION=1
   -D DISPLAY_CLASS=ST7735Display
   -D MAX_CONTACTS=100
@@ -47,8 +47,6 @@ build_flags =
   -D BLE_PIN_CODE=123456 ; HWT will use display for pin
   -D OFFLINE_QUEUE_SIZE=256
 ;  -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_tracker_base.build_src_filter}

variants/heltec_v2/platformio.ini

@@ -99,8 +99,6 @@ build_flags =
   -D BLE_PIN_CODE=0
   -D BLE_DEBUG_LOGGING=1
   -D OFFLINE_QUEUE_SIZE=256
-;  -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}

variants/heltec_v3/platformio.ini

@@ -17,11 +17,20 @@ build_flags =
   -D SX126X_DIO3_TCXO_VOLTAGE=1.8
   -D SX126X_CURRENT_LIMIT=140
   -D SX126X_RX_BOOSTED_GAIN=1
+  -D ENV_INCLUDE_AHTX0=1
+  -D ENV_INCLUDE_BME280=1
+  -D ENV_INCLUDE_INA3221=1
+  -D ENV_INCLUDE_INA219=1  
 build_src_filter = ${esp32_base.build_src_filter}
   +<../variants/heltec_v3>
+  +<helpers/sensors>    
 lib_deps =
   ${esp32_base.lib_deps}
   adafruit/Adafruit SSD1306 @ ^2.5.13
+  adafruit/Adafruit INA3221 Library @ ^1.0.1
+  adafruit/Adafruit INA219 @ ^1.2.3
+  adafruit/Adafruit AHTX0 @ ^2.0.5
+  adafruit/Adafruit BME280 Library @ ^2.3.0    
 
 [env:Heltec_v3_repeater]
 extends = Heltec_lora32_v3
@@ -82,8 +91,6 @@ 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}
@@ -103,8 +110,6 @@ build_flags =
   -D BLE_PIN_CODE=0   ; dynamic, random PIN
   -D BLE_DEBUG_LOGGING=1
   -D OFFLINE_QUEUE_SIZE=256
-;  -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}
@@ -125,8 +130,6 @@ build_flags =
   -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}
@@ -180,8 +183,6 @@ build_flags =
   -D BLE_PIN_CODE=123456
   -D BLE_DEBUG_LOGGING=1
   -D OFFLINE_QUEUE_SIZE=256
-;  -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}

variants/heltec_v3/target.cpp

@@ -14,7 +14,7 @@ WRAPPER_CLASS radio_driver(radio, board);
 
 ESP32RTCClock fallback_clock;
 AutoDiscoverRTCClock rtc_clock(fallback_clock);
-SensorManager sensors;
+EnvironmentSensorManager sensors;
 
 #ifdef DISPLAY_CLASS
   DISPLAY_CLASS display;

variants/heltec_v3/target.h

@@ -7,6 +7,7 @@
 #include <helpers/CustomSX1262Wrapper.h>
 #include <helpers/AutoDiscoverRTCClock.h>
 #include <helpers/SensorManager.h>
+#include <helpers/sensors/EnvironmentSensorManager.h>
 #ifdef DISPLAY_CLASS
   #include <helpers/ui/SSD1306Display.h>
 #endif
@@ -14,7 +15,7 @@
 extern HeltecV3Board board;
 extern WRAPPER_CLASS radio_driver;
 extern AutoDiscoverRTCClock rtc_clock;
-extern SensorManager sensors;
+extern EnvironmentSensorManager sensors;
 
 #ifdef DISPLAY_CLASS
   extern DISPLAY_CLASS display;

variants/lilygo_t3s3/platformio.ini

@@ -92,8 +92,6 @@ 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}
@@ -113,8 +111,6 @@ build_flags =
   -D BLE_PIN_CODE=123456
   -D BLE_DEBUG_LOGGING=1
   -D OFFLINE_QUEUE_SIZE=256
-;  -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}

variants/lilygo_tbeam/platformio.ini

@@ -33,8 +33,6 @@ build_flags =
   -D BLE_DEBUG_LOGGING=1
   -D OFFLINE_QUEUE_SIZE=256
 ;  -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}

variants/lilygo_tbeam/target.cpp

@@ -3,6 +3,14 @@
 
 TBeamBoard board;
 
+// Using PMU AXP2102
+#define PMU_WIRE_PORT               Wire
+
+bool pmuIntFlag = false;
+static void setPMUIntFlag(){
+  pmuIntFlag = true;
+}
+
 #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);
@@ -24,6 +32,112 @@ SensorManager sensors;
   #define LORA_CR      5
 #endif
 
+bool TBeamBoard::power_init()
+{
+  if (!PMU)
+  {
+    PMU = new XPowersAXP2101(PMU_WIRE_PORT);
+    if (!PMU->init())
+    {
+      // Serial.println("Warning: Failed to find AXP2101 power management");
+      delete PMU;
+      PMU = NULL;
+    }
+    else
+    {
+      // Serial.println("AXP2101 PMU init succeeded, using AXP2101 PMU");
+    }
+  }
+  if (!PMU)
+  {
+    PMU = new XPowersAXP192(PMU_WIRE_PORT);
+    if (!PMU->init())
+    {
+      // Serial.println("Warning: Failed to find AXP192 power management");
+      delete PMU;
+      PMU = NULL;
+    }
+    else
+    {
+      // Serial.println("AXP192 PMU init succeeded, using AXP192 PMU");
+    }
+  }
+
+  if (!PMU)
+  {
+    MESH_DEBUG_PRINTLN("PMU init failed.");
+    return false;
+  }
+
+  // Serial.printf("PMU  ID:0x%x\n", PMU->getChipID());
+  // printPMU();
+  if (PMU->getChipModel() == XPOWERS_AXP192)
+  {
+    // lora radio power channel
+    PMU->setPowerChannelVoltage(XPOWERS_LDO2, 3300);
+    PMU->enablePowerOutput(XPOWERS_LDO2);
+    // oled module power channel,
+    // disable it will cause abnormal communication between boot and AXP power supply,
+    // do not turn it off
+    PMU->setPowerChannelVoltage(XPOWERS_DCDC1, 3300);
+    // enable oled power
+    PMU->enablePowerOutput(XPOWERS_DCDC1);
+    // gnss module power channel
+    PMU->setPowerChannelVoltage(XPOWERS_LDO3, 3300);
+    // power->enablePowerOutput(XPOWERS_LDO3);
+    // protected oled power source
+    PMU->setProtectedChannel(XPOWERS_DCDC1);
+    // protected esp32 power source
+    PMU->setProtectedChannel(XPOWERS_DCDC3);
+    // disable not use channel
+    PMU->disablePowerOutput(XPOWERS_DCDC2);
+    // disable all axp chip interrupt
+    PMU->disableIRQ(XPOWERS_AXP192_ALL_IRQ);
+    PMU->setChargerConstantCurr(XPOWERS_AXP192_CHG_CUR_550MA);
+  }
+  else if (PMU->getChipModel() == XPOWERS_AXP2101)
+  {
+    // gnss module power channel
+    PMU->setPowerChannelVoltage(XPOWERS_ALDO4, 3300);
+    PMU->enablePowerOutput(XPOWERS_ALDO4);
+    // lora radio power channel
+    PMU->setPowerChannelVoltage(XPOWERS_ALDO3, 3300);
+    PMU->enablePowerOutput(XPOWERS_ALDO3);
+    // m.2 interface
+    PMU->setPowerChannelVoltage(XPOWERS_DCDC3, 3300);
+    PMU->enablePowerOutput(XPOWERS_DCDC3);
+    // power->setPowerChannelVoltage(XPOWERS_DCDC4, 3300);
+    // power->enablePowerOutput(XPOWERS_DCDC4);
+    // not use channel
+    PMU->disablePowerOutput(XPOWERS_DCDC2); // not elicited
+    PMU->disablePowerOutput(XPOWERS_DCDC5); // not elicited
+    PMU->disablePowerOutput(XPOWERS_DLDO1); // Invalid power channel, it does not exist
+    PMU->disablePowerOutput(XPOWERS_DLDO2); // Invalid power channel, it does not exist
+    PMU->disablePowerOutput(XPOWERS_VBACKUP);
+    // disable all axp chip interrupt
+    PMU->disableIRQ(XPOWERS_AXP2101_ALL_IRQ);
+    PMU->setChargerConstantCurr(XPOWERS_AXP2101_CHG_CUR_500MA);
+
+    // Set up PMU interrupts
+    // Serial.println("Setting up PMU interrupts");
+    pinMode(PIN_PMU_IRQ, INPUT_PULLUP);
+    attachInterrupt(PIN_PMU_IRQ, setPMUIntFlag, FALLING);
+
+    // Reset and re-enable PMU interrupts
+    // Serial.println("Re-enable interrupts");
+    PMU->disableIRQ(XPOWERS_AXP2101_ALL_IRQ);
+    PMU->clearIrqStatus();
+    PMU->enableIRQ(
+        XPOWERS_AXP2101_BAT_INSERT_IRQ | XPOWERS_AXP2101_BAT_REMOVE_IRQ |    // Battery interrupts
+        XPOWERS_AXP2101_VBUS_INSERT_IRQ | XPOWERS_AXP2101_VBUS_REMOVE_IRQ |  // VBUS interrupts
+        XPOWERS_AXP2101_PKEY_SHORT_IRQ | XPOWERS_AXP2101_PKEY_LONG_IRQ |     // Power Key interrupts
+        XPOWERS_AXP2101_BAT_CHG_DONE_IRQ | XPOWERS_AXP2101_BAT_CHG_START_IRQ // Charging interrupts
+    );
+  }
+
+  return true;
+}
+
 bool radio_init() {
   fallback_clock.begin();
   rtc_clock.begin(Wire);
@@ -66,3 +180,24 @@ mesh::LocalIdentity radio_new_identity() {
   RadioNoiseListener rng(radio);
   return mesh::LocalIdentity(&rng);  // create new random identity
 }
+
+#ifdef MESH_DEBUG
+void TBeamBoard::printPMU()
+{
+    Serial.print("isCharging:"); Serial.println(PMU->isCharging() ? "YES" : "NO");
+    Serial.print("isDischarge:"); Serial.println(PMU->isDischarge() ? "YES" : "NO");
+    Serial.print("isVbusIn:"); Serial.println(PMU->isVbusIn() ? "YES" : "NO");
+    Serial.print("getBattVoltage:"); Serial.print(PMU->getBattVoltage()); Serial.println("mV");
+    Serial.print("getVbusVoltage:"); Serial.print(PMU->getVbusVoltage()); Serial.println("mV");
+    Serial.print("getSystemVoltage:"); Serial.print(PMU->getSystemVoltage()); Serial.println("mV");
+
+    // The battery percentage may be inaccurate at first use, the PMU will automatically
+    // learn the battery curve and will automatically calibrate the battery percentage
+    // after a charge and discharge cycle
+    if (PMU->isBatteryConnect()) {
+        Serial.print("getBatteryPercent:"); Serial.print(PMU->getBatteryPercent()); Serial.println("%");
+    }
+
+    Serial.println();
+}
+#endif

variants/lilygo_tbeam_SX1262/platformio.ini

@@ -38,8 +38,6 @@ build_flags =
 ;  -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_SX1262.build_src_filter}

variants/lilygo_tbeam_supreme_SX1262/platformio.ini

@@ -8,19 +8,22 @@ build_flags =
   -D P_LORA_TX_LED=6
   -D PIN_BOARD_SDA=17
   -D PIN_BOARD_SCL=18
+  -D PIN_USER_BTN=0
   -D RADIO_CLASS=CustomSX1262
   -D WRAPPER_CLASS=CustomSX1262Wrapper
-  ;-D DISPLAY_CLASS=SSD1306Display      ;Needs to be modified for SH1106
+  -D DISPLAY_CLASS=SH1106Display
   -D SX126X_RX_BOOSTED_GAIN=1
   -D SX126X_CURRENT_LIMIT=140
 build_src_filter = ${esp32_base.build_src_filter}
   +<../variants/lilygo_tbeam_supreme_SX1262>
+  +<helpers/ui/SH1106Display.cpp>
 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
+  adafruit/Adafruit SH110X @ ^2.1.13
   stevemarple/MicroNMEA @ ^2.0.6
+  adafruit/Adafruit BME280 Library @ ^2.3.0
 
 ; === LILYGO T-Beam S3 Supreme with SX1262 environments ===
 [env:T_Beam_S3_Supreme_SX1262_repeater]
@@ -64,10 +67,8 @@ build_flags =
   -D MAX_CONTACTS=100
   -D MAX_GROUP_CHANNELS=8
   -D BLE_PIN_CODE=123456
-  -D BLE_DEBUG_LOGGING=1
   -D OFFLINE_QUEUE_SIZE=256
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+;  -D BLE_DEBUG_LOGGING=1
 ;  -D MESH_PACKET_LOGGING=8
 ;  -D MESH_DEBUG=1
 build_src_filter = ${T_Beam_S3_Supreme_SX1262.build_src_filter}

variants/lilygo_tbeam_supreme_SX1262/target.cpp

@@ -4,6 +4,10 @@
 
 TBeamS3SupremeBoard board;
 
+#ifdef DISPLAY_CLASS
+  DISPLAY_CLASS display;
+#endif
+
 bool pmuIntFlag;
 
 #ifndef LORA_CR
@@ -46,7 +50,7 @@ void scanDevices(TwoWire *w)
             switch (addr) {
             case 0x77:
             case 0x76:
-                Serial.println("\tFound BMX280 Sensor");
+                Serial.println("\tFound BME280 Sensor");
                 deviceOnline |= BME280_ONLINE;
                 break;
             case 0x34:
@@ -107,6 +111,26 @@ void TBeamS3SupremeBoard::printPMU()
 
     Serial.println();
 }
+void TbeamSupSensorManager::printBMEValues() {  
+  Serial.print("Temperature = ");
+  Serial.print(bme.readTemperature());
+  Serial.println(" *C");
+
+  Serial.print("Pressure = ");
+
+  Serial.print(bme.readPressure() / 100.0F);
+  Serial.println(" hPa");
+
+  Serial.print("Approx. Altitude = ");
+  Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
+  Serial.println(" m");
+
+  Serial.print("Humidity = ");
+  Serial.print(bme.readHumidity());
+  Serial.println(" %");
+
+  Serial.println();
+}
 #endif
 
 bool TBeamS3SupremeBoard::power_init()
@@ -119,9 +143,9 @@ bool TBeamS3SupremeBoard::power_init()
   PMU.setChargingLedMode(XPOWERS_CHG_LED_CTRL_CHG);
 
   // Set up PMU interrupts
-  // MESH_DEBUG_PRINTLN("Setting up PMU interrupts");
-  // pinMode(PIN_PMU_IRQ, INPUT_PULLUP);
-  // attachInterrupt(PIN_PMU_IRQ, setPMUIntFlag, FALLING);
+  MESH_DEBUG_PRINTLN("Setting up PMU interrupts");
+  pinMode(PIN_PMU_IRQ, INPUT_PULLUP);
+  attachInterrupt(PIN_PMU_IRQ, setPMUIntFlag, FALLING);
 
   // GPS
   MESH_DEBUG_PRINTLN("Setting and enabling a-ldo4 for GPS");
@@ -164,22 +188,22 @@ bool TBeamS3SupremeBoard::power_init()
   PMU.enableBLDO1();
 
   // Out to header pins
-  // MESH_DEBUG_PRINTLN("Setting and enabling b-ldo2 for output to header");
-  // PMU.setBLDO2Voltage(3300);
-  // PMU.enableBLDO2();
+  MESH_DEBUG_PRINTLN("Setting and enabling b-ldo2 for output to header");
+  PMU.setBLDO2Voltage(3300);
+  PMU.enableBLDO2();
 
-  // MESH_DEBUG_PRINTLN("Setting and enabling dcdc4 for output to header");
-  // PMU.setDC4Voltage(XPOWERS_AXP2101_DCDC4_VOL2_MAX); // 1.8V
-  // PMU.enableDC4();
+  MESH_DEBUG_PRINTLN("Setting and enabling dcdc4 for output to header");
+  PMU.setDC4Voltage(XPOWERS_AXP2101_DCDC4_VOL2_MAX); // 1.8V
+  PMU.enableDC4();
 
-  // MESH_DEBUG_PRINTLN("Setting and enabling dcdc5 for output to header");
-  // PMU.setDC5Voltage(3300);
-  // PMU.enableDC5();
+  MESH_DEBUG_PRINTLN("Setting and enabling dcdc5 for output to header");
+  PMU.setDC5Voltage(3300);
+  PMU.enableDC5();
 
   // Unused power rails
-  MESH_DEBUG_PRINTLN("Disabling unused supplies dcdc2, dldo1 and dldo2");
+  MESH_DEBUG_PRINTLN("Disabling unused supplies dcdc2, dcdc5, dldo1 and dldo2");
   PMU.disableDC2();
-  PMU.disableDC5();
+  //PMU.disableDC5();
   PMU.disableDLDO1();
   PMU.disableDLDO2();
 
@@ -199,18 +223,18 @@ bool TBeamS3SupremeBoard::power_init()
   PMU.enableVbusVoltageMeasure();
 
   // Reset and re-enable PMU interrupts
-  // MESH_DEBUG_PRINTLN("Re-enable interrupts");
-  // PMU.disableIRQ(XPOWERS_AXP2101_ALL_IRQ);
-  // PMU.clearIrqStatus();
-  // PMU.enableIRQ(
-  //     XPOWERS_AXP2101_BAT_INSERT_IRQ | XPOWERS_AXP2101_BAT_REMOVE_IRQ |    // Battery interrupts
-  //     XPOWERS_AXP2101_VBUS_INSERT_IRQ | XPOWERS_AXP2101_VBUS_REMOVE_IRQ |  // VBUS interrupts
-  //     XPOWERS_AXP2101_PKEY_SHORT_IRQ | XPOWERS_AXP2101_PKEY_LONG_IRQ |     // Power Key interrupts
-  //     XPOWERS_AXP2101_BAT_CHG_DONE_IRQ | XPOWERS_AXP2101_BAT_CHG_START_IRQ // Charging interrupts
-  // );
+  MESH_DEBUG_PRINTLN("Re-enable interrupts");
+  PMU.disableIRQ(XPOWERS_AXP2101_ALL_IRQ);
+  PMU.clearIrqStatus();
+  PMU.enableIRQ(
+      XPOWERS_AXP2101_BAT_INSERT_IRQ | XPOWERS_AXP2101_BAT_REMOVE_IRQ |    // Battery interrupts
+      XPOWERS_AXP2101_VBUS_INSERT_IRQ | XPOWERS_AXP2101_VBUS_REMOVE_IRQ |  // VBUS interrupts
+      XPOWERS_AXP2101_PKEY_SHORT_IRQ | XPOWERS_AXP2101_PKEY_LONG_IRQ |     // Power Key interrupts
+      XPOWERS_AXP2101_BAT_CHG_DONE_IRQ | XPOWERS_AXP2101_BAT_CHG_START_IRQ // Charging interrupts
+  );
 #ifdef MESH_DEBUG
-  // scanDevices(&Wire);
-  // scanDevices(&Wire1);
+  scanDevices(&Wire); 
+  scanDevices(&Wire1);
   printPMU();
 #endif
 
@@ -235,60 +259,14 @@ static bool readStringUntil(Stream& s, char dest[], size_t max_len, char term, u
   return millis() < timeout;   // false, if timed out
 }
 
-static bool l76kProbe()
-{
-    bool result = false;
-    uint32_t startTimeout ;
-    Serial1.write("$PCAS03,0,0,0,0,0,0,0,0,0,0,,,0,0*02\r\n");
-    delay(5);
-    // Get version information
-    startTimeout = millis() + 3000;
-    MESH_DEBUG_PRINTLN("Trying to init L76K GPS");
-    // Serial1.flush();
-    while (Serial1.available()) {
-        int c = Serial1.read();
-        // Serial.write(c);
-        // Serial.print(".");
-        // Serial.flush();
-        // Serial1.flush();
-        if (millis() > startTimeout) {
-            MESH_DEBUG_PRINTLN("L76K NMEA timeout!");
-            return false;
-        }
-    };
-
-    Serial1.flush();
-    delay(200);
-
-    Serial1.write("$PCAS06,0*1B\r\n");
-
-    char ver[100];
-    if (!readStringUntil(Serial1, ver, sizeof(ver), '\n', 500)) {
-      MESH_DEBUG_PRINTLN("Get L76K timeout!");
-      return false;
-    }
-
-    if (memcmp(ver, "$GPTXT,01,01,02", 15) == 0) {
-        MESH_DEBUG_PRINTLN("L76K GNSS init succeeded, using L76K GNSS Module\n");
-        result = true;
-    }
-    delay(500);
-
-    // Initialize the L76K Chip, use GPS + GLONASS
-    Serial1.write("$PCAS04,5*1C\r\n");
-    delay(250);
-    // only ask for RMC and GGA
-    Serial1.write("$PCAS03,1,0,0,0,1,0,0,0,0,0,,,0,0*02\r\n");
-    delay(250);
-    // Switch to Vehicle Mode, since SoftRF enables Aviation < 2g
-    Serial1.write("$PCAS11,3*1E\r\n");
-    return result;
-}
-
 bool radio_init() {
   fallback_clock.begin();
 
   rtc_clock.begin(Wire1);
+
+  // #ifdef MESH_DEBUG
+  // printBMEValues();
+  // #endif
   
 #ifdef SX126X_DIO3_TCXO_VOLTAGE
   float tcxo = SX126X_DIO3_TCXO_VOLTAGE;
@@ -340,55 +318,95 @@ void TbeamSupSensorManager::sleep_gps() {
 }
 
 bool TbeamSupSensorManager::begin() {
+  //init BME280
+    if (! bme.begin(0x77, &Wire)) {
+        MESH_DEBUG_PRINTLN("Could not find a valid BME280 sensor");
+        bme_active = false;
+    }
+    else
+      MESH_DEBUG_PRINTLN("BME280 found and init!");
+      bme_active = true;
+  
   // init GPS port
-
   Serial1.begin(GPS_BAUD_RATE, SERIAL_8N1, P_GPS_RX, P_GPS_TX);
 
-  bool result = false;
-    for ( int i = 0; i < 3; ++i) {
-      result = l76kProbe();
-      if (result) {
-        gps_active = true;
-        return result;
-      }
-    }
-  return result;
+  MESH_DEBUG_PRINTLN("Sleeping GPS for initial state");
+  sleep_gps();
+  return true;
 }
 
 bool TbeamSupSensorManager::querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) {
-  if (requester_permissions & TELEM_PERM_LOCATION) {   // does requester have permission?
+  if (requester_permissions & TELEM_PERM_LOCATION && gps_active) {   // does requester have permission?
     telemetry.addGPS(TELEM_CHANNEL_SELF, node_lat, node_lon, node_altitude);
   }
+  if (requester_permissions & TELEM_PERM_ENVIRONMENT && bme_active) {   // does requester have permission?
+    telemetry.addTemperature(TELEM_CHANNEL_SELF, node_temp);
+    telemetry.addRelativeHumidity(TELEM_CHANNEL_SELF, node_hum);
+    telemetry.addBarometricPressure(TELEM_CHANNEL_SELF, node_pres);
+    //telemetry.addAltitude(TELEM_CHANNEL_SELF, node_alt);
+  }
   return true;
 }
 
 void TbeamSupSensorManager::loop() {
-  static long next_gps_update = 0;
+  static long next_update = 0;
 
   _nmea->loop();
 
-  if (millis() > next_gps_update) {
-    if (_nmea->isValid()) {
+  if (millis() > next_update) {
+    if (_nmea->isValid() && gps_active) {
       node_lat = ((double)_nmea->getLatitude())/1000000.;
       node_lon = ((double)_nmea->getLongitude())/1000000.;
       node_altitude = ((double)_nmea->getAltitude()) / 1000.0;
-      //Serial.printf("lat %f lon %f\r\n", _lat, _lon);
+      MESH_DEBUG_PRINT("lat %f lon %f alt %f\r\n", node_lat, node_lon, node_altitude);
     }
-    next_gps_update = millis() + 1000;
+
+    //read BME280 values
+    if(bme_active){
+      //node_alt = bme.readAltitude(SEALEVELPRESSURE_HPA);
+      node_temp = bme.readTemperature();
+      node_hum = bme.readHumidity();
+      node_pres = (bme.readPressure() / 100.0F);
+    
+      #ifdef MESH_DEBUG
+      // Serial.print("Temperature = ");
+      // Serial.print(node_temp);
+      // Serial.println(" *C");
+
+      // Serial.print("Humidity = ");
+      // Serial.print(node_hum);
+      // Serial.println(" %");
+
+      // Serial.print("Pressure = ");
+      // Serial.print(node_pres);
+      // Serial.println(" hPa");
+
+      // Serial.print("Approx. Altitude = ");
+      // Serial.print(node_alt);
+      // Serial.println(" m");
+      #endif
+    }
+
+    next_update = millis() + 1000;
   }
 }
 
-int TbeamSupSensorManager::getNumSettings() const { return 1; }  // just one supported: "gps" (power switch)
+int TbeamSupSensorManager::getNumSettings() const {
+  return 1; 
+}
 
 const char* TbeamSupSensorManager::getSettingName(int i) const {
-  return i == 0 ? "gps" : NULL;
+  switch(i){
+    case 0: return "gps";
+    default: NULL;
+  }
 }
 
 const char* TbeamSupSensorManager::getSettingValue(int i) const {
-  if (i == 0) {
-    return gps_active ? "1" : "0";
+  switch(i){
+    case 0: return gps_active == true ? "1" : "0";
+    default: NULL;
   }
-  return NULL;
 }
 
 bool TbeamSupSensorManager::setSettingValue(const char* name, const char* value) {

variants/lilygo_tbeam_supreme_SX1262/target.h

@@ -8,15 +8,21 @@
 #include <helpers/AutoDiscoverRTCClock.h>
 #include <helpers/SensorManager.h>
 #include <helpers/sensors/LocationProvider.h>
+#include <Adafruit_BME280.h>
 
 class TbeamSupSensorManager: public SensorManager {
     bool gps_active = false;
+    bool bme_active = false;
     LocationProvider * _nmea;
-  
+    Adafruit_BME280 bme;
+    double node_temp, node_hum, node_pres;
+    
+    #define SEALEVELPRESSURE_HPA (1013.25)
+    
     void start_gps();
     void sleep_gps();
   public:
-    TbeamSupSensorManager(LocationProvider &nmea): _nmea(&nmea) { }
+    TbeamSupSensorManager(LocationProvider &nmea): _nmea(&nmea) {node_temp = 0; node_hum = 0; node_pres = 0;}
     bool begin() override;
     bool querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) override;
     void loop() override;
@@ -24,6 +30,11 @@ class TbeamSupSensorManager: public SensorManager {
     const char* getSettingName(int i) const override;
     const char* getSettingValue(int i) const override;
     bool setSettingValue(const char* name, const char* value) override;
+
+    #ifdef MESH_DEBUG
+    void printBMEValues();
+    #endif
+
   };
 
 extern TBeamS3SupremeBoard board;
@@ -31,6 +42,11 @@ extern WRAPPER_CLASS radio_driver;
 extern AutoDiscoverRTCClock rtc_clock;
 extern TbeamSupSensorManager sensors;
 
+#ifdef DISPLAY_CLASS
+  #include <helpers/ui/SH1106Display.h>
+  extern DISPLAY_CLASS display;
+#endif
+
 enum {
   POWERMANAGE_ONLINE  = _BV(0),
   DISPLAY_ONLINE      = _BV(1),
@@ -48,7 +64,6 @@ enum {
   OSC32768_ONLINE      = _BV(13),
 };
 
-bool power_init();
 bool radio_init();
 uint32_t radio_get_rng_seed();
 void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);

variants/lilygo_tlora_v2_1/platformio.ini

@@ -72,8 +72,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}
@@ -92,8 +90,6 @@ build_flags =
   -D BLE_PIN_CODE=123456
   -D OFFLINE_QUEUE_SIZE=256
 ;  -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}

variants/nano_g2_ultra/platformio.ini

@@ -41,8 +41,6 @@ build_flags =
   -D OFFLINE_QUEUE_SIZE=256
   -D DISPLAY_CLASS=SH1106Display
   -D PIN_BUZZER=4
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
 ;  -D MESH_PACKET_LOGGING=1
 ;  -D MESH_DEBUG=1
 build_src_filter = ${Nano_G2_Ultra.build_src_filter}

variants/picow/platformio.ini

@@ -49,8 +49,6 @@ extends = picow
 build_flags = ${picow.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 = ${picow.build_src_filter}
@@ -65,8 +63,6 @@ lib_deps = ${picow.lib_deps}
 ;   -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 = ${picow.build_src_filter}
@@ -82,8 +78,6 @@ lib_deps = ${picow.lib_deps}
 ;   -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 = ${picow.build_src_filter}

variants/promicro/platformio.ini

@@ -103,8 +103,6 @@ build_flags = ${Faketec.build_flags}
   -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 OFFLINE_QUEUE_SIZE=256
   -D DISPLAY_CLASS=SSD1306Display
 ;  -D MESH_PACKET_LOGGING=1
@@ -186,7 +184,7 @@ build_flags = ${ProMicroLLCC68.build_flags}
 ; 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>
+  +<../examples/companion_radio>
 lib_deps = ${ProMicroLLCC68.lib_deps}
   adafruit/RTClib @ ^2.1.3
   densaugeo/base64 @ ~1.4.0
@@ -198,14 +196,12 @@ build_flags = ${ProMicroLLCC68.build_flags}
   -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 OFFLINE_QUEUE_SIZE=256
 ;  -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>
+  +<../examples/companion_radio>
 lib_deps = ${ProMicroLLCC68.lib_deps}
   adafruit/RTClib @ ^2.1.3
   densaugeo/base64 @ ~1.4.0

variants/rak4631/platformio.ini

@@ -22,6 +22,8 @@ build_src_filter = ${nrf52840_base.build_src_filter}
 lib_deps =
   ${nrf52840_base.lib_deps}
   adafruit/Adafruit SSD1306 @ ^2.5.13
+  stevemarple/MicroNMEA @ ^2.0.6
+  sparkfun/SparkFun u-blox GNSS Arduino Library @ ^2.2.27
 
 [env:RAK_4631_Repeater]
 extends = rak4631
@@ -62,8 +64,6 @@ 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}
@@ -83,8 +83,27 @@ build_flags =
   -D BLE_PIN_CODE=123456
   -D BLE_DEBUG_LOGGING=1
   -D OFFLINE_QUEUE_SIZE=256
-;  -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/SSD1306Display.cpp>
+  +<helpers/nrf52/SerialBLEInterface.cpp>
+  +<../examples/companion_radio>
+lib_deps =
+  ${rak4631.lib_deps}
+  densaugeo/base64 @ ~1.4.0
+
+[env:RAK_4631_GPS_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 OFFLINE_QUEUE_SIZE=256
+  -D ENV_INCLUDE_GPS=1
 ;  -D MESH_PACKET_LOGGING=1
 ;  -D MESH_DEBUG=1
 build_src_filter = ${rak4631.build_src_filter}

variants/rak4631/target.cpp

@@ -1,6 +1,7 @@
 #include <Arduino.h>
 #include "target.h"
 #include <helpers/ArduinoHelpers.h>
+#include <helpers/sensors/MicroNMEALocationProvider.h>
 
 RAK4631Board board;
 
@@ -10,7 +11,13 @@ WRAPPER_CLASS radio_driver(radio, board);
 
 VolatileRTCClock fallback_clock;
 AutoDiscoverRTCClock rtc_clock(fallback_clock);
-SensorManager sensors;
+
+#if ENV_INCLUDE_GPS
+MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Wire);
+RAK4631SensorManager sensors = RAK4631SensorManager(nmea);
+#else
+RAK4631SensorManager sensors;
+#endif
 
 #ifdef DISPLAY_CLASS
   DISPLAY_CLASS display;
@@ -20,6 +27,52 @@ SensorManager sensors;
   #define LORA_CR      5
 #endif
 
+#ifdef MESH_DEBUG
+uint32_t deviceOnline = 0x00;
+void scanDevices(TwoWire *w)
+{
+    uint8_t err, addr;
+    int nDevices = 0;
+    uint32_t start = 0;
+
+    Serial.println("Scanning I2C for Devices");
+    for (addr = 1; addr < 127; addr++) {
+        start = millis();
+        w->beginTransmission(addr); delay(2);
+        err = w->endTransmission();
+        if (err == 0) {
+            nDevices++;
+            switch (addr) {
+            case 0x42:
+                Serial.println("\tFound RAK12500 GPS Sensor");
+                deviceOnline |= RAK12500_ONLINE;
+                break;
+            default:
+                Serial.print("\tI2C device found at address 0x");
+                if (addr < 16) {
+                    Serial.print("0");
+                }
+                Serial.print(addr, HEX);
+                Serial.println(" !");
+                break;
+            }
+
+        } else if (err == 4) {
+            Serial.print("Unknow error at address 0x");
+            if (addr < 16) {
+                Serial.print("0");
+            }
+            Serial.println(addr, HEX);
+        }
+    }
+    if (nDevices == 0)
+        Serial.println("No I2C devices found\n");
+
+    Serial.println("Scan for devices is complete.");
+    Serial.println("\n");
+}
+#endif
+
 bool radio_init() {
   rtc_clock.begin(Wire);
   
@@ -68,6 +121,142 @@ void radio_set_tx_power(uint8_t dbm) {
   radio.setOutputPower(dbm);
 }
 
+#if ENV_INCLUDE_GPS
+void RAK4631SensorManager::start_gps()
+{
+  //function currently not used
+  gps_active = true;
+  pinMode(disStandbyPin, OUTPUT);
+  digitalWrite(disStandbyPin, 1);
+  MESH_DEBUG_PRINTLN("GPS should be on now");
+}
+
+void RAK4631SensorManager::stop_gps()
+{
+  //function currently not used
+  gps_active = false;
+  pinMode(disStandbyPin, OUTPUT);
+  digitalWrite(disStandbyPin, 0);
+  MESH_DEBUG_PRINTLN("GPS should be off now");
+}
+
+void RAK4631SensorManager::sleep_gps() {
+  gps_active = false;
+  ublox_GNSS.powerSaveMode();
+  MESH_DEBUG_PRINTLN("GPS should be sleeping now");
+}
+
+void RAK4631SensorManager::wake_gps() {
+  gps_active = true;
+  ublox_GNSS.powerSaveMode(false);
+  MESH_DEBUG_PRINTLN("GPS should be waking now");
+}
+
+bool RAK4631SensorManager::gpsIsAwake(uint32_t ioPin){
+  
+  int pinInitialState = 0;
+
+  //set initial waking state
+  pinMode(ioPin,OUTPUT);
+  digitalWrite(ioPin,0);
+  delay(1000);
+  digitalWrite(ioPin,1);
+  delay(1000);
+
+  if (ublox_GNSS.begin(Wire) == true){
+    MESH_DEBUG_PRINTLN("GPS init correctly and GPS is turned on");
+    ublox_GNSS.setI2COutput(COM_TYPE_NMEA);
+    ublox_GNSS.saveConfigSelective(VAL_CFG_SUBSEC_IOPORT);
+    disStandbyPin = ioPin;
+    gps_active = true;
+    gps_present = true;
+    return true;
+  }
+  else
+  MESH_DEBUG_PRINTLN("GPS failed to init on this IO pin... try the next");
+  //digitalWrite(ioPin,pinInitialState); //reset the IO pin to initial state
+  return false;
+}
+#endif
+
+bool RAK4631SensorManager::begin() {
+  
+  #ifdef MESH_DEBUG
+  scanDevices(&Wire);
+  #endif
+
+#if ENV_INCLUDE_GPS
+  //search for the correct IO standby pin depending on socket used
+  if(gpsIsAwake(P_GPS_STANDBY_A)){
+    MESH_DEBUG_PRINTLN("GPS is on socket A");
+  }
+  else if(gpsIsAwake(P_GPS_STANDBY_C)){
+    MESH_DEBUG_PRINTLN("GPS is on socket C"); 
+  }
+  else if(gpsIsAwake(P_GPS_STANDBY_F)){
+    MESH_DEBUG_PRINTLN("GPS is on socket F"); 
+  }
+  else{
+    MESH_DEBUG_PRINTLN("Error: No GPS found on sockets A, C or F"); 
+    gps_active = false;
+    gps_present = false;
+    return false;
+  }
+
+  //Now that GPS is found and set up, set to sleep for initial state
+  stop_gps();
+#endif
+}
+
+#if ENV_INCLUDE_GPS
+bool RAK4631SensorManager::querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) {
+  if (requester_permissions & TELEM_PERM_LOCATION && gps_active) {   // does requester have permission?
+    telemetry.addGPS(TELEM_CHANNEL_SELF, node_lat, node_lon, node_altitude);
+  }
+  return true;
+}
+
+void RAK4631SensorManager::loop() {
+  static long next_update = 0;
+  
+  _nmea->loop();
+
+  if (millis() > next_update && gps_active) {
+    node_lat = (double)ublox_GNSS.getLatitude()/10000000.;
+    node_lon = (double)ublox_GNSS.getLongitude()/10000000.;
+    node_altitude = (double)ublox_GNSS.getAltitude()/1000.;
+    MESH_DEBUG_PRINT("lat %f lon %f alt %f\r\n", node_lat, node_lon, node_altitude);
+    
+    next_update = millis() + 1000;
+  }
+}
+
+int RAK4631SensorManager::getNumSettings() const { return 1; }  // just one supported: "gps" (power switch)
+
+const char* RAK4631SensorManager::getSettingName(int i) const {
+  return i == 0 ? "gps" : NULL;
+}
+
+const char* RAK4631SensorManager::getSettingValue(int i) const {
+  if (i == 0) {
+    return gps_active ? "1" : "0";
+  }
+  return NULL;
+}
+
+bool RAK4631SensorManager::setSettingValue(const char* name, const char* value) {
+  if (strcmp(name, "gps") == 0) {
+    if (strcmp(value, "0") == 0) {
+      stop_gps();
+    } else {
+      start_gps();
+    }
+    return true;
+  }
+  return false;  // not supported
+}
+#endif
+
 mesh::LocalIdentity radio_new_identity() {
   RadioNoiseListener rng(radio);
   return mesh::LocalIdentity(&rng);  // create new random identity

variants/rak4631/target.h

@@ -7,19 +7,74 @@
 #include <helpers/CustomSX1262Wrapper.h>
 #include <helpers/AutoDiscoverRTCClock.h>
 #include <helpers/SensorManager.h>
+#if ENV_INCLUDE_GPS
+  #include <helpers/sensors/LocationProvider.h>
+  #include <SparkFun_u-blox_GNSS_Arduino_Library.h>
+#endif
 #ifdef DISPLAY_CLASS
   #include <helpers/ui/SSD1306Display.h>
 #endif
 
+#define _BV(x)   (1 << x)
+
+class RAK4631SensorManager: public SensorManager {
+  #if ENV_INCLUDE_GPS
+    bool gps_active = false;
+    bool gps_present = false;
+    LocationProvider * _nmea;
+    SFE_UBLOX_GNSS ublox_GNSS;
+    uint32_t disStandbyPin = 0;
+  
+    void start_gps();
+    void stop_gps();
+    void sleep_gps();
+    void wake_gps();
+    bool gpsIsAwake(uint32_t ioPin);
+  #endif
+
+  public:
+  #if ENV_INCLUDE_GPS
+    RAK4631SensorManager(LocationProvider &nmea): _nmea(&nmea) { }
+
+    bool querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) override;
+    void loop() override;
+    int getNumSettings() const override;
+    const char* getSettingName(int i) const override;
+    const char* getSettingValue(int i) const override;
+    bool setSettingValue(const char* name, const char* value) override;
+  #else
+    RAK4631SensorManager() { }
+  #endif
+    bool begin() override;
+};
+
 extern RAK4631Board board;
 extern WRAPPER_CLASS radio_driver;
 extern AutoDiscoverRTCClock rtc_clock;
-extern SensorManager sensors;
+extern RAK4631SensorManager sensors;
 
 #ifdef DISPLAY_CLASS
   extern DISPLAY_CLASS display;
 #endif
 
+enum {
+  POWERMANAGE_ONLINE  = _BV(0),
+  DISPLAY_ONLINE      = _BV(1),
+  RADIO_ONLINE        = _BV(2),
+  GPS_ONLINE          = _BV(3),
+  PSRAM_ONLINE        = _BV(4),
+  SDCARD_ONLINE       = _BV(5),
+  AXDL345_ONLINE      = _BV(6),
+  BME280_ONLINE       = _BV(7),
+  BMP280_ONLINE       = _BV(8),
+  BME680_ONLINE       = _BV(9),
+  QMC6310_ONLINE      = _BV(10),
+  QMI8658_ONLINE      = _BV(11),
+  PCF8563_ONLINE      = _BV(12),
+  OSC32768_ONLINE     = _BV(13),
+  RAK12500_ONLINE     = _BV(14),
+};
+
 bool radio_init();
 uint32_t radio_get_rng_seed();
 void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);

variants/station_g2/platformio.ini

@@ -9,18 +9,23 @@ build_flags =
   -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 PIN_BOARD_SDA=5
+  -D PIN_BOARD_SCL=6
+  -D PIN_USER_BTN=38
   -D SX126X_DIO2_AS_RF_SWITCH=true
   -D SX126X_DIO3_TCXO_VOLTAGE=1.8
   -D SX126X_CURRENT_LIMIT=140
 ;  -D SX126X_RX_BOOSTED_GAIN=1 - DO NOT ENABLE THIS!
+  -I src/helpers/ui
+  -D DISPLAY_CLASS=SH1106Display
 ;  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>
+  +<helpers/ui/SH1106Display.cpp>
 lib_deps =
   ${esp32_base.lib_deps}
+  adafruit/Adafruit SH110X @ ~2.1.13
+  adafruit/Adafruit GFX Library @ ^1.12.1
 
 [env:Station_G2_repeater]
 extends = Station_G2

variants/station_g2/target.cpp

@@ -16,6 +16,10 @@ ESP32RTCClock fallback_clock;
 AutoDiscoverRTCClock rtc_clock(fallback_clock);
 SensorManager sensors;
 
+#ifdef DISPLAY_CLASS
+  DISPLAY_CLASS display;
+#endif
+
 #ifndef LORA_CR
   #define LORA_CR      5
 #endif

variants/station_g2/target.h

@@ -8,11 +8,19 @@
 #include <helpers/AutoDiscoverRTCClock.h>
 #include <helpers/SensorManager.h>
 
+#ifdef DISPLAY_CLASS
+  #include <helpers/ui/SH1106Display.h>
+#endif
+
 extern StationG2Board board;
 extern WRAPPER_CLASS radio_driver;
 extern AutoDiscoverRTCClock rtc_clock;
 extern SensorManager sensors;
 
+#ifdef DISPLAY_CLASS
+  extern DISPLAY_CLASS display;
+#endif
+
 bool radio_init();
 uint32_t radio_get_rng_seed();
 void radio_set_params(float freq, float bw, uint8_t sf, uint8_t cr);

variants/t1000-e/t1000e_sensors.cpp

@@ -0,0 +1,119 @@
+#include <Arduino.h>
+#include "t1000e_sensors.h"
+
+#define HEATER_NTC_BX       4250    // thermistor coefficient B
+#define HEATER_NTC_RP       8250    // ohm, series resistance to thermistor
+#define HEATER_NTC_KA       273.15  // 25 Celsius at Kelvin
+#define NTC_REF_VCC         3000    // mV, output voltage of LDO
+#define LIGHT_REF_VCC       2400    // 
+ 
+static unsigned int ntc_res2[136]={    
+    113347,107565,102116,96978,92132,87559,83242,79166,75316,71677,
+    68237,64991,61919,59011,56258,53650,51178,48835,46613,44506,
+    42506,40600,38791,37073,35442,33892,32420,31020,29689,28423,
+    27219,26076,24988,23951,22963,22021,21123,20267,19450,18670,                               
+    17926,17214,16534,15886,15266,14674,14108,13566,13049,12554,
+    12081,11628,11195,10780,10382,10000,9634,9284,8947,8624,
+    8315,8018,7734,7461,7199,6948,6707,6475,6253,6039,
+    5834,5636,5445,5262,5086,4917,4754,4597,4446,4301,
+    4161,4026,3896,3771,3651,3535,3423,3315,3211,3111,
+    3014,2922,2834,2748,2666,2586,2509,2435,2364,2294,
+    2228,2163,2100,2040,1981,1925,1870,1817,1766,1716,
+    1669,1622,1578,1535,1493,1452,1413,1375,1338,1303,
+    1268,1234,1202,1170,1139,1110,1081,1053,1026,999,
+    974,949,925,902,880,858,
+};
+ 
+static char ntc_temp2[136]=
+{
+    -30,-29,-28,-27,-26,-25,-24,-23,-22,-21,
+    -20,-19,-18,-17,-16,-15,-14,-13,-12,-11,
+    -10,-9,-8,-7,-6,-5,-4,-3,-2,-1,
+    0,1,2,3,4,5,6,7,8,9,
+    10,11,12,13,14,15,16,17,18,19,
+    20,21,22,23,24,25,26,27,28,29,
+    30,31,32,33,34,35,36,37,38,39,
+    40,41,42,43,44,45,46,47,48,49,
+    50,51,52,53,54,55,56,57,58,59,
+    60,61,62,63,64,65,66,67,68,69,
+    70,71,72,73,74,75,76,77,78,79,
+    80,81,82,83,84,85,86,87,88,89,
+    90,91,92,93,94,95,96,97,98,99,
+    100,101,102,103,104,105,
+};
+
+static float get_heater_temperature( unsigned int vcc_volt, unsigned int ntc_volt )
+{
+    int i = 0;
+    float Vout = 0, Rt = 0, temp = 0;
+    Vout = ntc_volt;
+    
+    Rt = ( HEATER_NTC_RP * vcc_volt ) / Vout - HEATER_NTC_RP;   
+        
+    for( i = 0; i < 136; i++ )
+    {
+        if( Rt >= ntc_res2[i] )
+        {
+           break; 
+        }
+    }
+ 
+    temp = ntc_temp2[i - 1] + 1 * ( ntc_res2[i - 1] - Rt ) / ( float )( ntc_res2[i - 1] - ntc_res2[i] );
+ 
+    temp = ( temp * 100 + 5 ) / 100;
+    return temp;
+}
+
+static int get_light_lv( unsigned int light_volt )
+{  
+    float Vout = 0, Vin = 0, Rt = 0, temp = 0;
+    unsigned int light_level = 0;     
+    
+    if( light_volt <= 80 )
+    {
+        light_level = 0;
+        return light_level;
+    }
+    else if( light_volt >= 2480 )
+    {
+        light_level = 100;
+        return light_level;    
+    }
+    Vout = light_volt;
+    light_level = 100 * ( Vout - 80 ) / LIGHT_REF_VCC;
+   
+    return light_level;
+} 
+
+float t1000e_get_temperature( void )
+{
+    unsigned int ntc_v, vcc_v;
+
+    digitalWrite(PIN_3V3_EN, HIGH);
+    digitalWrite(SENSOR_EN, HIGH);
+    analogReference(AR_INTERNAL_3_0);
+    analogReadResolution(12);
+    delay(10);
+    vcc_v = (1000.0*(analogRead(BATTERY_PIN) * ADC_MULTIPLIER * AREF_VOLTAGE)) / 4096;
+    ntc_v = (1000.0 * AREF_VOLTAGE * analogRead(TEMP_SENSOR)) / 4096;
+    digitalWrite(PIN_3V3_EN, LOW);
+    digitalWrite(SENSOR_EN, LOW);
+
+    return get_heater_temperature (vcc_v, ntc_v);
+}
+
+uint32_t t1000e_get_light( void )
+{
+    int lux = 0;
+    unsigned int lux_v = 0;
+ 
+    digitalWrite(SENSOR_EN, HIGH);
+    analogReference(AR_INTERNAL_3_0);
+    analogReadResolution(12);
+    delay(10);
+    lux_v = 1000 * analogRead(LUX_SENSOR) * AREF_VOLTAGE / 4096;
+    lux = get_light_lv( lux_v );
+    digitalWrite(SENSOR_EN, LOW);
+ 
+    return lux;
+}

variants/t1000-e/t1000e_sensors.h

@@ -0,0 +1,8 @@
+#pragma once
+
+// Light and temperature sensors are on ADC ports
+// functions adapted from Seeed examples to get values 
+// see : https://github.com/Seeed-Studio/Seeed-Tracker-T1000-E-for-LoRaWAN-dev-board
+
+extern uint32_t t1000e_get_light();
+extern float t1000e_get_temperature();

variants/t1000-e/target.cpp

@@ -1,4 +1,5 @@
 #include <Arduino.h>
+#include "t1000e_sensors.h"
 #include "target.h"
 #include <helpers/sensors/MicroNMEALocationProvider.h>
 
@@ -9,7 +10,7 @@ RADIO_CLASS radio = new Module(P_LORA_NSS, P_LORA_DIO_1, P_LORA_RESET, P_LORA_BU
 WRAPPER_CLASS radio_driver(radio, board);
 
 VolatileRTCClock rtc_clock;
-MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Serial1);
+MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Serial1, &rtc_clock);
 T1000SensorManager sensors = T1000SensorManager(nmea);
 
 #ifdef DISPLAY_CLASS
@@ -160,6 +161,10 @@ bool T1000SensorManager::querySensors(uint8_t requester_permissions, CayenneLPP&
   if (requester_permissions & TELEM_PERM_LOCATION) {   // does requester have permission?
     telemetry.addGPS(TELEM_CHANNEL_SELF, node_lat, node_lon, node_altitude);
   }
+  if (requester_permissions & TELEM_PERM_ENVIRONMENT) {
+    telemetry.addLuminosity(TELEM_CHANNEL_SELF, t1000e_get_light());
+    telemetry.addTemperature(TELEM_CHANNEL_SELF, t1000e_get_temperature());
+  }
   return true;
 }
 

variants/t114/platformio.ini

@@ -70,17 +70,14 @@ build_flags =
   -D MAX_CONTACTS=100
   -D MAX_GROUP_CHANNELS=8
   -D BLE_PIN_CODE=123456
-  -D BLE_DEBUG_LOGGING=1
+;  -D BLE_DEBUG_LOGGING=1
   -D OFFLINE_QUEUE_SIZE=256
-;  -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/T114Board.cpp>
   +<helpers/nrf52/SerialBLEInterface.cpp>
-  +<../examples/companion_radio/main.cpp>
-  +<../examples/companion_radio/UITask.cpp>
+  +<../examples/companion_radio>
   +<helpers/ui/ST7789Display.cpp>
   +<helpers/ui/OLEDDisplay.cpp>
   +<helpers/ui/OLEDDisplayFonts.cpp>
@@ -97,13 +94,11 @@ build_flags =
   -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>
+  +<../examples/companion_radio>
 lib_deps =
   ${Heltec_t114.lib_deps}
   densaugeo/base64 @ ~1.4.0

variants/techo/platformio.ini

@@ -25,6 +25,9 @@ build_src_filter = ${nrf52840_techo.build_src_filter}
   +<helpers/*.cpp>
   +<helpers/nrf52/TechoBoard.cpp>
   +<../variants/techo>
+lib_deps =
+  ${nrf52840_techo.lib_deps}
+  stevemarple/MicroNMEA @ ^2.0.6
 debug_tool = jlink
 upload_protocol = nrfutil
 
@@ -64,8 +67,6 @@ build_flags =
   -D BLE_DEBUG_LOGGING=1
   -D DISPLAY_CLASS=GxEPDDisplay
   -D OFFLINE_QUEUE_SIZE=256
-;  -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}

variants/techo/target.cpp

@@ -1,6 +1,7 @@
 #include <Arduino.h>
 #include "target.h"
 #include <helpers/ArduinoHelpers.h>
+#include <helpers/sensors/MicroNMEALocationProvider.h>
 
 TechoBoard board;
 
@@ -10,7 +11,8 @@ WRAPPER_CLASS radio_driver(radio, board);
 
 VolatileRTCClock fallback_clock;
 AutoDiscoverRTCClock rtc_clock(fallback_clock);
-SensorManager sensors;
+MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Serial1);
+TechoSensorManager sensors = TechoSensorManager(nmea);
 
 #ifdef DISPLAY_CLASS
   DISPLAY_CLASS display;
@@ -72,3 +74,80 @@ mesh::LocalIdentity radio_new_identity() {
   RadioNoiseListener rng(radio);
   return mesh::LocalIdentity(&rng);  // create new random identity
 }
+
+void TechoSensorManager::start_gps() {
+  if (!gps_active) {
+    gps_active = true;
+    _location->begin();
+  }
+}
+
+void TechoSensorManager::stop_gps() {
+  if (gps_active) {
+    gps_active = false;
+    _location->stop();
+  }
+}
+
+bool TechoSensorManager::begin() {
+  Serial1.begin(9600);
+
+  // GPS enabled pin
+  pinMode(GPS_EN, OUTPUT);
+  
+  return true;
+}
+
+bool TechoSensorManager::querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) {
+  if (requester_permissions & TELEM_PERM_LOCATION) {   // does requester have permission?
+    telemetry.addGPS(TELEM_CHANNEL_SELF, node_lat, node_lon, node_altitude);
+  }
+  return true;
+}
+
+void TechoSensorManager::loop() {
+  static long next_gps_update = 0;
+  
+  if (!gps_active) {
+    return;  // GPS is not active, skip further processing
+  }
+
+  _location->loop();
+
+  if (millis() > next_gps_update) {
+    if (_location->isValid()) {
+      node_lat = ((double)_location->getLatitude())/1000000.;
+      node_lon = ((double)_location->getLongitude())/1000000.;
+      node_altitude = ((double)_location->getAltitude()) / 1000.0;
+      MESH_DEBUG_PRINTLN("lat %f lon %f", node_lat, node_lon);
+    }
+    next_gps_update = millis() + 1000;
+  }
+}
+
+int TechoSensorManager::getNumSettings() const {
+  return 1;  // always show GPS setting
+}
+
+const char* TechoSensorManager::getSettingName(int i) const {
+  return (i == 0) ? "gps" : NULL;
+}
+
+const char* TechoSensorManager::getSettingValue(int i) const {
+  if (i == 0) {
+    return gps_active ? "1" : "0";
+  }
+  return NULL;
+}
+
+bool TechoSensorManager::setSettingValue(const char* name, const char* value) {
+  if (strcmp(name, "gps") == 0) {
+    if (strcmp(value, "0") == 0) {
+      stop_gps();
+    } else {
+      start_gps();
+    }
+    return true;
+  }
+  return false;  // not supported
+}

variants/techo/target.h

@@ -7,15 +7,32 @@
 #include <helpers/CustomSX1262Wrapper.h>
 #include <helpers/AutoDiscoverRTCClock.h>
 #include <helpers/SensorManager.h>
+#include <helpers/sensors/LocationProvider.h>
 #ifdef DISPLAY_CLASS
   #include <helpers/ui/GxEPDDisplay.h>
 #endif
 
+class TechoSensorManager : public SensorManager {
+  bool gps_active = false;
+  LocationProvider* _location;
+
+  void start_gps();
+  void stop_gps();
+public:
+  TechoSensorManager(LocationProvider &location): _location(&location) { }
+  bool begin() override;
+  bool querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) override;
+  void loop() override;
+  int getNumSettings() const override;
+  const char* getSettingName(int i) const override;
+  const char* getSettingValue(int i) const override;
+  bool setSettingValue(const char* name, const char* value) override;
+};
 
 extern TechoBoard board;
 extern WRAPPER_CLASS radio_driver;
 extern AutoDiscoverRTCClock rtc_clock;
-extern SensorManager sensors;
+extern TechoSensorManager sensors;
 
 #ifdef DISPLAY_CLASS
   extern DISPLAY_CLASS display;

variants/techo/variant.cpp

@@ -29,6 +29,6 @@ void initVariant() {
   digitalWrite(PIN_TXCO, HIGH);
 
   // shutdown gps
-  pinMode(PIN_GPS_STANDBY, OUTPUT);
-  digitalWrite(PIN_GPS_STANDBY, LOW);
+  pinMode(GPS_EN, OUTPUT);
+  digitalWrite(GPS_EN, LOW);
 }

variants/techo/variant.h

@@ -40,8 +40,8 @@
 ////////////////////////////////////////////////////////////////////////////////
 // UART pin definition
 
-#define PIN_SERIAL1_RX          (41) // GPS TX
-#define PIN_SERIAL1_TX          (40) // GPS RX
+#define PIN_SERIAL1_RX          PIN_GPS_TX
+#define PIN_SERIAL1_TX          PIN_GPS_RX
 ////////////////////////////////////////////////////////////////////////////////
 // I2C pin definition
 
@@ -125,9 +125,8 @@ extern const int SCK;
 ////////////////////////////////////////////////////////////////////////////////
 // GPS
 
-#define PIN_GPS_RX              (41)
-#define PIN_GPS_TX              (40)
-#define PIN_GPS_WAKEUP          (34)
+#define PIN_GPS_RX              (40)
+#define PIN_GPS_TX              (41)
+#define GPS_EN                  (34)
 #define PIN_GPS_RESET           (37)
 #define PIN_GPS_PPS             (36)
-#define PIN_GPS_STANDBY         (34)

variants/thinknode_m1/platformio.ini

@@ -25,6 +25,9 @@ build_src_filter = ${nrf52840_thinknode_m1.build_src_filter}
   +<helpers/*.cpp>
   +<helpers/nrf52/ThinkNodeM1Board.cpp>
   +<../variants/thinknode_m1>
+lib_deps =
+  ${nrf52840_thinknode_m1.lib_deps}
+  stevemarple/MicroNMEA @ ^2.0.6
 debug_tool = jlink
 upload_protocol = nrfutil
 
@@ -71,16 +74,17 @@ build_flags =
   -D DISPLAY_ROTATION=4
   -D DISPLAY_CLASS=GxEPDDisplay
   -D OFFLINE_QUEUE_SIZE=256
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
-;  -D ENABLE_PRIVATE_KEY_EXPORT=1
+  -D PIN_BUZZER=6
 ;  -D MESH_PACKET_LOGGING=1
 ;  -D MESH_DEBUG=1
 build_src_filter = ${ThinkNode_M1.build_src_filter}
   +<helpers/nrf52/ThinkNodeM1.cpp>
   +<helpers/nrf52/SerialBLEInterface.cpp>
   +<helpers/ui/GxEPDDisplay.cpp>
+  +<helpers/ui/buzzer.cpp>
   +<../examples/companion_radio>
 lib_deps =
   ${ThinkNode_M1.lib_deps}
   densaugeo/base64 @ ~1.4.0
   zinggjm/GxEPD2 @ 1.6.2
+  end2endzone/NonBlockingRTTTL@^1.3.0

variants/thinknode_m1/target.cpp

@@ -1,6 +1,7 @@
 #include <Arduino.h>
 #include "target.h"
 #include <helpers/ArduinoHelpers.h>
+#include <helpers/sensors/MicroNMEALocationProvider.h>
 
 ThinkNodeM1Board board;
 
@@ -10,7 +11,8 @@ WRAPPER_CLASS radio_driver(radio, board);
 
 VolatileRTCClock fallback_clock;
 AutoDiscoverRTCClock rtc_clock(fallback_clock);
-SensorManager sensors;
+MicroNMEALocationProvider nmea = MicroNMEALocationProvider(Serial1);
+ThinkNodeM1SensorManager sensors = ThinkNodeM1SensorManager(nmea);
 
 #ifdef DISPLAY_CLASS
   DISPLAY_CLASS display;
@@ -72,3 +74,110 @@ mesh::LocalIdentity radio_new_identity() {
   RadioNoiseListener rng(radio);
   return mesh::LocalIdentity(&rng);  // create new random identity
 }
+
+void ThinkNodeM1SensorManager::start_gps() {
+  if (!gps_active) {
+    gps_active = true;
+    _location->begin();
+  }
+}
+
+void ThinkNodeM1SensorManager::stop_gps() {
+  if (gps_active) {
+    gps_active = false;
+    _location->stop();
+  }
+}
+
+bool ThinkNodeM1SensorManager::begin() {
+  Serial1.begin(9600);
+
+  // Initialize GPS switch pin
+  pinMode(PIN_GPS_SWITCH, INPUT);
+  last_gps_switch_state = digitalRead(PIN_GPS_SWITCH);
+
+  // Initialize GPS power pin
+  pinMode(GPS_EN, OUTPUT);
+
+  // Check initial switch state to determine if GPS should be active
+  if (last_gps_switch_state == HIGH) {  // Switch is HIGH when ON
+    start_gps();
+  }
+
+  return true;
+}
+
+bool ThinkNodeM1SensorManager::querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) {
+  if (requester_permissions & TELEM_PERM_LOCATION) {   // does requester have permission?
+    telemetry.addGPS(TELEM_CHANNEL_SELF, node_lat, node_lon, node_altitude);
+  }
+  return true;
+}
+
+void ThinkNodeM1SensorManager::loop() {
+  static long next_gps_update = 0;
+  static long last_switch_check = 0;
+
+  // Check GPS switch state every second
+  if (millis() - last_switch_check > 1000) {
+    bool current_switch_state = digitalRead(PIN_GPS_SWITCH);
+    
+    // Detect switch state change
+    if (current_switch_state != last_gps_switch_state) {
+      last_gps_switch_state = current_switch_state;
+      
+      if (current_switch_state == HIGH) {  // Switch is ON
+        MESH_DEBUG_PRINTLN("GPS switch ON");
+        start_gps();
+      } else {  // Switch is OFF
+        MESH_DEBUG_PRINTLN("GPS switch OFF");
+        stop_gps();
+      }
+    }
+    
+    last_switch_check = millis();
+  }
+
+  if (!gps_active) {
+    return;  // GPS is not active, skip further processing
+  }
+
+  _location->loop();
+
+  if (millis() > next_gps_update) {
+    if (_location->isValid()) {
+      node_lat = ((double)_location->getLatitude())/1000000.;
+      node_lon = ((double)_location->getLongitude())/1000000.;
+      node_altitude = ((double)_location->getAltitude()) / 1000.0;
+      MESH_DEBUG_PRINTLN("lat %f lon %f", node_lat, node_lon);
+    }
+    next_gps_update = millis() + 1000;
+  }
+}
+
+int ThinkNodeM1SensorManager::getNumSettings() const {
+  return 1;  // always show GPS setting
+}
+
+const char* ThinkNodeM1SensorManager::getSettingName(int i) const {
+  return (i == 0) ? "gps" : NULL;
+}
+
+const char* ThinkNodeM1SensorManager::getSettingValue(int i) const {
+  if (i == 0) {
+    return gps_active ? "1" : "0";
+  }
+  return NULL;
+}
+
+bool ThinkNodeM1SensorManager::setSettingValue(const char* name, const char* value) {
+  if (strcmp(name, "gps") == 0) {
+    if (strcmp(value, "0") == 0) {
+      stop_gps();
+    } else {
+      start_gps();
+    }
+    return true;
+  }
+  return false;  // not supported
+}

variants/thinknode_m1/target.h

@@ -7,14 +7,33 @@
 #include <helpers/CustomSX1262Wrapper.h>
 #include <helpers/AutoDiscoverRTCClock.h>
 #include <helpers/SensorManager.h>
+#include <helpers/sensors/LocationProvider.h>
 #ifdef DISPLAY_CLASS
   #include <helpers/ui/GxEPDDisplay.h>
 #endif
 
+class ThinkNodeM1SensorManager : public SensorManager {
+  bool gps_active = false;
+  bool last_gps_switch_state = false;
+  LocationProvider* _location;
+
+  void start_gps();
+  void stop_gps();
+public:
+  ThinkNodeM1SensorManager(LocationProvider &location): _location(&location) { }
+  bool begin() override;
+  bool querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) override;
+  void loop() override;
+  int getNumSettings() const override;
+  const char* getSettingName(int i) const override;
+  const char* getSettingValue(int i) const override;
+  bool setSettingValue(const char* name, const char* value) override;
+};
+
 extern ThinkNodeM1Board board;
 extern WRAPPER_CLASS radio_driver;
 extern AutoDiscoverRTCClock rtc_clock;
-extern SensorManager sensors;
+extern ThinkNodeM1SensorManager sensors;
 
 #ifdef DISPLAY_CLASS
   extern DISPLAY_CLASS display;

variants/thinknode_m1/variant.h

@@ -40,8 +40,8 @@
 ////////////////////////////////////////////////////////////////////////////////
 // UART pin definition
 
-#define PIN_SERIAL1_RX          (41) // GPS TX
-#define PIN_SERIAL1_TX          (40) // GPS RX
+#define PIN_SERIAL1_RX          PIN_GPS_TX
+#define PIN_SERIAL1_TX          PIN_GPS_RX
 ////////////////////////////////////////////////////////////////////////////////
 // I2C pin definition
 
@@ -125,9 +125,10 @@ extern const int SCK;
 ////////////////////////////////////////////////////////////////////////////////
 // GPS
 
-#define PIN_GPS_RX              (41)
-#define PIN_GPS_TX              (40)
-#define PIN_GPS_WAKEUP          (34)
+#define PIN_GPS_RX              (40)
+#define PIN_GPS_TX              (41)
+#define GPS_EN                  (34)
 #define PIN_GPS_RESET           (37)
 #define PIN_GPS_PPS             (36)
 #define PIN_GPS_STANDBY         (34)
+#define PIN_GPS_SWITCH          (33)

variants/wio-e5-dev/platformio.ini

@@ -7,9 +7,9 @@ build_flags = ${stm32_base.build_flags}
   -D WRAPPER_CLASS=CustomSTM32WLxWrapper
   -D SPI_INTERFACES_COUNT=0
   -D RX_BOOSTED_GAIN=true
-  -I variants/wio-e5
+  -I variants/wio-e5-dev
 build_src_filter = ${stm32_base.build_src_filter}
-  +<../variants/wio-e5>
+  +<../variants/wio-e5-dev>
 
 [env:wio-e5-repeater]
 extends = lora_e5

variants/wio-e5-dev/target.h

@@ -11,7 +11,13 @@
 class WIOE5Board : public STM32Board {
 public:
     const char* getManufacturerName() const override {
-        return "Seeed Wio E5";
+        return "Seeed Wio E5 Dev Board";
+    }
+
+    // Just returns ADC value for now to test adc
+    uint16_t getBattMilliVolts() override {
+        uint32_t raw = analogRead(PIN_A3);            
+        return raw;
     }
 };
 

variants/wio-e5-dev/variant.h

@@ -0,0 +1,10 @@
+#pragma once
+
+// UART Definitions
+// #ifndef SERIAL_UART_INSTANCE
+//   #define SERIAL_UART_INSTANCE  101
+// #endif
+
+#include <variant_generic.h>
+
+#undef RNG

variants/wio-e5-mini/platformio.ini

@@ -0,0 +1,34 @@
+[lora_e5_mini]
+extends = stm32_base
+board = lora_e5_mini
+board_upload.maximum_size = 229376 ; 32kb for FS
+build_flags = ${stm32_base.build_flags}
+  -D RADIO_CLASS=CustomSTM32WLx
+  -D WRAPPER_CLASS=CustomSTM32WLxWrapper
+  -D SPI_INTERFACES_COUNT=0
+  -D RX_BOOSTED_GAIN=true
+  -I variants/wio-e5-mini
+build_src_filter = ${stm32_base.build_src_filter}
+  +<../variants/wio-e5-mini>
+lib_deps = ${stm32_base.lib_deps}
+  finitespace/BME280 @ ^3.0.0
+
+[env:wio-e5-mini-repeater]
+extends = lora_e5_mini
+build_flags = ${lora_e5_mini.build_flags}
+  -D LORA_TX_POWER=22
+  -D ADVERT_NAME='"wio-e5-mini Repeater"'
+  -D ADMIN_PASSWORD='"password"'
+build_src_filter = ${lora_e5_mini.build_src_filter}
+  +<../examples/simple_repeater/main.cpp>
+
+[env:wio-e5-mini_companion_radio_usb]
+extends = lora_e5_mini
+build_flags = ${lora_e5_mini.build_flags}
+  -D LORA_TX_POWER=22
+  -D MAX_CONTACTS=100
+  -D MAX_GROUP_CHANNELS=8
+build_src_filter = ${lora_e5_mini.build_src_filter}
+  +<../examples/companion_radio/*.cpp>
+lib_deps = ${lora_e5_mini.lib_deps}
+  densaugeo/base64 @ ~1.4.0

variants/wio-e5-mini/target.cpp

@@ -0,0 +1,90 @@
+#include <Arduino.h>
+#include "target.h"
+#include <helpers/ArduinoHelpers.h>
+
+WIOE5Board board;
+
+RADIO_CLASS radio = new STM32WLx_Module();
+
+WRAPPER_CLASS radio_driver(radio, board);
+
+static const uint32_t rfswitch_pins[] = {PA4,  PA5,  RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC};
+static const Module::RfSwitchMode_t rfswitch_table[] = {
+  {STM32WLx::MODE_IDLE,  {LOW,  LOW}},
+  {STM32WLx::MODE_RX,    {HIGH, LOW}},
+  {STM32WLx::MODE_TX_HP, {LOW, HIGH}},  // for LoRa-E5 mini
+//  {STM32WLx::MODE_TX_LP, {HIGH, HIGH}},   // for LoRa-E5-LE mini
+  END_OF_MODE_TABLE,
+};
+
+VolatileRTCClock rtc_clock;
+WIOE5SensorManager sensors;
+
+#ifndef LORA_CR
+  #define LORA_CR      5
+#endif
+
+bool radio_init() {
+  Wire.begin();
+
+  radio.setRfSwitchTable(rfswitch_pins, rfswitch_table);
+
+  int status = radio.begin(LORA_FREQ, LORA_BW, LORA_SF, LORA_CR, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, LORA_TX_POWER, 8, 1.7, 0);
+
+  if (status != RADIOLIB_ERR_NONE) {
+    Serial.print("ERROR: radio init failed: ");
+    Serial.println(status);
+    return false;  // fail
+  }
+    
+  #ifdef RX_BOOSTED_GAIN
+    radio.setRxBoostedGainMode(RX_BOOSTED_GAIN);
+  #endif
+ 
+  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
+}
+
+bool WIOE5SensorManager::querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) { 
+  if (!has_bme) return false;
+
+  float temp(NAN), hum(NAN), pres(NAN);
+
+  BME280::TempUnit tempUnit(BME280::TempUnit_Celsius);
+  BME280::PresUnit presUnit(BME280::PresUnit_hPa);
+
+  bme.read(pres, temp, hum, tempUnit, presUnit);
+
+  telemetry.addTemperature(TELEM_CHANNEL_SELF, temp);
+  telemetry.addRelativeHumidity(TELEM_CHANNEL_SELF, hum);
+  telemetry.addBarometricPressure(TELEM_CHANNEL_SELF, pres);
+
+  return true; 
+}
+
+bool WIOE5SensorManager::begin() {
+  has_bme = bme.begin();
+
+  return has_bme;
+}

variants/wio-e5-mini/target.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#define RADIOLIB_STATIC_ONLY 1
+#include <RadioLib.h>
+#include <helpers/RadioLibWrappers.h>
+#include <helpers/stm32/STM32Board.h>
+#include <helpers/CustomSTM32WLxWrapper.h>
+#include <helpers/ArduinoHelpers.h>
+#include <helpers/SensorManager.h>
+
+#include <BME280I2C.h>
+#include <Wire.h>
+
+class WIOE5Board : public STM32Board {
+public:
+    const char* getManufacturerName() const override {
+        return "Seeed Wio E5 mini";
+    }
+
+    uint16_t getBattMilliVolts() override {
+        analogReadResolution(12);
+        uint32_t raw = analogRead(PIN_A3);            
+        return raw;
+    }
+};
+
+class WIOE5SensorManager : public SensorManager {
+    BME280I2C bme;
+    bool has_bme = false;   
+
+public:
+    WIOE5SensorManager() {}
+    bool begin() override;
+    bool querySensors(uint8_t requester_permissions, CayenneLPP& telemetry) override;
+};
+
+extern WIOE5Board board;
+extern WRAPPER_CLASS radio_driver;
+extern VolatileRTCClock rtc_clock;
+extern WIOE5SensorManager sensors;
+
+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/wio-e5-mini/variant.h

@@ -1,9 +1,9 @@
 #pragma once
 
 // UART Definitions
-#ifndef SERIAL_UART_INSTANCE
-  #define SERIAL_UART_INSTANCE  101
-#endif
+// #ifndef SERIAL_UART_INSTANCE
+//   #define SERIAL_UART_INSTANCE  101
+// #endif
 
 #include <variant_LORA_E5_MINI.h>
 

variants/xiao_c3/platformio.ini

@@ -4,6 +4,7 @@ board = seeed_xiao_esp32c3
 build_flags =
   ${esp32_base.build_flags}
   -I variants/xiao_c3
+  -D ESP32_CPU_FREQ=80
   -D LORA_TX_BOOST_PIN=D3
   -D P_LORA_TX_LED=D5
   -D PIN_VBAT_READ=D0

variants/xiao_nrf52/platformio.ini

@@ -36,6 +36,8 @@ build_flags = ${nrf52840_xiao.build_flags}
   -D P_LORA_RESET=D2
   -D P_LORA_BUSY=D3
   -D P_LORA_NSS=D4
+  -D SX126X_RXEN=D5
+  -D SX126X_TXEN=RADIOLIB_NC
   -D SX126X_DIO2_AS_RF_SWITCH=1
   -D SX126X_DIO3_TCXO_VOLTAGE=1.8
   -D SX126X_CURRENT_LIMIT=140
@@ -63,12 +65,11 @@ build_flags =
   -D BLE_PIN_CODE=123456
   -D OFFLINE_QUEUE_SIZE=256
 ;  -D BLE_DEBUG_LOGGING=1
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
 ;  -D MESH_PACKET_LOGGING=1
 ;  -D MESH_DEBUG=1
 build_src_filter = ${Xiao_nrf52.build_src_filter}
   +<helpers/nrf52/SerialBLEInterface.cpp>
-  +<../examples/companion_radio/main.cpp>
+  +<../examples/companion_radio>
 lib_deps =
   ${Xiao_nrf52.lib_deps}
   densaugeo/base64 @ ~1.4.0
@@ -79,12 +80,11 @@ build_flags =
   ${Xiao_nrf52.build_flags}
   -D MAX_CONTACTS=100
   -D MAX_GROUP_CHANNELS=8
-;  -D ENABLE_PRIVATE_KEY_IMPORT=1
 ;  -D MESH_PACKET_LOGGING=1
 ;  -D MESH_DEBUG=1
 build_src_filter = ${Xiao_nrf52.build_src_filter}
   +<helpers/nrf52/SerialBLEInterface.cpp>
-  +<../examples/companion_radio/main.cpp>
+  +<../examples/companion_radio>
 lib_deps =
   ${Xiao_nrf52.lib_deps}
   densaugeo/base64 @ ~1.4.0

variants/xiao_nrf52/target.cpp

@@ -35,6 +35,10 @@ bool radio_init() {
   
   radio.setCRC(1);
   
+#if defined(SX126X_RXEN) && defined(SX126X_TXEN)
+  radio.setRfSwitchPins(SX126X_RXEN, SX126X_TXEN);
+#endif 
+
 #ifdef SX126X_CURRENT_LIMIT
   radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
 #endif

variants/xiao_s3_wio/platformio.ini

@@ -15,6 +15,8 @@ build_flags = ${esp32_base.build_flags}
   -D P_LORA_MOSI=9
   -D PIN_USER_BTN=21
   -D PIN_STATUS_LED=48
+  -D SX126X_RXEN=38
+  -D SX126X_TXEN=RADIOLIB_NC
   -D SX126X_DIO2_AS_RF_SWITCH=true
   -D SX126X_DIO3_TCXO_VOLTAGE=1.8
   -D SX126X_CURRENT_LIMIT=140
@@ -83,8 +85,6 @@ build_flags =
   -D DISPLAY_CLASS=SSD1306Display
   -D OFFLINE_QUEUE_SIZE=256
 ;  -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}
@@ -108,7 +108,7 @@ build_flags =
 ;  -D MESH_DEBUG=1
 build_src_filter = ${Xiao_S3_WIO.build_src_filter}
   +<helpers/esp32/*.cpp>
-  +<../examples/companion_radio/main.cpp>
+  +<../examples/companion_radio>
 lib_deps =
   ${Xiao_S3_WIO.lib_deps}
   densaugeo/base64 @ ~1.4.0

variants/xiao_s3_wio/target.cpp

@@ -47,7 +47,11 @@ bool radio_init() {
   }
   
   radio.setCRC(1);
-  
+
+#if defined(SX126X_RXEN) && defined(SX126X_TXEN)
+  radio.setRfSwitchPins(SX126X_RXEN, SX126X_TXEN);
+#endif 
+
 #ifdef SX126X_CURRENT_LIMIT
   radio.setCurrentLimit(SX126X_CURRENT_LIMIT);
 #endif