Park unused LNA_CTRL_MCU net with pulldown on makerfabs_pucky

Added TX Power curve.

.github/copilot-instructions.md

@@ -4,11 +4,11 @@ This document provides context and guidelines for AI assistants working with the
 
 ## Project Overview
 
-Meshtastic is an open-source LoRa mesh networking project for long-range, low-power communication without relying on internet or cellular infrastructure. The firmware enables text messaging, location sharing, and telemetry over a decentralized mesh network.
+Meshtastic is an open-source LoRa mesh networking project for long-range, low-power communication without relying on internet or cellular infrastructure. The firmware enables text messaging, location sharing, and telemetry over a decentralized mesh network. The project uses **C++17** as its language standard across all platforms.
 
 ### Supported Hardware Platforms
 
-- **ESP32** (ESP32, ESP32-S3, ESP32-C3) - Most common platform
+- **ESP32** (ESP32, ESP32-S3, ESP32-C3, ESP32-C6) - Most common platform
 - **nRF52** (nRF52840, nRF52833) - Low power Nordic chips
 - **RP2040/RP2350** - Raspberry Pi Pico variants
 - **STM32WL** - STM32 with integrated LoRa
@@ -80,21 +80,46 @@ firmware/
 │   │   ├── NodeDB.*       # Node database management
 │   │   ├── Router.*       # Packet routing
 │   │   ├── Channels.*     # Channel management
+│   │   ├── CryptoEngine.* # AES-CCM encryption
 │   │   ├── *Interface.*   # Radio interface implementations
+│   │   ├── api/           # WiFi/Ethernet server APIs (ServerAPI, PacketAPI)
+│   │   ├── http/          # HTTP server (WebServer, ContentHandler)
+│   │   ├── wifi/          # WiFi support (WiFiAPClient)
+│   │   ├── eth/           # Ethernet support (ethClient)
+│   │   ├── udp/           # UDP multicast
+│   │   ├── compression/   # Message compression (unishox2)
 │   │   └── generated/     # Protobuf generated code
 │   ├── modules/           # Feature modules (Position, Telemetry, etc.)
+│   │   └── Telemetry/     # Telemetry subsystem
+│   │       └── Sensor/    # 50+ I2C sensor drivers
 │   ├── gps/               # GPS handling
 │   ├── graphics/          # Display drivers and UI
-│   ├── platform/          # Platform-specific code
-│   ├── input/             # Input device handling
-│   └── concurrency/       # Threading utilities
+│   │   └── niche/         # Specialized UIs (InkHUD e-ink framework)
+│   ├── platform/          # Platform-specific code (esp32, nrf52, rp2xx0, stm32wl, portduino)
+│   ├── input/             # Input device handling (InputBroker, keyboards, buttons)
+│   ├── detect/            # I2C hardware auto-detection (80+ device types)
+│   ├── motion/            # Accelerometer drivers (BMA423, BMI270, MPU6050, etc.)
+│   ├── mqtt/              # MQTT bridge client
+│   ├── power/             # Power HAL
+│   ├── nimble/            # BLE via NimBLE
+│   ├── buzz/              # Audio/notification (buzzer, RTTTL)
+│   ├── serialization/     # JSON serialization, COBS encoding
+│   ├── watchdog/          # Hardware watchdog thread
+│   ├── concurrency/       # Threading utilities (OSThread, Lock)
+│   ├── PowerFSM.*         # Power finite state machine
+│   └── Observer.h         # Observer/Observable event pattern
 ├── variants/              # Hardware variant definitions
 │   ├── esp32/            # ESP32 variants
 │   ├── esp32s3/          # ESP32-S3 variants
-│   ├── nrf52/            # nRF52 variants
-│   └── rp2xxx/           # RP2040/RP2350 variants
+│   ├── esp32c3/          # ESP32-C3 variants
+│   ├── esp32c6/          # ESP32-C6 variants
+│   ├── nrf52840/         # nRF52 variants
+│   ├── rp2040/           # RP2040/RP2350 variants
+│   ├── stm32/            # STM32WL variants
+│   └── native/           # Linux/Portduino variants
 ├── protobufs/            # Protocol buffer definitions
 ├── boards/               # Custom PlatformIO board definitions
+├── test/                 # Unit tests (12 test suites)
 └── bin/                  # Build and utility scripts
 ```
 
@@ -105,6 +130,7 @@ firmware/
 - Follow existing code style - run `trunk fmt` before commits
 - Prefer `LOG_DEBUG`, `LOG_INFO`, `LOG_WARN`, `LOG_ERROR` for logging
 - Use `assert()` for invariants that should never fail
+- C++17 features are available (`std::optional`, structured bindings, `if constexpr`, etc.)
 
 ### Naming Conventions
 
@@ -118,70 +144,151 @@ firmware/
 
 #### Module System
 
-Modules inherit from `MeshModule` or `ProtobufModule<T>` and implement:
+Modules use a three-tier class hierarchy:
 
-- `handleReceivedProtobuf()` - Process incoming packets
-- `allocReply()` - Generate response packets
-- `runOnce()` - Periodic task execution (returns next run interval in ms)
+1. **`MeshModule`** - Base class. Implement `wantPacket()` and `handleReceived()`. Returns `ProcessMessage::STOP` or `ProcessMessage::CONTINUE`.
+2. **`SinglePortModule`** - Handles a single portnum. Simplified `wantPacket()` that checks `decoded.portnum`.
+3. **`ProtobufModule<T>`** - Template for protobuf-based modules. Handles encoding/decoding automatically.
+
+Most modules also inherit from **`OSThread`** for periodic tasks (the "mixin" pattern):
 
 ```cpp
-class MyModule : public ProtobufModule<meshtastic_MyMessage>
+class MyModule : public ProtobufModule<meshtastic_MyMessage>, private concurrency::OSThread
 {
+  public:
+    MyModule();
+
   protected:
     virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_MyMessage *msg) override;
-    virtual int32_t runOnce() override;
+    virtual meshtastic_MeshPacket *allocReply() override;       // Generate response packets
+    virtual int32_t runOnce() override;                         // Periodic task (returns next interval in ms)
+    virtual bool alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtastic_MyMessage *msg); // Modify in-flight
+    virtual bool wantUIFrame();                                 // Request a UI display frame
 };
 ```
 
+Modules are registered in `src/modules/Modules.cpp` guarded by `MESHTASTIC_EXCLUDE_*` flags.
+
+#### Observer/Observable Pattern
+
+Event-driven communication between subsystems uses `src/Observer.h`:
+
+```cpp
+// Observable emits events
+Observable<const meshtastic::Status *> newStatus;
+newStatus.notifyObservers(&status);
+
+// Observer receives events via callback
+CallbackObserver<MyClass, const meshtastic::Status *> statusObserver =
+    CallbackObserver<MyClass, const meshtastic::Status *>(this, &MyClass::handleStatusUpdate);
+```
+
 #### Configuration Access
 
 - `config.*` - Device configuration (LoRa, position, power, etc.)
 - `moduleConfig.*` - Module-specific configuration
 - `channels.*` - Channel configuration and management
+- `owner` - Device owner info
+- `myNodeInfo` - Local node info
 
 #### Default Values
 
 Use the `Default` class helpers in `src/mesh/Default.h`:
 
 - `Default::getConfiguredOrDefaultMs(configured, default)` - Returns ms, using default if configured is 0
+- `Default::getConfiguredOrDefault(configured, default)` - Generic configured/default getter
 - `Default::getConfiguredOrMinimumValue(configured, min)` - Enforces minimum values
 - `Default::getConfiguredOrDefaultMsScaled(configured, default, numNodes)` - Scales based on network size
 
 #### Thread Safety
 
-- Use `concurrency::Lock` for mutex protection
+- Use `concurrency::Lock` and `concurrency::LockGuard` for mutex protection
 - Radio SPI access uses `SPILock`
 - Prefer `OSThread` for background tasks
 
+### Hardware Detection
+
+`src/detect/ScanI2C` automatically enumerates 80+ I2C device types at boot including displays, sensors, RTCs, keyboards, PMUs, and touch controllers. This drives automatic initialization of the correct drivers.
+
+### Graphics/UI System
+
+Multiple display driver families in `src/graphics/`:
+
+- **OLED**: SSD1306, SH1106, ST7567
+- **TFT**: TFTDisplay (LovyanGFX-based)
+- **E-Ink**: EInkDisplay2, EInkDynamicDisplay, EInkParallelDisplay
+
+**InkHUD** (`src/graphics/niche/InkHUD/`) is an event-driven e-ink UI framework:
+
+- Applet-based architecture — modular display tiles
+- Read-only, static display optimized for minimal refreshes and low power
+- Configured per-variant via `nicheGraphics.h`
+- Separate PlatformIO config: `src/graphics/niche/InkHUD/PlatformioConfig.ini`
+
+### Input System
+
+`src/input/InputBroker` is the centralized input event dispatcher. Supports multiple input sources: buttons, keyboards (BBQ10, Cardputer, TCA8418), touch screens, rotary encoders, and matrix keyboards.
+
+### Power Management
+
+`src/PowerFSM.*` implements a finite state machine with states: `stateON`, `statePOWER`, `stateSERIAL`, `stateDARK`. Key events: `EVENT_PRESS`, `EVENT_WAKE_TIMER`, `EVENT_LOW_BATTERY`, `EVENT_RECEIVED_MSG`, `EVENT_SHUTDOWN`. Conditionally excluded with `MESHTASTIC_EXCLUDE_POWER_FSM` (falls back to `FakeFsm`).
+
+### Motion Sensors
+
+`src/motion/AccelerometerThread` provides background motion monitoring with automatic screen wake and double-tap button press detection. Supports 10+ accelerometer/gyroscope chips (BMA423, BMI270, MPU6050, LIS3DH, LSM6DS3, STK8XXX, QMA6100P, ICM20948, BMX160).
+
+### Telemetry Sensor Library
+
+`src/modules/Telemetry/Sensor/` contains 50+ I2C sensor drivers organized by category:
+
+- **Power monitoring**: INA219/226/260/3221, MAX17048
+- **Environmental**: BME280/680, SCD4X (CO₂), SEN5X (particulate)
+- **Humidity/Temperature**: SHT3X/4X, AHT10, MCP9808, MLX90614
+- **Light**: BH1750, TSL2561/2591, VEML7700, LTR390UV, OPT3001
+- **Air quality**: PMSA003I, SFA30
+- **Specialized**: CGRadSens (radiation), NAU7802 (weight scale)
+
+### API/Networking
+
+`src/mesh/api/` provides a template-based `ServerAPI` for client communication over WiFi (`WiFiServerAPI`) and Ethernet (`ethServerAPI`). Default port: **4403**. HTTP server in `src/mesh/http/`. JSON serialization in `src/serialization/MeshPacketSerializer`.
+
 ### Hardware Variants
 
 Each hardware variant has:
 
 - `variant.h` - Pin definitions and hardware capabilities
 - `platformio.ini` - Build configuration
-- Optional: `pins_arduino.h`, `rfswitch.h`
+- Optional: `pins_arduino.h`, `rfswitch.h`, `nicheGraphics.h` (for InkHUD variants)
 
 Key defines in variant.h:
 
 ```cpp
 #define USE_SX1262          // Radio chip selection
 #define HAS_GPS 1           // Hardware capabilities
+#define HAS_SCREEN 1        // Display present
 #define LORA_CS 36          // Pin assignments
 #define SX126X_DIO1 14      // Radio-specific pins
 ```
 
 ### Protobuf Messages
 
-- Defined in `protobufs/meshtastic/*.proto`
-- Generated code in `src/mesh/generated/`
+- Defined in `protobufs/meshtastic/*.proto` (~32 proto files)
+- Generated code in `src/mesh/generated/meshtastic/`
 - Regenerate with `bin/regen-protos.sh`
 - Message types prefixed with `meshtastic_`
+- Nanopb `.options` files control field sizes and encoding
 
 ### Conditional Compilation
 
 ```cpp
 #if !MESHTASTIC_EXCLUDE_GPS        // Feature exclusion
+#if !MESHTASTIC_EXCLUDE_WIFI       // Network feature exclusion
+#if !MESHTASTIC_EXCLUDE_BLUETOOTH  // BLE exclusion
+#if !MESHTASTIC_EXCLUDE_POWER_FSM  // Power FSM exclusion
 #ifdef ARCH_ESP32                   // Architecture-specific
+#ifdef ARCH_NRF52                   // Nordic platform
+#ifdef ARCH_RP2040                  // Raspberry Pi Pico
+#ifdef ARCH_PORTDUINO               // Linux native
 #if defined(USE_SX1262)            // Radio-specific
 #ifdef HAS_SCREEN                   // Hardware capability
 #if USERPREFS_EVENT_MODE           // User preferences
@@ -192,7 +299,7 @@ Key defines in variant.h:
 Uses **PlatformIO** with custom scripts:
 
 - `bin/platformio-pre.py` - Pre-build script
-- `bin/platformio-custom.py` - Custom build logic
+- `bin/platformio-custom.py` - Custom build logic, manifest generation
 
 Build commands:
 
@@ -202,21 +309,38 @@ pio run -e tbeam -t upload    # Build and upload
 pio run -e native             # Build native/Linux version
 ```
 
+### Build Manifest
+
+`bin/platformio-custom.py` emits a build manifest with metadata:
+
+- `hasMui`, `hasInkHud` - UI capability flags (overridable via `custom_meshtastic_has_mui`, `custom_meshtastic_has_ink_hud`)
+- Architecture normalization (e.g., `esp32s3` → `esp32-s3` for API compatibility)
+
 ## Common Tasks
 
 ### Adding a New Module
 
 1. Create `src/modules/MyModule.cpp` and `.h`
-2. Inherit from appropriate base class
-3. Register in `src/modules/Modules.cpp`
-4. Add protobuf messages if needed in `protobufs/`
+2. Inherit from appropriate base class (`MeshModule`, `SinglePortModule`, or `ProtobufModule<T>`)
+3. Mix in `concurrency::OSThread` if periodic work is needed
+4. Register in `src/modules/Modules.cpp` guarded by `#if !MESHTASTIC_EXCLUDE_MYMODULE`
+5. Add protobuf messages if needed in `protobufs/meshtastic/`
+6. Add test suite in `test/test_mymodule/` if applicable
 
 ### Adding a New Hardware Variant
 
 1. Create directory under `variants/<arch>/<name>/`
-2. Add `variant.h` with pin definitions
-3. Add `platformio.ini` with build config
-4. Reference common configs with `extends`
+2. Add `variant.h` with pin definitions and hardware capability defines
+3. Add `platformio.ini` with build config — use `extends` to reference common base (e.g., `esp32s3_base`)
+4. Set `custom_meshtastic_support_level = 1` (PR builds) or `2` (merge builds)
+5. For e-ink displays, add `nicheGraphics.h` for InkHUD configuration
+
+### Adding a New Telemetry Sensor
+
+1. Create driver in `src/modules/Telemetry/Sensor/` following existing sensor pattern
+2. Register I2C address in `src/detect/ScanI2C` for auto-detection
+3. Integrate with the appropriate telemetry module (Environment, Health, Power, AirQuality)
+4. Add proto fields in `protobufs/meshtastic/telemetry.proto` if new data types are needed
 
 ### Modifying Configuration Defaults
 
@@ -305,9 +429,22 @@ Most workflows can be triggered manually via `workflow_dispatch` for testing.
 
 ## Testing
 
-- Unit tests in `test/` directory
-- Run with `pio test -e native`
-- Use `bin/test-simulator.sh` for simulation testing
+Unit tests in `test/` directory with 12 test suites:
+
+- `test_crypto/` - Cryptography
+- `test_mqtt/` - MQTT integration
+- `test_radio/` - Radio interface
+- `test_mesh_module/` - Module framework
+- `test_meshpacket_serializer/` - Packet serialization
+- `test_transmit_history/` - Retransmission tracking
+- `test_atak/` - ATAK integration
+- `test_default/` - Default configuration
+- `test_http_content_handler/` - HTTP handling
+- `test_serial/` - Serial communication
+
+Run with: `pio test -e native`
+
+Simulation testing: `bin/test-simulator.sh`
 
 ## Resources
 

.github/prompts/new-module.prompt.md

@@ -0,0 +1,138 @@
+# New Meshtastic Module
+
+Guide for developing a new Meshtastic firmware module.
+
+## Module Hierarchy
+
+Choose the appropriate base class:
+
+1. **`MeshModule`** — Raw base class. Override `wantPacket()` and `handleReceived()`. Returns `ProcessMessage::STOP` or `ProcessMessage::CONTINUE`.
+2. **`SinglePortModule`** — Handles a single `meshtastic_PortNum`. Constructor takes `(name, portNum)`. Simplified `wantPacket()` checking `decoded.portnum`. Use `allocDataPacket()` to create outgoing packets.
+3. **`ProtobufModule<T>`** — Template for protobuf-encoded modules. Constructor takes `(name, portNum, fields)`. Override `handleReceivedProtobuf()`. Use `allocDataProtobuf(payload)` to create outgoing packets.
+
+Most modules also mix in `concurrency::OSThread` for periodic background tasks.
+
+## Implementation Pattern
+
+```cpp
+// src/modules/MyModule.h
+#pragma once
+#include "ProtobufModule.h"
+#include "concurrency/OSThread.h"
+
+class MyModule : public ProtobufModule<meshtastic_MyMessage>, private concurrency::OSThread
+{
+  public:
+    MyModule();
+
+  protected:
+    // Process incoming protobuf packet. Return true to stop further processing.
+    virtual bool handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshtastic_MyMessage *msg) override;
+
+    // Generate response packet (optional)
+    virtual meshtastic_MeshPacket *allocReply() override;
+
+    // Periodic task — return next run interval in ms, or disable()
+    virtual int32_t runOnce() override;
+
+    // Modify packet in-flight before delivery (optional)
+    virtual bool alterReceivedProtobuf(meshtastic_MeshPacket &mp, meshtastic_MyMessage *msg);
+
+    // Request a UI display frame (optional)
+    virtual bool wantUIFrame();
+};
+```
+
+## Registration
+
+Register in `src/modules/Modules.cpp` inside `setupModules()`:
+
+```cpp
+#if !MESHTASTIC_EXCLUDE_MYMODULE
+    new MyModule();
+#endif
+```
+
+If other code needs to reference the module instance:
+
+```cpp
+#if !MESHTASTIC_EXCLUDE_MYMODULE
+    myModule = new MyModule();
+#endif
+```
+
+And declare the global in the header:
+
+```cpp
+extern MyModule *myModule;
+```
+
+Some modules also conditionally instantiate based on `moduleConfig`:
+
+```cpp
+#if !MESHTASTIC_EXCLUDE_MYMODULE
+    if (moduleConfig.has_my_module && moduleConfig.my_module.enabled) {
+        new MyModule();
+    }
+#endif
+```
+
+## Conditional Compilation
+
+Add a `MESHTASTIC_EXCLUDE_MYMODULE` guard. This allows the module to be excluded from constrained builds. The flag name must follow the pattern: `MESHTASTIC_EXCLUDE_` + uppercase module name.
+
+## Protobuf Messages (if needed)
+
+1. Define messages in `protobufs/meshtastic/` (e.g., `mymodule.proto`)
+2. Add a `.options` file for nanopb field size constraints
+3. Regenerate with `bin/regen-protos.sh`
+4. Generated code appears in `src/mesh/generated/meshtastic/`
+5. Assign a `meshtastic_PortNum` if the module uses a new port number
+
+## Timing and Defaults
+
+Use `Default` class helpers for configurable intervals:
+
+```cpp
+int32_t MyModule::runOnce()
+{
+    uint32_t interval = Default::getConfiguredOrDefaultMs(moduleConfig.my_module.update_interval,
+                                                          default_my_module_interval);
+    // ... do work ...
+    return interval;
+}
+```
+
+On public/default channels, enforce minimums with `Default::getConfiguredOrMinimumValue()`.
+
+## Observer Pattern
+
+Subscribe to system events:
+
+```cpp
+CallbackObserver<MyModule, const meshtastic::Status *> statusObserver =
+    CallbackObserver<MyModule, const meshtastic::Status *>(this, &MyModule::handleStatusUpdate);
+```
+
+## Testing
+
+Add test suite in `test/test_mymodule/`:
+
+```
+test/
+└── test_mymodule/
+    └── test_main.cpp
+```
+
+Run with: `pio test -e native`
+
+## Checklist
+
+- [ ] Header and implementation files in `src/modules/`
+- [ ] Inherit from appropriate base class (MeshModule / SinglePortModule / ProtobufModule)
+- [ ] Mix in OSThread if periodic work is needed
+- [ ] Register in `src/modules/Modules.cpp` with `MESHTASTIC_EXCLUDE_` guard
+- [ ] Add protobuf definitions if needed (`protobufs/meshtastic/`)
+- [ ] Use `Default::getConfiguredOrDefaultMs()` for timing
+- [ ] Respect bandwidth limits on public channels
+- [ ] Add test suite in `test/`

.github/prompts/new-sensor.prompt.md

@@ -0,0 +1,149 @@
+# New Telemetry Sensor
+
+Guide for adding a new I2C telemetry sensor driver to Meshtastic firmware.
+
+## Overview
+
+Telemetry sensors live in `src/modules/Telemetry/Sensor/`. There are 50+ existing drivers organized by measurement type. Each sensor integrates with one of the telemetry modules:
+
+- **EnvironmentTelemetryModule** — Temperature, humidity, pressure, gas, light
+- **AirQualityTelemetryModule** — Particulate matter, VOCs
+- **PowerTelemetryModule** — Voltage, current, power monitoring
+- **HealthTelemetryModule** — Heart rate, SpO2, body temperature
+
+## Sensor Driver Pattern
+
+Each sensor has a `.h` and `.cpp` file pair following this pattern:
+
+```cpp
+// src/modules/Telemetry/Sensor/MySensor.h
+#pragma once
+#include "TelemetrySensor.h"
+#include <MySensorLibrary.h>  // Arduino/PlatformIO library
+
+class MySensor : virtual public TelemetrySensor
+{
+  private:
+    MySensorLibrary sensor;
+
+  public:
+    MySensor() : TelemetrySensor(meshtastic_TelemetrySensorType_MY_SENSOR, "MySensor") {}
+
+    // Initialize sensor hardware. Return true on success.
+    virtual void setup() override;
+
+    // Read sensor data into the telemetry protobuf. Return true on success.
+    virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+};
+```
+
+```cpp
+// src/modules/Telemetry/Sensor/MySensor.cpp
+#include "MySensor.h"
+#include "TelemetrySensor.h"
+
+void MySensor::setup()
+{
+    sensor.begin();
+    // Configure sensor parameters...
+}
+
+bool MySensor::getMetrics(meshtastic_Telemetry *measurement)
+{
+    // Read from hardware
+    float value = sensor.readValue();
+
+    // Populate the appropriate protobuf variant
+    measurement->variant.environment_metrics.temperature = value;
+    // ... other fields ...
+
+    return true;
+}
+```
+
+## I2C Address Registration
+
+Register the sensor's I2C address(es) in `src/detect/ScanI2C` so it's auto-detected at boot:
+
+1. Add a `DeviceType` enum entry in `src/detect/ScanI2C.h`
+2. Add the I2C address mapping in `src/detect/ScanI2CTwoWire.cpp`
+
+The scan runs at boot and populates a device map that telemetry modules use to decide which sensors to initialize.
+
+## Protobuf Fields
+
+If the sensor provides data not covered by existing telemetry fields:
+
+1. Add fields to the appropriate message in `protobufs/meshtastic/telemetry.proto`:
+   - `EnvironmentMetrics` — Environmental measurements
+   - `AirQualityMetrics` — Air quality data
+   - `PowerMetrics` — Power/energy data
+   - `HealthMetrics` — Health/biometric data
+2. Add a `.options` constraint if needed (field sizes for nanopb)
+3. Regenerate: `bin/regen-protos.sh`
+
+## Sensor Type Enum
+
+Add the sensor to `meshtastic_TelemetrySensorType` enum in `protobufs/meshtastic/telemetry.proto`:
+
+```protobuf
+enum TelemetrySensorType {
+    // ... existing entries ...
+    MY_SENSOR = XX;
+}
+```
+
+## Integration with Telemetry Module
+
+Wire the sensor into the appropriate telemetry module. For environment sensors, this is typically in `src/modules/Telemetry/EnvironmentTelemetry.cpp`:
+
+1. Include the sensor header
+2. Add initialization in `setupSensor()` guarded by detection results
+3. Call `getMetrics()` in the measurement collection path
+
+Example pattern from existing sensors:
+
+```cpp
+#include "Sensor/MySensor.h"
+
+MySensor mySensor;
+
+// In setup:
+if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MY_SENSOR].first > 0) {
+    mySensor.setup();
+}
+
+// In measurement collection:
+if (nodeTelemetrySensorsMap[meshtastic_TelemetrySensorType_MY_SENSOR].first > 0) {
+    mySensor.getMetrics(&measurement);
+}
+```
+
+## Library Dependencies
+
+If the sensor needs an external library, add it to the `lib_deps` in the relevant base platformio.ini configs:
+
+```ini
+lib_deps =
+    ${env.lib_deps}
+    mysensorlibrary@^1.0.0
+```
+
+Or use a conditional dependency if it's platform-specific.
+
+## Unit Conversions
+
+If the sensor reports values in non-standard units, use `src/modules/Telemetry/UnitConversions.h` for conversion helpers (e.g., Celsius ↔ Fahrenheit, hPa ↔ inHg).
+
+## Checklist
+
+- [ ] Create `src/modules/Telemetry/Sensor/MySensor.h` and `.cpp`
+- [ ] Inherit from `TelemetrySensor` base class
+- [ ] Implement `setup()` and `getMetrics()` methods
+- [ ] Add `meshtastic_TelemetrySensorType` enum entry in `telemetry.proto`
+- [ ] Add I2C address to `src/detect/ScanI2C` for auto-detection
+- [ ] Add protobuf fields in `telemetry.proto` if new data types needed
+- [ ] Regenerate protos: `bin/regen-protos.sh`
+- [ ] Wire into the appropriate telemetry module (Environment/AirQuality/Power/Health)
+- [ ] Add library dependency if external library required
+- [ ] Test on hardware or native build

.github/prompts/new-variant.prompt.md

@@ -0,0 +1,178 @@
+# New Hardware Variant
+
+Guide for adding a new Meshtastic hardware variant to the firmware.
+
+## Directory Structure
+
+Create under `variants/<arch>/<name>/`:
+
+```
+variants/
+├── esp32/          # ESP32
+├── esp32s3/        # ESP32-S3
+├── esp32c3/        # ESP32-C3
+├── esp32c6/        # ESP32-C6
+├── nrf52840/       # nRF52840
+├── rp2040/         # RP2040/RP2350
+├── stm32/          # STM32WL
+└── native/         # Linux/Portduino
+```
+
+Each variant needs at minimum:
+
+- `variant.h` — Pin definitions and hardware capabilities
+- `platformio.ini` — Build configuration
+
+Optional files:
+
+- `pins_arduino.h` — Arduino pin mapping overrides
+- `rfswitch.h` — RF switch control for multi-band radios
+- `nicheGraphics.h` — InkHUD e-ink configuration
+
+## variant.h Template
+
+```cpp
+// Pin definitions
+#define I2C_SDA 21
+#define I2C_SCL 22
+
+// LoRa radio
+#define USE_SX1262              // Radio chip: USE_SX1262, USE_SX1268, USE_SX1280, USE_RF95, USE_LLCC68, USE_LR1110, USE_LR1120, USE_LR1121
+#define LORA_CS   18
+#define LORA_SCK  5
+#define LORA_MOSI 27
+#define LORA_MISO 19
+#define LORA_DIO1 33            // SX126x: DIO1, SX128x: DIO1, RF95: IRQ
+#define LORA_RESET 23
+#define LORA_BUSY 32            // SX126x/SX128x only
+#define SX126X_DIO2_AS_RF_SWITCH // Common for SX1262 boards
+
+// GPS
+#define HAS_GPS 1
+#define GPS_RX_PIN 34
+#define GPS_TX_PIN 12
+// #define PIN_GPS_EN 47         // Optional GPS enable pin
+// #define GPS_BAUDRATE 9600     // Override default 9600
+
+// Display
+#define HAS_SCREEN 1
+// #define USE_SSD1306            // OLED type
+// #define USE_SH1106             // Alternative OLED
+// #define USE_ST7789             // TFT type
+// #define SCREEN_WIDTH 128
+// #define SCREEN_HEIGHT 64
+
+// LEDs
+#define LED_PIN 2               // Status LED (optional)
+// #define HAS_NEOPIXEL 1        // WS2812 support
+
+// Buttons
+#define BUTTON_PIN 38
+// #define BUTTON_PIN_ALT 0      // Secondary button
+
+// Power management
+// #define HAS_AXP192 1          // AXP192 PMU (T-Beam v1.0)
+// #define HAS_AXP2101 1         // AXP2101 PMU (T-Beam v1.2+)
+// #define BATTERY_PIN 35        // ADC battery voltage pin
+// #define ADC_MULTIPLIER 2.0    // Voltage divider ratio
+
+// Optional I2C devices
+// #define HAS_RTC 1             // Real-time clock
+// #define HAS_TELEMETRY 1       // Enable telemetry sensor support
+// #define HAS_SENSOR 1          // I2C sensors present
+```
+
+## platformio.ini Template
+
+```ini
+[env:my_variant]
+extends = esp32s3_base            ; Use architecture-specific base
+board = esp32-s3-devkitc-1        ; PlatformIO board definition (or custom in boards/)
+board_level = extra               ; Build level: extra, or omit for default
+custom_meshtastic_support_level = 1  ; 1 = PR builds, 2 = merge builds only
+
+build_flags =
+    ${esp32s3_base.build_flags}
+    -D MY_VARIANT_SPECIFIC_FLAG=1
+    -I variants/esp32s3/my_variant  ; Include path for variant.h
+
+upload_speed = 921600
+```
+
+### Common Base Configs
+
+- `esp32_base` / `esp32-common.ini` — ESP32
+- `esp32s3_base` — ESP32-S3
+- `esp32c3_base` — ESP32-C3
+- `esp32c6_base` — ESP32-C6
+- `nrf52840_base` / `nrf52.ini` — nRF52840
+- `rp2040_base` — RP2040/RP2350
+
+### Support Levels
+
+- `custom_meshtastic_support_level = 1` — Built on every PR (actively supported)
+- `custom_meshtastic_support_level = 2` — Built only on merge to main branches
+- `board_level = extra` — Only built on full releases
+
+## Build Manifest Metadata
+
+`bin/platformio-custom.py` emits UI capability flags in the build manifest:
+
+- `custom_meshtastic_has_mui = true/false` — Override MUI detection
+- `custom_meshtastic_has_ink_hud = true/false` — Override InkHUD detection
+- Architecture names are normalized (e.g., `esp32s3` → `esp32-s3`)
+
+## InkHUD E-Ink Variants
+
+For e-ink display variants using the InkHUD framework, add `nicheGraphics.h`:
+
+```cpp
+// nicheGraphics.h — InkHUD configuration for this variant
+#define INKHUD                     // Enable InkHUD
+// Configure display, applets, and refresh behavior per device
+```
+
+InkHUD has its own PlatformIO config: `src/graphics/niche/InkHUD/PlatformioConfig.ini`
+
+## I2C Device Detection
+
+If the variant has I2C devices, ensure `src/detect/ScanI2C` will detect them. The auto-detection system handles 80+ device types including displays, sensors, RTCs, keyboards, PMUs, and touch controllers at boot.
+
+## Custom Board Definitions
+
+If the PlatformIO board doesn't exist, create a custom board JSON in `boards/`:
+
+```json
+{
+  "build": {
+    "arduino": { "ldscript": "esp32s3_out.ld" },
+    "core": "esp32",
+    "f_cpu": "240000000L",
+    "f_flash": "80000000L",
+    "flash_mode": "qio",
+    "mcu": "esp32s3",
+    "variant": "esp32s3"
+  },
+  "connectivity": ["wifi", "bluetooth"],
+  "frameworks": ["arduino", "espidf"],
+  "name": "My Custom Board",
+  "upload": {
+    "flash_size": "8MB",
+    "maximum_ram_size": 327680,
+    "maximum_size": 8388608
+  },
+  "url": "https://example.com",
+  "vendor": "MyVendor"
+}
+```
+
+## Checklist
+
+- [ ] Create `variants/<arch>/<name>/variant.h` with pin definitions
+- [ ] Create `variants/<arch>/<name>/platformio.ini` extending correct base
+- [ ] Set `custom_meshtastic_support_level` (1 or 2)
+- [ ] Verify radio chip define matches hardware (`USE_SX1262`, etc.)
+- [ ] Set hardware capability flags (`HAS_GPS`, `HAS_SCREEN`, etc.)
+- [ ] Add custom board JSON in `boards/` if needed
+- [ ] Test build: `pio run -e my_variant`
+- [ ] For e-ink: add `nicheGraphics.h` with InkHUD config

.github/workflows/build_one_target.yml

@@ -4,14 +4,9 @@ on:
   workflow_dispatch:
     inputs:
       # trunk-ignore(checkov/CKV_GHA_7)
-      target:
-        type: string
-        required: false
-        description: Choose the target board, e.g. nrf52_promicro_diy_tcxo. If blank, will find available targets.
       arch:
         type: choice
         options:
-          - all
           - esp32
           - esp32s3
           - esp32c3
@@ -20,18 +15,32 @@ on:
           - rp2040
           - rp2350
           - stm32
-        description: Choose an arch to limit the search, or 'all' to search all architectures.
-        default: all
+      target:
+        type: string
+        required: false
+        description: Choose the target board, e.g. nrf52_promicro_diy_tcxo. If blank, will find available targets.
+      # find-target:
+      #   type: boolean
+      #   default: true
+      #   description: 'Find the available targets'
 
 permissions: read-all
 
 jobs:
   find-targets:
+    if: ${{ inputs.target == '' }}
     strategy:
       fail-fast: false
       matrix:
         arch:
-          - all
+          - esp32
+          - esp32s3
+          - esp32c3
+          - esp32c6
+          - nrf52840
+          - rp2040
+          - rp2350
+          - stm32
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v6
@@ -42,37 +51,14 @@ jobs:
       - run: pip install -U platformio
       - name: Generate matrix
         id: jsonStep
-        env:
-          BUILDTARGET: ${{ inputs.target }}
-          MATRIXARCH: ${{ inputs.arch }}
         run: |
           TARGETS=$(./bin/generate_ci_matrix.py ${{matrix.arch}} --level extra)
-          if [ "$BUILDTARGET" = "" ]; then
-            echo "Name: $GITHUB_REF_NAME" >> $GITHUB_STEP_SUMMARY
-            echo "Base: $GITHUB_BASE_REF" >> $GITHUB_STEP_SUMMARY
-            echo "Arch: $MATRIXARCH" >> $GITHUB_STEP_SUMMARY
-            echo "Ref: $GITHUB_REF" >> $GITHUB_STEP_SUMMARY
-            echo "## 🎯 The following target boards are available to build:" >> $GITHUB_STEP_SUMMARY
-            echo "| Platform | Board |" >> $GITHUB_STEP_SUMMARY
-            echo "| -------- | ----- |" >> $GITHUB_STEP_SUMMARY
-            echo $TARGETS | jq -r 'sort_by(.board) | sort_by(.platform) |.[] | "| " + .platform + " | " + .board + " |" ' >> $GITHUB_STEP_SUMMARY
-          else
-            echo "We build this one:" >> $GITHUB_STEP_SUMMARY
-            ARCH=$(echo "$TARGETS" | jq --arg BUILDTARGET "$BUILDTARGET" -r '.[] | select(.board==$BUILDTARGET) | .platform')
-            echo "| Platform | Board |" >> $GITHUB_STEP_SUMMARY
-            echo "| -------- | ----- |" >> $GITHUB_STEP_SUMMARY
-            echo "| $ARCH | "$BUILDTARGET" |" >> $GITHUB_STEP_SUMMARY
-            echo "" >> $GITHUB_STEP_SUMMARY
-            if [[ "$ARCH" == "" ]]; then
-              echo "## ❌ Error: Target "$BUILDTARGET" not found!" >> $GITHUB_STEP_SUMMARY
-            else
-              echo "## ✅ Target "$BUILDTARGET" found, proceeding to build." >> $GITHUB_STEP_SUMMARY
-            fi
-            echo "You may need to refresh this page to make the built firmware appear below." >> $GITHUB_STEP_SUMMARY
-            echo "arch=$ARCH" >> $GITHUB_OUTPUT
-          fi
-    outputs:
-      arch: ${{ steps.jsonStep.outputs.arch }}
+          echo "Name: $GITHUB_REF_NAME" >> $GITHUB_STEP_SUMMARY
+          echo "Base: $GITHUB_BASE_REF" >> $GITHUB_STEP_SUMMARY
+          echo "Arch: ${{matrix.arch}}" >> $GITHUB_STEP_SUMMARY
+          echo "Ref: $GITHUB_REF" >> $GITHUB_STEP_SUMMARY
+          echo "Targets:" >> $GITHUB_STEP_SUMMARY
+          echo $TARGETS | jq -r 'sort_by(.board) |.[] | "- " + .board' >> $GITHUB_STEP_SUMMARY
 
   version:
     if: ${{ inputs.target != '' }}
@@ -92,12 +78,12 @@ jobs:
 
   build:
     if: ${{ inputs.target != '' && inputs.arch != 'native' }}
-    needs: [version, find-targets]
+    needs: [version]
     uses: ./.github/workflows/build_firmware.yml
     with:
       version: ${{ needs.version.outputs.long }}
       pio_env: ${{ inputs.target }}
-      platform: ${{ needs.find-targets.outputs.arch }}
+      platform: ${{ inputs.arch }}
 
   gather-artifacts:
     permissions:

bin/config.d/femtofox/femtofox_E80-900M2213S.yaml

@@ -1,30 +0,0 @@
----
-Lora:
-## Ebyte E80-900M22S
-## This is a bit experimental
-## 
-##
-  Module: lr1121
-  gpiochip: 1 # subtract 32 from the gpio numbers
-  DIO3_TCXO_VOLTAGE: 1.8
-  CS: 16 #pin6 / GPIO48 1C0
-  IRQ: 23  #pin17 / GPIO55 1C7
-  Busy: 22 #pin16 / GPIO54 1C6
-  Reset: 25 #pin13 / GPIO57 1D1
-
-
-  spidev: spidev0.0 #pins are (CS=16, CLK=17, MOSI=18, MISO=19)
-  spiSpeed: 2000000
-  
-rfswitch_table:
-  pins: [DIO5, DIO6, DIO7]
-  MODE_STBY: [LOW, LOW, LOW]
-  MODE_RX: [LOW, HIGH, LOW]
-  MODE_TX: [HIGH, HIGH, LOW]
-  MODE_TX_HP: [HIGH, LOW, LOW]
-  MODE_TX_HF: [LOW, LOW, LOW]
-  MODE_GNSS: [LOW, LOW, HIGH]
-  MODE_WIFI: [LOW, LOW, LOW]
-
-General:
-  MACAddressSource: eth0

bin/config.d/femtofox/femtofox_LR1121 generic.yaml

@@ -1,46 +0,0 @@
----
-Lora:
-## Ebyte E80-900M22S
-## This is a bit experimental
-## 
-##
-  Module: lr1121
-  gpiochip: 1 # subtract 32 from the gpio numbers
-  DIO3_TCXO_VOLTAGE: 1.8
-  CS: 16 #pin6 / GPIO48 1C0
-  IRQ: 23  #pin17 / GPIO55 1C7
-  Busy: 22 #pin16 / GPIO54 1C6
-  Reset: 25 #pin13 / GPIO57 1D1
-
-
-  spidev: spidev0.0 #pins are (CS=16, CLK=17, MOSI=18, MISO=19)
-  spiSpeed: 2000000
-  
-rfswitch_table:
-  pins:
-    - DIO5
-    - DIO6
-  MODE_STBY:
-    - LOW
-    - LOW
-  MODE_RX:
-    - HIGH
-    - LOW
-  MODE_TX:
-    - HIGH
-    - HIGH
-  MODE_TX_HP:
-    - LOW
-    - HIGH
-  MODE_TX_HF:
-    - LOW
-    - LOW
-  MODE_GNSS:
-    - LOW
-    - LOW
-  MODE_WIFI:
-    - LOW
-    - LOW
-
-General:
-  MACAddressSource: eth0

bin/config.d/femtofox/femtofox_WIO-LR1121.yaml

@@ -1,30 +0,0 @@
----
-Lora:
-## Ebyte E80-900M22S
-## This is a bit experimental
-## 
-##
-  Module: lr1121
-  gpiochip: 1 # subtract 32 from the gpio numbers
-  DIO3_TCXO_VOLTAGE: 1.8
-  CS: 16 #pin6 / GPIO48 1C0
-  IRQ: 23  #pin17 / GPIO55 1C7
-  Busy: 22 #pin16 / GPIO54 1C6
-  Reset: 25 #pin13 / GPIO57 1D1
-
-
-  spidev: spidev0.0 #pins are (CS=16, CLK=17, MOSI=18, MISO=19)
-  spiSpeed: 2000000
-  
-rfswitch_table:
-  pins: [DIO5, DIO6, DIO7]
-  MODE_STBY: [LOW, LOW, LOW]
-  MODE_RX: [LOW, LOW, LOW]
-  MODE_TX: [LOW, HIGH, LOW]
-  MODE_TX_HP: [HIGH, LOW, LOW]
-  # MODE_TX_HF: []
-  # MODE_GNSS: []
-  MODE_WIFI: [LOW, LOW, LOW]
-
-General:
-  MACAddressSource: eth0

boards/makerfabs_pucky.json

@@ -0,0 +1,52 @@
+{
+  "build": {
+    "arduino": {
+      "ldscript": "nrf52840_s140_v6.ld"
+    },
+    "core": "nRF5",
+    "cpu": "cortex-m4",
+    "extra_flags": "-DARDUINO_NRF52840_FEATHER -DNRF52840_XXAA",
+    "f_cpu": "64000000L",
+    "hwids": [
+      ["0x239A", "0x8029"],
+      ["0x239A", "0x0029"],
+      ["0x239A", "0x002A"],
+      ["0x239A", "0x802A"]
+    ],
+    "usb_product": "makerfabs_pucky",
+    "mcu": "nrf52840",
+    "variant": "makerfabs_pucky",
+    "bsp": {
+      "name": "adafruit"
+    },
+    "softdevice": {
+      "sd_flags": "-DS140",
+      "sd_name": "s140",
+      "sd_version": "6.1.1",
+      "sd_fwid": "0x00B6"
+    },
+    "bootloader": {
+      "settings_addr": "0xFF000"
+    }
+  },
+  "connectivity": ["bluetooth"],
+  "debug": {
+    "jlink_device": "nRF52840_xxAA",
+    "svd_path": "nrf52840.svd",
+    "openocd_target": "nrf52840-mdk-rs"
+  },
+  "frameworks": ["arduino", "freertos"],
+  "name": "makerfabs_pucky",
+  "upload": {
+    "maximum_ram_size": 248832,
+    "maximum_size": 815104,
+    "speed": 115200,
+    "protocol": "nrfutil",
+    "protocols": ["jlink", "nrfjprog", "nrfutil", "stlink"],
+    "use_1200bps_touch": true,
+    "require_upload_port": true,
+    "wait_for_upload_port": true
+  },
+  "url": "https://www.makerfabs.com",
+  "vendor": "Makerfabs"
+}

platformio.ini

@@ -227,8 +227,6 @@ lib_deps =
 	https://github.com/Sensirion/arduino-i2c-sfa3x/archive/refs/tags/1.0.0.zip
 	# renovate: datasource=github-tags depName=Sensirion I2C SCD30 packageName=sensirion/arduino-i2c-scd30
 	https://github.com/Sensirion/arduino-i2c-scd30/archive/refs/tags/1.0.0.zip
-	# renovate: datasource=github-tags depName=arduino-sht packageName=sensirion/arduino-sht
-	https://github.com/Sensirion/arduino-sht/archive/refs/tags/v1.2.6.zip
 
 ; Environmental sensors with BSEC2 (Bosch proprietary IAQ)
 [environmental_extra]

src/DisplayFormatters.cpp

@@ -4,8 +4,7 @@ const char *DisplayFormatters::getModemPresetDisplayName(meshtastic_Config_LoRaC
                                                          bool usePreset)
 {
 
-    // If use_preset is false, always return "Custom" — callers such as RadioInterface and Channels
-    // rely on this being a stable literal for channel-name hashing and default-channel detection.
+    // If use_preset is false, always return "Custom"
     if (!usePreset) {
         return "Custom";
     }

src/Power.cpp

@@ -40,22 +40,6 @@
 #include "concurrency/LockGuard.h"
 #endif
 
-#if defined(ARCH_STM32WL) && defined(BATTERY_PIN)
-#include "stm32yyxx_ll_adc.h"
-
-/* Analog read resolution */
-#if defined(LL_ADC_RESOLUTION_12B)
-#define LL_ADC_RESOLUTION LL_ADC_RESOLUTION_12B
-#define BATTERY_SENSE_RESOLUTION_BITS 12
-#elif defined(LL_ADC_DS_DATA_WIDTH_12_BIT)
-#define LL_ADC_RESOLUTION LL_ADC_DS_DATA_WIDTH_12_BIT
-#define BATTERY_SENSE_RESOLUTION_BITS 12
-#else
-#error "ADC resolution could not be defined!"
-#endif
-#define ADC_RANGE (1 << BATTERY_SENSE_RESOLUTION_BITS)
-#endif
-
 #if defined(DEBUG_HEAP_MQTT) && !MESHTASTIC_EXCLUDE_MQTT
 #include "mqtt/MQTT.h"
 #include "target_specific.h"
@@ -344,17 +328,11 @@ class AnalogBatteryLevel : public HasBatteryLevel
             float scaled = 0;
 
             battery_adcEnable();
-#ifdef ARCH_STM32WL
-            // STM32 ADC with VREFINT runtime calibration
-            Vref = __LL_ADC_CALC_VREFANALOG_VOLTAGE(analogRead(AVREF), LL_ADC_RESOLUTION);
-            raw = analogRead(BATTERY_PIN);
-            scaled = __LL_ADC_CALC_DATA_TO_VOLTAGE(Vref, raw, LL_ADC_RESOLUTION);
-            scaled *= operativeAdcMultiplier;
-#elif defined(ARCH_ESP32) // ADC block for espressif platforms
+#ifdef ARCH_ESP32 // ADC block for espressif platforms
             raw = espAdcRead();
             scaled = esp_adc_cal_raw_to_voltage(raw, adc_characs);
             scaled *= operativeAdcMultiplier;
-#else                     // block for all other platforms
+#else // block for all other platforms
 #ifdef ARCH_NRF52
             concurrency::LockGuard saadcGuard(concurrency::nrf52SaadcLock);
 #endif
@@ -495,7 +473,7 @@ class AnalogBatteryLevel : public HasBatteryLevel
 // technically speaking this should work for all(?) NRF52 boards
 // but needs testing across multiple devices. NRF52 USB would not even work if
 // VBUS was not properly connected and detected by the CPU
-#elif defined(MUZI_BASE) || defined(PROMICRO_DIY_TCXO)
+#elif defined(MUZI_BASE) || defined(PROMICRO_DIY_TCXO) || defined(HOCKEY_PUCK)
         return powerHAL_isVBUSConnected();
 #endif
         return getBattVoltage() > chargingVolt;
@@ -552,11 +530,6 @@ class AnalogBatteryLevel : public HasBatteryLevel
     bool initial_read_done = false;
     float last_read_value = (OCV[NUM_OCV_POINTS - 1] * NUM_CELLS);
     uint32_t last_read_time_ms = 0;
-#ifdef ARCH_STM32WL
-    // 3300mV placeholder for STM32 errata where VREFINT factory calibration may be missing
-    // (e.g. STM32U0, see DS14756 Rev 3 §2.4.1 "VREFINT offset")
-    uint32_t Vref = 3300;
-#endif
 
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && defined(HAS_RAKPROT)
 
@@ -666,9 +639,7 @@ bool Power::analogInit()
 #define BATTERY_SENSE_RESOLUTION_BITS 10
 #endif
 
-#ifdef ARCH_STM32WL
-    analogReadResolution(BATTERY_SENSE_RESOLUTION_BITS);
-#elif defined(ARCH_ESP32) // ESP32 needs special analog stuff
+#ifdef ARCH_ESP32 // ESP32 needs special analog stuff
 
 #ifndef ADC_WIDTH // max resolution by default
     static const adc_bits_width_t width = ADC_WIDTH_BIT_12;
@@ -678,7 +649,7 @@ bool Power::analogInit()
 #ifndef BAT_MEASURE_ADC_UNIT // ADC1
     adc1_config_width(width);
     adc1_config_channel_atten(adc_channel, atten);
-#else                        // ADC2
+#else // ADC2
     adc2_config_channel_atten(adc_channel, atten);
 #ifndef CONFIG_IDF_TARGET_ESP32S3
     // ADC2 wifi bug workaround
@@ -708,7 +679,7 @@ bool Power::analogInit()
 
     // NRF52 ADC init moved to powerHAL_init in nrf52 platform
 
-#if !defined(ARCH_ESP32) && !defined(ARCH_STM32WL)
+#ifndef ARCH_ESP32
     analogReadResolution(BATTERY_SENSE_RESOLUTION_BITS);
 #endif
 

src/RedirectablePrint.cpp

@@ -137,7 +137,7 @@ void RedirectablePrint::log_to_serial(const char *logLevel, const char *format,
         if (color) {
             ::printf("\u001b[0m");
         }
-        ::printf("| %02d:%02d:%02d %u.%03u ", hour, min, sec, millis() / 1000, millis() % 1000);
+        ::printf("| %02d:%02d:%02d %u ", hour, min, sec, millis() / 1000);
 #else
         printf("%s ", logLevel);
         if (color) {
@@ -151,7 +151,7 @@ void RedirectablePrint::log_to_serial(const char *logLevel, const char *format,
         if (color) {
             ::printf("\u001b[0m");
         }
-        ::printf("| ??:??:?? %u.%03u ", millis() / 1000, millis() % 1000);
+        ::printf("| ??:??:?? %u ", millis() / 1000);
 #else
         printf("%s ", logLevel);
         if (color) {

src/SerialConsole.cpp

@@ -30,9 +30,6 @@ SerialConsole *console;
 
 void consoleInit()
 {
-    if (console) {
-        return;
-    }
     auto sc = new SerialConsole(); // Must be dynamically allocated because we are now inheriting from thread
 
 #if defined(SERIAL_HAS_ON_RECEIVE)

src/configuration.h

@@ -78,11 +78,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 // Configuration
 // -----------------------------------------------------------------------------
 
-// Pre-hop drop handling (compile-time flag).
-#ifndef MESHTASTIC_PREHOP_DROP
-#define MESHTASTIC_PREHOP_DROP 0
-#endif
-
 /// Convert a preprocessor name into a quoted string
 #define xstr(s) ystr(s)
 #define ystr(s) #s
@@ -231,7 +226,7 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define BME_ADDR 0x76
 #define BME_ADDR_ALTERNATE 0x77
 #define MCP9808_ADDR 0x18
-#define INA_ADDR 0x40 // same as SHT2X
+#define INA_ADDR 0x40
 #define INA_ADDR_ALTERNATE 0x41
 #define INA_ADDR_WAVESHARE_UPS 0x43
 #define INA3221_ADDR 0x42
@@ -244,8 +239,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define LPS22HB_ADDR 0x5C
 #define LPS22HB_ADDR_ALT 0x5D
 #define SFA30_ADDR 0x5D
-#define SHTXX_ADDR 0x44
-#define SHTXX_ADDR_ALT 0x45
+#define SHT31_4x_ADDR 0x44
+#define SHT31_4x_ADDR_ALT 0x45
 #define PMSA003I_ADDR 0x12
 #define QMA6100P_ADDR 0x12
 #define AHT10_ADDR 0x38
@@ -515,7 +510,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define MESHTASTIC_EXCLUDE_REMOTEHARDWARE 1
 #define MESHTASTIC_EXCLUDE_STOREFORWARD 1
 #define MESHTASTIC_EXCLUDE_TEXTMESSAGE 1
-#define MESHTASTIC_EXCLUDE_TRAFFIC_MANAGEMENT 1
 #define MESHTASTIC_EXCLUDE_ATAK 1
 #define MESHTASTIC_EXCLUDE_CANNEDMESSAGES 1
 #define MESHTASTIC_EXCLUDE_NEIGHBORINFO 1

src/detect/ScanI2C.h

@@ -31,6 +31,9 @@ class ScanI2C
         INA3221,
         MAX17048,
         MCP9808,
+        SHT31,
+        SHT4X,
+        SHTC3,
         LPS22HB,
         QMC6310U,
         QMC6310N,
@@ -91,8 +94,7 @@ class ScanI2C
         SFA30,
         CW2015,
         SCD30,
-        ADS1115,
-        SHTXX
+        ADS1115
     } DeviceType;
 
     // typedef uint8_t DeviceAddress;

src/detect/ScanI2CTwoWire.cpp

@@ -136,9 +136,7 @@ bool ScanI2CTwoWire::i2cCommandResponseLength(ScanI2C::DeviceAddress addr, uint1
     return match;
 }
 
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_AIR_QUALITY_SENSOR
-// FIXME Move to a separate file for detection of sensors that require more complex interactions?
-// For SEN5X detection
+/// for SEN5X detection
 // Note, this code needs to be called before setting the I2C bus speed
 // for the screen at high speed. The speed needs to be at 100kHz, otherwise
 // detection will not work
@@ -176,46 +174,6 @@ String readSEN5xProductName(TwoWire *i2cBus, uint8_t address)
 
     return String(productName);
 }
-#endif
-
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
-bool detectSHT21SerialNumber(TwoWire *i2cBus, uint8_t address)
-{
-
-    i2cBus->beginTransmission(address);
-    i2cBus->write(0xFA);
-    i2cBus->write(0x0F);
-
-    if (i2cBus->endTransmission() != 0)
-        return false;
-
-    if (i2cBus->requestFrom(address, (uint8_t)8) != 8)
-        return false;
-
-    // Just flush the data
-    while (i2cBus->available() < 8) {
-        i2cBus->read();
-    }
-
-    i2cBus->beginTransmission(address);
-    i2cBus->write(0xFC);
-    i2cBus->write(0xC9);
-
-    if (i2cBus->endTransmission() != 0)
-        return false;
-
-    if (i2cBus->requestFrom(address, (uint8_t)6) != 6)
-        return false;
-
-    // Just flush the data
-    while (i2cBus->available() < 6) {
-        i2cBus->read();
-    }
-
-    // Assume we detect the SHT21 if something came back from the request
-    return true;
-}
-#endif
 
 #define SCAN_SIMPLE_CASE(ADDR, T, ...)                                                                                           \
     case ADDR:                                                                                                                   \
@@ -413,7 +371,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                 break;
 #endif
 #if !defined(M5STACK_UNITC6L)
-            case INA_ADDR: // Same as SHT2X
+            case INA_ADDR:
             case INA_ADDR_ALTERNATE:
             case INA_ADDR_WAVESHARE_UPS:
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xFE), 2);
@@ -429,12 +387,7 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                         logFoundDevice("INA260", (uint8_t)addr.address);
                         type = INA260;
                     }
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
-                } else if (detectSHT21SerialNumber(i2cBus, (uint8_t)addr.address)) {
-                    logFoundDevice("SHTXX (SHT2X)", (uint8_t)addr.address);
-                    type = SHTXX;
-#endif
-                } else { // Assume INA219 if none of the above ones are found
+                } else { // Assume INA219 if INA260 ID is not found
                     logFoundDevice("INA219", (uint8_t)addr.address);
                     type = INA219;
                 }
@@ -495,19 +448,22 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                     }
                     break;
                 }
-            case SHTXX_ADDR:     // same as OPT3001_ADDR_ALT
-            case SHTXX_ADDR_ALT: // same as OPT3001_ADDR
+            case SHT31_4x_ADDR:     // same as OPT3001_ADDR_ALT
+            case SHT31_4x_ADDR_ALT: // same as OPT3001_ADDR
                 if (getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0x7E), 2) == 0x5449) {
                     type = OPT3001;
                     logFoundDevice("OPT3001", (uint8_t)addr.address);
-                } else { // SHTXX
-                    type = SHTXX;
-                    logFoundDevice("SHTXX", (uint8_t)addr.address);
+                } else if (i2cCommandResponseLength(addr, 0x89, 6)) { // SHT4x serial number (6 bytes inc. CRC)
+                    type = SHT4X;
+                    logFoundDevice("SHT4X", (uint8_t)addr.address);
+                } else {
+                    type = SHT31;
+                    logFoundDevice("SHT31", (uint8_t)addr.address);
                 }
 
                 break;
 
-                SCAN_SIMPLE_CASE(SHTC3_ADDR, SHTXX, "SHTXX", (uint8_t)addr.address)
+                SCAN_SIMPLE_CASE(SHTC3_ADDR, SHTC3, "SHTC3", (uint8_t)addr.address)
             case RCWL9620_ADDR:
                 // get MAX30102 PARTID
                 registerValue = getRegisterValue(ScanI2CTwoWire::RegisterLocation(addr, 0xFF), 1);
@@ -719,7 +675,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                     logFoundDevice("BMX160", (uint8_t)addr.address);
                     break;
                 } else {
-#if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_AIR_QUALITY_SENSOR
                     String prod = "";
                     prod = readSEN5xProductName(i2cBus, addr.address);
                     if (prod.startsWith("SEN55")) {
@@ -735,7 +690,6 @@ void ScanI2CTwoWire::scanPort(I2CPort port, uint8_t *address, uint8_t asize)
                         logFoundDevice("Sensirion SEN50", addr.address);
                         break;
                     }
-#endif
                     if (addr.address == BMX160_ADDR) {
                         type = BMX160;
                         logFoundDevice("BMX160", (uint8_t)addr.address);

src/gps/GPS.cpp

@@ -103,14 +103,6 @@ static int32_t gpsSwitch()
     if (gps) {
         int currentState = digitalRead(PIN_GPS_SWITCH);
 
-        // Respect explicit NOT_PRESENT mode and do not let the hardware switch re-enable GPS.
-        if (config.position.gps_mode == meshtastic_Config_PositionConfig_GpsMode_NOT_PRESENT) {
-            gps->disable();
-            lastState = currentState;
-            firstrun = false;
-            return 1000;
-        }
-
         // if the switch is set to zero, disable the GPS Thread
         if (firstrun)
             if (currentState == LOW)

src/graphics/TFTDisplay.cpp

@@ -1254,14 +1254,14 @@ void TFTDisplay::display(bool fromBlank)
 
         // Did we find a pixel that needs updating on this row?
         if (x_FirstPixelUpdate < displayWidth) {
-            // Align the first pixel for update to an even number so the total alignment of
-            // the data will be at 32-bit boundary, which is required by GDMA SPI transfers.
-            x_FirstPixelUpdate &= ~1;
 
-            // Step 3a: copy rest of the pixels in this row into the pixel line buffer,
-            // while also recording the last pixel in the row that needs updating.
-            // Since the first changed pixel will be looked up, the x_LastPixelUpdate will be set.
-            for (x = x_FirstPixelUpdate; x < displayWidth; x++) {
+            // Quickly write out the first changed pixel (saves another array lookup)
+            linePixelBuffer[x_FirstPixelUpdate] = isset ? colorTftMesh : colorTftBlack;
+            x_LastPixelUpdate = x_FirstPixelUpdate;
+
+            // Step 3: copy all remaining pixels in this row into the pixel line buffer,
+            // while also recording the last pixel in the row that needs updating
+            for (x = x_FirstPixelUpdate + 1; x < displayWidth; x++) {
                 isset = buffer[x + y_byteIndex] & y_byteMask;
                 linePixelBuffer[x] = isset ? colorTftMesh : colorTftBlack;
 
@@ -1274,14 +1274,6 @@ void TFTDisplay::display(bool fromBlank)
                     x_LastPixelUpdate = x;
                 }
             }
-            // Step 3b: Round up the last pixel to odd number to maintain 32-bit alignment for SPIs.
-            // Most displays will have even number of pixels in a row -- this will be in bounds
-            // of the displayWidth. (Hopefully odd displays will just ignore that extra pixel.)
-            x_LastPixelUpdate |= 1;
-            // Ensure the last pixel index does not exceed the display width.
-            if (x_LastPixelUpdate >= displayWidth) {
-                x_LastPixelUpdate = displayWidth - 1;
-            }
 #if defined(HACKADAY_COMMUNICATOR)
             tft->draw16bitBeRGBBitmap(x_FirstPixelUpdate, y, &linePixelBuffer[x_FirstPixelUpdate],
                                       (x_LastPixelUpdate - x_FirstPixelUpdate + 1), 1);

src/graphics/draw/DebugRenderer.cpp

@@ -408,16 +408,7 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
     display->drawString(nameX, getTextPositions(display)[line++], device_role);
 
     // === Third Row: Radio Preset ===
-    // For custom modem settings show the actual parameters; for presets use the preset name.
-    char modeStr[16];
-    if (!config.lora.use_preset) {
-        snprintf(modeStr, sizeof(modeStr), "BW%u-SF%u-CR%u", static_cast<unsigned>(config.lora.bandwidth),
-                 static_cast<unsigned>(config.lora.spread_factor), static_cast<unsigned>(config.lora.coding_rate));
-    } else {
-        strncpy(modeStr, DisplayFormatters::getModemPresetDisplayName(config.lora.modem_preset, false, true),
-                sizeof(modeStr) - 1);
-        modeStr[sizeof(modeStr) - 1] = '\0';
-    }
+    auto mode = DisplayFormatters::getModemPresetDisplayName(config.lora.modem_preset, false, config.lora.use_preset);
 
     char regionradiopreset[25];
     const char *region = myRegion ? myRegion->name : NULL;
@@ -425,7 +416,7 @@ void drawLoRaFocused(OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x,
         if (currentResolution == ScreenResolution::UltraLow) {
             snprintf(regionradiopreset, sizeof(regionradiopreset), "%s", region);
         } else {
-            snprintf(regionradiopreset, sizeof(regionradiopreset), "%s/%s", region, modeStr);
+            snprintf(regionradiopreset, sizeof(regionradiopreset), "%s/%s", region, mode);
         }
     }
     textWidth = display->getStringWidth(regionradiopreset);

src/graphics/draw/MenuHandler.cpp

@@ -18,7 +18,6 @@
 #include "main.h"
 #include "mesh/Default.h"
 #include "mesh/MeshTypes.h"
-#include "mesh/RadioLibInterface.h"
 #include "modules/AdminModule.h"
 #include "modules/CannedMessageModule.h"
 #include "modules/ExternalNotificationModule.h"
@@ -26,7 +25,6 @@
 #include "modules/TraceRouteModule.h"
 #include <algorithm>
 #include <array>
-#include <cmath>
 #include <functional>
 #include <utility>
 
@@ -161,22 +159,31 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
                 return;
             }
 
-            // Guard: without a reboot, reconfigure() applies the region directly.
-            // Reject LORA_24 on sub-GHz-only hardware — getRadio() used to catch this post-reboot.
-            // TODO: change this to either use the validateLoraConfig() logic or at least check the region for wideLora
-            // rather than a hardcoded check for LORA_24.
-            if (selectedRegion == meshtastic_Config_LoRaConfig_RegionCode_LORA_24 &&
-                !(RadioLibInterface::instance && RadioLibInterface::instance->wideLora())) {
-                LOG_WARN("Radio hardware does not support 2.4 GHz; ignoring region selection");
-                return;
-            }
-
             config.lora.region = selectedRegion;
             auto changes = SEGMENT_CONFIG;
 
+        // FIXME: This should be a method consolidated with the same logic in the admin message as well
+        // This is needed as we wait til picking the LoRa region to generate keys for the first time.
 #if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
-            if (crypto) {
-                crypto->ensurePkiKeys(config.security, owner);
+            if (!owner.is_licensed) {
+                bool keygenSuccess = false;
+                if (config.security.private_key.size == 32) {
+                    // public key is derived from private, so this will always have the same result.
+                    if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) {
+                        keygenSuccess = true;
+                    }
+
+                } else {
+                    LOG_INFO("Generate new PKI keys");
+                    crypto->generateKeyPair(config.security.public_key.bytes, config.security.private_key.bytes);
+                    keygenSuccess = true;
+                }
+                if (keygenSuccess) {
+                    config.security.public_key.size = 32;
+                    config.security.private_key.size = 32;
+                    owner.public_key.size = 32;
+                    memcpy(owner.public_key.bytes, config.security.public_key.bytes, 32);
+                }
             }
 #endif
             config.lora.tx_enabled = true;
@@ -192,6 +199,7 @@ void menuHandler::LoraRegionPicker(uint32_t duration)
             }
 
             service->reloadConfig(changes);
+            rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
         });
 
     bannerOptions.durationMs = duration;
@@ -257,24 +265,13 @@ void menuHandler::FrequencySlotPicker()
     optionsEnumArray[options++] = 0;
 
     // Calculate number of channels (copied from RadioInterface::applyModemConfig())
-
     meshtastic_Config_LoRaConfig &loraConfig = config.lora;
     double bw = loraConfig.use_preset ? modemPresetToBwKHz(loraConfig.modem_preset, myRegion->wideLora)
                                       : bwCodeToKHz(loraConfig.bandwidth);
 
     uint32_t numChannels = 0;
     if (myRegion) {
-        // Match RadioInterface::applyModemConfig(): include padding, add spacing in numerator, and use round()
-        const double spacing = myRegion->profile->spacing;
-        const double padding = myRegion->profile->padding;
-        const double channelBandwidthMHz = bw / 1000.0;
-        const double numerator = (myRegion->freqEnd - myRegion->freqStart) + spacing;
-        const double denominator = spacing + (padding * 2) + channelBandwidthMHz;
-        if (denominator > 0.0) {
-            numChannels = static_cast<uint32_t>(round(numerator / denominator));
-        } else {
-            LOG_WARN("Invalid region configuration: non-positive channel spacing/width");
-        }
+        numChannels = (uint32_t)floor((myRegion->freqEnd - myRegion->freqStart) / (myRegion->spacing + (bw / 1000.0)));
     } else {
         LOG_WARN("Region not set, cannot calculate number of channels");
         return;
@@ -310,6 +307,7 @@ void menuHandler::FrequencySlotPicker()
 
         config.lora.channel_num = selected;
         service->reloadConfig(SEGMENT_CONFIG);
+        rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
     };
 
     screen->showOverlayBanner(bannerOptions);
@@ -348,6 +346,7 @@ void menuHandler::radioPresetPicker()
             config.lora.channel_num = 0;        // Reset to default channel for the preset
             config.lora.override_frequency = 0; // Clear any custom frequency
             service->reloadConfig(SEGMENT_CONFIG);
+            rebootAtMsec = (millis() + DEFAULT_REBOOT_SECONDS * 1000);
         });
 
     screen->showOverlayBanner(bannerOptions);

src/graphics/niche/InkHUD/Applets/System/Menu/MenuApplet.cpp

@@ -177,8 +177,24 @@ static void applyLoRaRegion(meshtastic_Config_LoRaConfig_RegionCode region)
     auto changes = SEGMENT_CONFIG;
 
 #if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
-    if (crypto) {
-        crypto->ensurePkiKeys(config.security, owner);
+    if (!owner.is_licensed) {
+        bool keygenSuccess = false;
+
+        if (config.security.private_key.size == 32) {
+            if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) {
+                keygenSuccess = true;
+            }
+        } else {
+            crypto->generateKeyPair(config.security.public_key.bytes, config.security.private_key.bytes);
+            keygenSuccess = true;
+        }
+
+        if (keygenSuccess) {
+            config.security.public_key.size = 32;
+            config.security.private_key.size = 32;
+            owner.public_key.size = 32;
+            memcpy(owner.public_key.bytes, config.security.public_key.bytes, 32);
+        }
     }
 #endif
 

src/mesh/CryptoEngine.cpp

@@ -4,7 +4,6 @@
 #include <memory>
 
 #if !(MESHTASTIC_EXCLUDE_PKI)
-#include "HardwareRNG.h"
 #include "NodeDB.h"
 #include "aes-ccm.h"
 #include "meshUtils.h"
@@ -27,15 +26,6 @@ void CryptoEngine::generateKeyPair(uint8_t *pubKey, uint8_t *privKey)
 {
     // Mix in any randomness we can, to make key generation stronger.
     CryptRNG.begin(optstr(APP_VERSION));
-
-    uint8_t hardwareEntropy[64] = {0};
-    if (HardwareRNG::fill(hardwareEntropy, sizeof(hardwareEntropy), true)) {
-        CryptRNG.stir(hardwareEntropy, sizeof(hardwareEntropy));
-    } else {
-        LOG_WARN("Hardware entropy unavailable, falling back to software RNG");
-    }
-    memset(hardwareEntropy, 0, sizeof(hardwareEntropy));
-
     if (myNodeInfo.device_id.size == 16) {
         CryptRNG.stir(myNodeInfo.device_id.bytes, myNodeInfo.device_id.size);
     }
@@ -71,33 +61,6 @@ bool CryptoEngine::regeneratePublicKey(uint8_t *pubKey, uint8_t *privKey)
     }
     return true;
 }
-
-bool CryptoEngine::ensurePkiKeys(meshtastic_Config_SecurityConfig &security, meshtastic_User &user)
-{
-    if (user.is_licensed) {
-        return false;
-    }
-
-    bool keygenSuccess = false;
-    if (security.private_key.size == 32) {
-        if (regeneratePublicKey(security.public_key.bytes, security.private_key.bytes)) {
-            keygenSuccess = true;
-        }
-    } else {
-        LOG_INFO("Generate new PKI keys");
-        generateKeyPair(security.public_key.bytes, security.private_key.bytes);
-        keygenSuccess = true;
-    }
-
-    if (keygenSuccess) {
-        security.public_key.size = 32;
-        security.private_key.size = 32;
-        user.public_key.size = 32;
-        memcpy(user.public_key.bytes, security.public_key.bytes, 32);
-    }
-
-    return keygenSuccess;
-}
 #endif
 
 /**

src/mesh/CryptoEngine.h

@@ -36,7 +36,6 @@ class CryptoEngine
 #if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN)
     virtual void generateKeyPair(uint8_t *pubKey, uint8_t *privKey);
     virtual bool regeneratePublicKey(uint8_t *pubKey, uint8_t *privKey);
-    virtual bool ensurePkiKeys(meshtastic_Config_SecurityConfig &security, meshtastic_User &user);
 
 #endif
     void setDHPrivateKey(uint8_t *_private_key);

src/mesh/Default.h

@@ -30,11 +30,6 @@
 #define min_node_info_broadcast_secs 60 * 60 // No regular broadcasts of more than once an hour
 #define min_neighbor_info_broadcast_secs 4 * 60 * 60
 #define default_map_publish_interval_secs 60 * 60
-
-// Traffic management defaults
-#define default_traffic_mgmt_position_precision_bits 24               // ~10m grid cells
-#define default_traffic_mgmt_position_min_interval_secs (ONE_DAY / 2) // 12 hours between identical positions
-
 #ifdef USERPREFS_RINGTONE_NAG_SECS
 #define default_ringtone_nag_secs USERPREFS_RINGTONE_NAG_SECS
 #else

src/mesh/HardwareRNG.cpp

@@ -1,160 +0,0 @@
-#include "HardwareRNG.h"
-
-#include <algorithm>
-#include <cstring>
-#include <random>
-
-#include "configuration.h"
-
-#if HAS_RADIO
-#include "RadioLibInterface.h"
-#endif
-
-#if defined(ARCH_NRF52)
-#include <Adafruit_nRFCrypto.h>
-extern Adafruit_nRFCrypto nRFCrypto;
-#elif defined(ARCH_ESP32)
-#include <esp_system.h>
-#elif defined(ARCH_RP2040)
-#include <Arduino.h>
-#elif defined(ARCH_PORTDUINO)
-#include <random>
-#include <sys/random.h>
-#include <unistd.h>
-#endif
-
-namespace HardwareRNG
-{
-
-namespace
-{
-void fillWithRandomDevice(uint8_t *buffer, size_t length)
-{
-    std::random_device rd;
-    size_t offset = 0;
-    while (offset < length) {
-        uint32_t value = rd();
-        size_t toCopy = std::min(length - offset, sizeof(value));
-        memcpy(buffer + offset, &value, toCopy);
-        offset += toCopy;
-    }
-}
-
-#if HAS_RADIO
-bool mixWithLoRaEntropy(uint8_t *buffer, size_t length)
-{
-    // Only attempt to pull entropy from the modem if it is initialized and exposes the helper.
-    // When the radio stack is disabled or has not yet been configured, we simply skip this step
-    // and return false so callers know no extra mixing occurred.
-    RadioLibInterface *radio = RadioLibInterface::instance;
-    if (!radio) {
-        // Intentionally silent: this path runs during portduinoSetup() before the
-        // console/SerialConsole is initialized, so LOG_* here would dereference a null pointer.
-        return false;
-    }
-
-    constexpr size_t chunkSize = 16;
-    uint8_t scratch[chunkSize];
-    size_t offset = 0;
-    bool mixed = false;
-
-    while (offset < length) {
-        size_t toCopy = std::min(length - offset, chunkSize);
-
-        // randomBytes() returns false if the modem does not support it or is not ready
-        // (for instance, when the radio is powered down). We break immediately to avoid
-        // blocking or returning partially-filled entropy and simply report failure.
-        if (!radio->randomBytes(scratch, toCopy)) {
-            break;
-        }
-
-        for (size_t i = 0; i < toCopy; ++i) {
-            buffer[offset + i] ^= scratch[i];
-        }
-
-        mixed = true;
-        offset += toCopy;
-    }
-
-    // Avoid leaving the modem-sourced bytes sitting on the stack longer than needed.
-    if (mixed) {
-        memset(scratch, 0, sizeof(scratch));
-    }
-
-    return mixed;
-}
-#endif
-} // namespace
-
-bool fill(uint8_t *buffer, size_t length, bool useRadioEntropy)
-{
-    if (!buffer || length == 0) {
-        return false;
-    }
-
-    bool filled = false;
-
-#if defined(ARCH_NRF52)
-    // The Nordic SDK RNG provides cryptographic-quality randomness backed by hardware.
-    nRFCrypto.begin();
-    auto result = nRFCrypto.Random.generate(buffer, length);
-    nRFCrypto.end();
-    filled = result;
-#elif defined(ARCH_ESP32)
-    // ESP32 exposes a true RNG via esp_fill_random().
-    esp_fill_random(buffer, length);
-    filled = true;
-#elif defined(ARCH_RP2040)
-    // RP2040 has a hardware random number generator accessible through the Arduino core.
-    size_t offset = 0;
-    while (offset < length) {
-        uint32_t value = rp2040.hwrand32();
-        size_t toCopy = std::min(length - offset, sizeof(value));
-        memcpy(buffer + offset, &value, toCopy);
-        offset += toCopy;
-    }
-    filled = true;
-#elif defined(ARCH_PORTDUINO)
-    // Prefer the host OS RNG first when running under Portduino.
-    ssize_t generated = ::getrandom(buffer, length, 0);
-    if (generated == static_cast<ssize_t>(length)) {
-        filled = true;
-    }
-
-    if (!filled) {
-        fillWithRandomDevice(buffer, length);
-        filled = true;
-    }
-#endif
-
-    if (!filled) {
-        // As a last resort, fall back to std::random_device. This should only be reached
-        // if a platform-specific source was unavailable.
-        fillWithRandomDevice(buffer, length);
-        filled = true;
-    }
-
-#if HAS_RADIO
-    if (useRadioEntropy) {
-        // Best-effort: if the radio is active and can provide modem entropy, XOR it over the
-        // buffer to improve overall quality. We consider the filling a success if either a
-        // good platform RNG or the modem RNG provided data, so we return true as long as at
-        // least one of those steps succeeded.
-        filled = mixWithLoRaEntropy(buffer, length) || filled;
-    }
-#endif
-
-    return filled;
-}
-
-bool seed(uint32_t &seedOut)
-{
-    uint32_t candidate = 0;
-    if (!fill(reinterpret_cast<uint8_t *>(&candidate), sizeof(candidate), true)) {
-        return false;
-    }
-    seedOut = candidate;
-    return true;
-}
-
-} // namespace HardwareRNG

src/mesh/HardwareRNG.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <cstdint>
-
-namespace HardwareRNG
-{
-
-/**
- * Fill the provided buffer with random bytes sourced from the most
- * appropriate hardware-backed RNG available on the current platform.
- *
- * @param buffer Destination buffer for random bytes
- * @param length Number of bytes to write
- * @param useRadioEntropy If true, attempt to mix radio entropy into the output as well.
- * @return true if the buffer was fully populated with entropy, false on failure
- */
-bool fill(uint8_t *buffer, size_t length, bool useRadioEntropy = false);
-
-/**
- * Populate a 32-bit seed value with hardware-backed randomness where possible.
- *
- * @param seedOut Destination for the generated seed value
- * @return true if a seed was produced from a reliable entropy source
- */
-bool seed(uint32_t &seedOut);
-
-} // namespace HardwareRNG

src/mesh/LR11x0Interface.cpp

@@ -71,10 +71,12 @@ template <typename T> bool LR11x0Interface<T>::init()
 
     RadioLibInterface::init();
 
-    if (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24) { // clamp if wide freq range
-        limitPower(LR1120_MAX_POWER);
-    } else {
-        limitPower(LR1110_MAX_POWER); // default clamp for non-wide freq range
+    limitPower(LR1110_MAX_POWER);
+
+    if ((power > LR1120_MAX_POWER) &&
+        (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) { // clamp again if wide freq range
+        power = LR1120_MAX_POWER;
+        preambleLength = 12; // 12 is the default for operation above 2GHz
     }
 
 #ifdef LR11X0_RF_SWITCH_SUBGHZ
@@ -175,12 +177,6 @@ template <typename T> bool LR11x0Interface<T>::reconfigure()
     err = lora.setSyncWord(syncWord);
     assert(err == RADIOLIB_ERR_NONE);
 
-    if (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24) { // clamp if wide freq range
-        limitPower(LR1120_MAX_POWER);
-    } else {
-        limitPower(LR1110_MAX_POWER); // default clamp for non-wide freq range
-    }
-
     err = lora.setPreambleLength(preambleLength);
     assert(err == RADIOLIB_ERR_NONE);
 
@@ -188,14 +184,14 @@ template <typename T> bool LR11x0Interface<T>::reconfigure()
     if (err != RADIOLIB_ERR_NONE)
         RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
 
+    if (power > LR1110_MAX_POWER) // This chip has lower power limits than some
+        power = LR1110_MAX_POWER;
+    if ((power > LR1120_MAX_POWER) && (config.lora.region == meshtastic_Config_LoRaConfig_RegionCode_LORA_24)) // 2.4G power limit
+        power = LR1120_MAX_POWER;
+
     err = lora.setOutputPower(power);
     assert(err == RADIOLIB_ERR_NONE);
 
-    // Apply RX gain mode — valid in STDBY, matches resetAGC() pattern
-    err = lora.setRxBoostedGainMode(config.lora.sx126x_rx_boosted_gain);
-    if (err != RADIOLIB_ERR_NONE)
-        LOG_WARN("LR11x0 setRxBoostedGainMode %s%d", radioLibErr, err);
-
     startReceive(); // restart receiving
 
     return RADIOLIB_ERR_NONE;

src/mesh/MeshRadio.h

@@ -4,54 +4,19 @@
 #include "MeshTypes.h"
 #include "PointerQueue.h"
 #include "configuration.h"
-#include "detect/LoRaRadioType.h"
-
-// Sentinel marking the end of a modem preset array
-static constexpr meshtastic_Config_LoRaConfig_ModemPreset MODEM_PRESET_END =
-    static_cast<meshtastic_Config_LoRaConfig_ModemPreset>(0xFF);
-
-// Region profile: bundles the preset list with regulatory parameters shared across regions
-struct RegionProfile {
-    const meshtastic_Config_LoRaConfig_ModemPreset *presets; // sentinel-terminated; first entry is the default
-    float spacing;                                           // gaps between radio channels
-    float padding;                                           // padding at each side of the "operating channel"
-    bool audioPermitted;
-    bool licensedOnly;        // a region profile for licensed operators only
-    int8_t textThrottle;      // throttle for text - future expansion
-    int8_t positionThrottle;  // throttle for location data - future expansion
-    int8_t telemetryThrottle; // throttle for telemetry - future expansion
-    uint8_t overrideSlot;     // a per-region override slot for if we need to fix it in place
-};
-
-extern const RegionProfile PROFILE_STD;
-extern const RegionProfile PROFILE_EU868;
-extern const RegionProfile PROFILE_UNDEF;
-// extern const RegionProfile  PROFILE_LITE;
-// extern const RegionProfile  PROFILE_NARROW;
-// extern const RegionProfile  PROFILE_HAM;
 
 // Map from old region names to new region enums
 struct RegionInfo {
     meshtastic_Config_LoRaConfig_RegionCode code;
     float freqStart;
     float freqEnd;
-    float dutyCycle;    // modified by getEffectiveDutyCycle
+    float dutyCycle;
+    float spacing;
     uint8_t powerLimit; // Or zero for not set
+    bool audioPermitted;
     bool freqSwitching;
     bool wideLora;
-    const RegionProfile *profile;
     const char *name; // EU433 etc
-
-    // Preset accessors (delegate through profile)
-    meshtastic_Config_LoRaConfig_ModemPreset getDefaultPreset() const { return profile->presets[0]; }
-    const meshtastic_Config_LoRaConfig_ModemPreset *getAvailablePresets() const { return profile->presets; }
-    size_t getNumPresets() const
-    {
-        size_t n = 0;
-        while (profile->presets[n] != MODEM_PRESET_END)
-            n++;
-        return n;
-    }
 };
 
 extern const RegionInfo regions[];
@@ -60,7 +25,7 @@ extern const RegionInfo *myRegion;
 extern void initRegion();
 
 // Valid LoRa spread factor range and defaults
-constexpr uint8_t LORA_SF_MIN = 5;
+constexpr uint8_t LORA_SF_MIN = 7;
 constexpr uint8_t LORA_SF_MAX = 12;
 constexpr uint8_t LORA_SF_DEFAULT = 11; // LONG_FAST default
 
@@ -72,14 +37,10 @@ constexpr uint8_t LORA_CR_DEFAULT = 5; // LONG_FAST default
 // Default bandwidth in kHz (LONG_FAST)
 constexpr float LORA_BW_DEFAULT_KHZ = 250.0f;
 
-/// Clamp spread factor to the valid LoRa range [5, 12].
+/// Clamp spread factor to the valid LoRa range [7, 12].
 /// Out-of-range values (including 0 from unset preset mode) return LORA_SF_DEFAULT.
 static inline uint8_t clampSpreadFactor(uint8_t sf)
 {
-    // We check for RF95 radios that are incompatible with Spreading Factors 5 and 6.
-    if (radioType == RF95_RADIO && (sf == 5 || sf == 6))
-        return LORA_SF_DEFAULT;
-
     if (sf < LORA_SF_MIN || sf > LORA_SF_MAX)
         return LORA_SF_DEFAULT;
     return sf;

src/mesh/NextHopRouter.cpp

@@ -4,9 +4,6 @@
 #if !MESHTASTIC_EXCLUDE_TRACEROUTE
 #include "modules/TraceRouteModule.h"
 #endif
-#if HAS_TRAFFIC_MANAGEMENT
-#include "modules/TrafficManagementModule.h"
-#endif
 #include "NodeDB.h"
 
 NextHopRouter::NextHopRouter() {}
@@ -129,28 +126,15 @@ void NextHopRouter::sniffReceived(const meshtastic_MeshPacket *p, const meshtast
 /* Check if we should be rebroadcasting this packet if so, do so. */
 bool NextHopRouter::perhapsRebroadcast(const meshtastic_MeshPacket *p)
 {
-    // Check if traffic management wants to exhaust this packet's hops
-    bool exhaustHops = false;
-#if HAS_TRAFFIC_MANAGEMENT
-    if (trafficManagementModule && trafficManagementModule->shouldExhaustHops(*p)) {
-        exhaustHops = true;
-    }
-#endif
-
-    // Allow rebroadcast if hop_limit > 0 OR if we're exhausting hops (which sets hop_limit = 0 but still needs one relay)
-    if (!isToUs(p) && !isFromUs(p) && (p->hop_limit > 0 || exhaustHops)) {
+    if (!isToUs(p) && !isFromUs(p) && p->hop_limit > 0) {
         if (p->id != 0) {
             if (isRebroadcaster()) {
                 if (p->next_hop == NO_NEXT_HOP_PREFERENCE || p->next_hop == nodeDB->getLastByteOfNodeNum(getNodeNum())) {
                     meshtastic_MeshPacket *tosend = packetPool.allocCopy(*p); // keep a copy because we will be sending it
                     LOG_INFO("Rebroadcast received message coming from %x", p->relay_node);
 
-                    // If exhausting hops, force hop_limit = 0 regardless of other logic
-                    if (exhaustHops) {
-                        tosend->hop_limit = 0;
-                        LOG_INFO("Traffic management: exhausting hops for 0x%08x, setting hop_limit=0", getFrom(p));
-                    } else if (shouldDecrementHopLimit(p)) {
-                        // Use shared logic to determine if hop_limit should be decremented
+                    // Use shared logic to determine if hop_limit should be decremented
+                    if (shouldDecrementHopLimit(p)) {
                         tosend->hop_limit--; // bump down the hop count
                     } else {
                         LOG_INFO("favorite-ROUTER/CLIENT_BASE-to-ROUTER/CLIENT_BASE rebroadcast: preserving hop_limit");

src/mesh/NodeDB.cpp

@@ -1299,7 +1299,7 @@ void NodeDB::loadFromDisk()
     // Coerce LoRa config fields derived from presets while bootstrapping.
     // Some clients/UI components display bandwidth/spread_factor directly from config even in preset mode.
     if (config.has_lora && config.lora.use_preset) {
-        RadioInterface::clampConfigLora(config.lora);
+        RadioInterface::bootstrapLoRaConfigFromPreset(config.lora);
     }
 
 #if defined(USERPREFS_LORA_TX_DISABLED) && USERPREFS_LORA_TX_DISABLED
@@ -1650,25 +1650,6 @@ uint32_t sinceReceived(const meshtastic_MeshPacket *p)
     return delta;
 }
 
-HopStartStatus classifyHopStart(const meshtastic_MeshPacket &p)
-{
-    // Guard against invalid values.
-    if (p.hop_start < p.hop_limit)
-        return HopStartStatus::INVALID;
-
-    if (p.hop_start == 0) {
-        // Firmware prior to 2.3.0 (585805c) lacked a hop_start field. Firmware version 2.5.0 (bf34329) introduced a
-        // bitfield that is always present. Use the presence of the bitfield to determine if the origin's firmware
-        // version is guaranteed to have hop_start populated. Note that this can only be done for decoded packets as
-        // the bitfield is encrypted under the channel encryption key.
-        if (p.which_payload_variant == meshtastic_MeshPacket_decoded_tag && p.decoded.has_bitfield)
-            return HopStartStatus::VALID;
-        return HopStartStatus::MISSING_OR_UNKNOWN;
-    }
-
-    return HopStartStatus::VALID;
-}
-
 int8_t getHopsAway(const meshtastic_MeshPacket &p, int8_t defaultIfUnknown)
 {
     // Firmware prior to 2.3.0 (585805c) lacked a hop_start field. Firmware version 2.5.0 (bf34329) introduced a
@@ -1706,22 +1687,6 @@ size_t NodeDB::getNumOnlineMeshNodes(bool localOnly)
 #include "MeshModule.h"
 #include "Throttle.h"
 
-static constexpr uint32_t HOPSTART_DROP_LOG_INTERVAL_MS = 15000;
-
-void logHopStartDrop(const meshtastic_MeshPacket &p, const char *context)
-{
-    static uint32_t lastLogMs = 0;
-    if (Throttle::isWithinTimespanMs(lastLogMs, HOPSTART_DROP_LOG_INTERVAL_MS)) {
-        return;
-    }
-    lastLogMs = millis();
-    const bool decoded = (p.which_payload_variant == meshtastic_MeshPacket_decoded_tag);
-    const bool hasBitfield = decoded && p.decoded.has_bitfield;
-    LOG_DEBUG(
-        "Drop packet (%s): hop_start invalid/missing (from=0x%x id=%u hop_start=%u hop_limit=%u decoded=%d has_bitfield=%d)",
-        context ? context : "unknown", p.from, p.id, p.hop_start, p.hop_limit, decoded, hasBitfield);
-}
-
 /** Update position info for this node based on received position data
  */
 void NodeDB::updatePosition(uint32_t nodeId, const meshtastic_Position &p, RxSource src)

src/mesh/NodeDB.h

@@ -114,27 +114,6 @@ uint32_t sinceReceived(const meshtastic_MeshPacket *p);
 /// Returns defaultIfUnknown if the number of hops couldn't be determined.
 int8_t getHopsAway(const meshtastic_MeshPacket &p, int8_t defaultIfUnknown = -1);
 
-enum class HopStartStatus : uint8_t { VALID = 0, MISSING_OR_UNKNOWN, INVALID };
-
-/// Classify hop_start validity for forwarding decisions.
-HopStartStatus classifyHopStart(const meshtastic_MeshPacket &p);
-
-inline bool shouldDropPacketForPreHop(const meshtastic_MeshPacket &p)
-{
-#if !MESHTASTIC_PREHOP_DROP
-    (void)p;
-    return false;
-#else
-    if (isFromUs(&p)) {
-        return false; // local-originated packets should never be dropped by pre-hop drop policy
-    }
-    return classifyHopStart(p) != HopStartStatus::VALID;
-#endif
-}
-
-/// Rate-limited debug log when hop_start is invalid/missing and packet is dropped.
-void logHopStartDrop(const meshtastic_MeshPacket &p, const char *context);
-
 enum LoadFileResult {
     // Successfully opened the file
     LOAD_SUCCESS = 1,

src/mesh/PhoneAPI.cpp

@@ -449,11 +449,6 @@ size_t PhoneAPI::getFromRadio(uint8_t *buf)
             fromRadioScratch.moduleConfig.which_payload_variant = meshtastic_ModuleConfig_paxcounter_tag;
             fromRadioScratch.moduleConfig.payload_variant.paxcounter = moduleConfig.paxcounter;
             break;
-        case meshtastic_ModuleConfig_traffic_management_tag:
-            LOG_DEBUG("Send module config: traffic management");
-            fromRadioScratch.moduleConfig.which_payload_variant = meshtastic_ModuleConfig_traffic_management_tag;
-            fromRadioScratch.moduleConfig.payload_variant.traffic_management = moduleConfig.traffic_management;
-            break;
         default:
             LOG_ERROR("Unknown module config type %d", config_state);
         }

src/mesh/PointerQueue.h

@@ -17,4 +17,14 @@ template <class T> class PointerQueue : public TypedQueue<T *>
 
         return this->dequeue(&p, maxWait) ? p : nullptr;
     }
+
+#ifdef HAS_FREE_RTOS
+    // returns a ptr or null if the queue was empty
+    T *dequeuePtrFromISR(BaseType_t *higherPriWoken)
+    {
+        T *p;
+
+        return this->dequeueFromISR(&p, higherPriWoken) ? p : nullptr;
+    }
+#endif
 };

src/mesh/RF95Interface.cpp

@@ -240,7 +240,8 @@ bool RF95Interface::reconfigure()
     if (err != RADIOLIB_ERR_NONE)
         RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
 
-    limitPower(RF95_MAX_POWER);
+    if (power > RF95_MAX_POWER) // This chip has lower power limits than some
+        power = RF95_MAX_POWER;
 
 #ifdef USE_RF95_RFO
     err = lora->setOutputPower(power, true);

src/mesh/RadioInterface.cpp

@@ -21,7 +21,6 @@
 #include <assert.h>
 #include <pb_decode.h>
 #include <pb_encode.h>
-#include <string.h>
 
 #ifdef ARCH_PORTDUINO
 #include "platform/portduino/PortduinoGlue.h"
@@ -33,32 +32,10 @@
 #include "STM32WLE5JCInterface.h"
 #endif
 
-static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_STD[] = {
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,     meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW,
-    meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW,   meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST,
-    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW,    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST,
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE, meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO,
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO,    MODEM_PRESET_END};
-
-static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_EU_868[] = {
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,     meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW,
-    meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW,   meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST,
-    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW,    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST,
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE, MODEM_PRESET_END};
-
-static const meshtastic_Config_LoRaConfig_ModemPreset PRESETS_UNDEF[] = {meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,
-                                                                         MODEM_PRESET_END};
-
-// Region profiles: bundle preset list + regulatory parameters shared across regions
-// presets, spacing, padding, audio, licensed, text throttle, position throttle, telemetry throttle, override slot
-const RegionProfile PROFILE_STD = {PRESETS_STD, 0, 0, true, false, 0, 0, 0, 0};
-const RegionProfile PROFILE_EU868 = {PRESETS_EU_868, 0, 0, false, false, 0, 0, 0, 0};
-const RegionProfile PROFILE_UNDEF = {PRESETS_UNDEF, 0, 0, true, false, 0, 0, 0, 0};
-
-#define RDEF(name, freq_start, freq_end, duty_cycle, power_limit, frequency_switching, wide_lora, profile_ptr)                   \
+#define RDEF(name, freq_start, freq_end, duty_cycle, spacing, power_limit, audio_permitted, frequency_switching, wide_lora)      \
     {                                                                                                                            \
-        meshtastic_Config_LoRaConfig_RegionCode_##name, freq_start, freq_end, duty_cycle, power_limit, frequency_switching,      \
-            wide_lora, &profile_ptr, #name                                                                                       \
+        meshtastic_Config_LoRaConfig_RegionCode_##name, freq_start, freq_end, duty_cycle, spacing, power_limit, audio_permitted, \
+            frequency_switching, wide_lora, #name                                                                                \
     }
 
 const RegionInfo regions[] = {
@@ -66,7 +43,7 @@ const RegionInfo regions[] = {
         https://link.springer.com/content/pdf/bbm%3A978-1-4842-4357-2%2F1.pdf
         https://www.thethingsnetwork.org/docs/lorawan/regional-parameters/
     */
-    RDEF(US, 902.0f, 928.0f, 100, 30, false, false, PROFILE_STD),
+    RDEF(US, 902.0f, 928.0f, 100, 0, 30, true, false, false),
 
     /*
         EN300220 ETSI V3.2.1 [Table B.1, Item H, p. 21]
@@ -74,7 +51,8 @@ const RegionInfo regions[] = {
         https://www.etsi.org/deliver/etsi_en/300200_300299/30022002/03.02.01_60/en_30022002v030201p.pdf
         FIXME: https://github.com/meshtastic/firmware/issues/3371
      */
-    RDEF(EU_433, 433.0f, 434.0f, 10, 10, false, false, PROFILE_STD),
+    RDEF(EU_433, 433.0f, 434.0f, 10, 0, 10, true, false, false),
+
     /*
        https://www.thethingsnetwork.org/docs/lorawan/duty-cycle/
        https://www.thethingsnetwork.org/docs/lorawan/regional-parameters/
@@ -89,33 +67,33 @@ const RegionInfo regions[] = {
        AFA) to avoid a duty cycle. (Please refer to line P page 22 of this document.)
        https://www.etsi.org/deliver/etsi_en/300200_300299/30022002/03.01.01_60/en_30022002v030101p.pdf
      */
-    RDEF(EU_868, 869.4f, 869.65f, 10, 27, false, false, PROFILE_EU868),
+    RDEF(EU_868, 869.4f, 869.65f, 10, 0, 27, false, false, false),
 
     /*
         https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
      */
-    RDEF(CN, 470.0f, 510.0f, 100, 19, false, false, PROFILE_STD),
+    RDEF(CN, 470.0f, 510.0f, 100, 0, 19, true, false, false),
 
     /*
         https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
         https://www.arib.or.jp/english/html/overview/doc/5-STD-T108v1_5-E1.pdf
         https://qiita.com/ammo0613/items/d952154f1195b64dc29f
      */
-    RDEF(JP, 920.5f, 923.5f, 100, 13, false, false, PROFILE_STD),
+    RDEF(JP, 920.5f, 923.5f, 100, 0, 13, true, false, false),
 
     /*
         https://www.iot.org.au/wp/wp-content/uploads/2016/12/IoTSpectrumFactSheet.pdf
         https://iotalliance.org.nz/wp-content/uploads/sites/4/2019/05/IoT-Spectrum-in-NZ-Briefing-Paper.pdf
         Also used in Brazil.
      */
-    RDEF(ANZ, 915.0f, 928.0f, 100, 30, false, false, PROFILE_STD),
+    RDEF(ANZ, 915.0f, 928.0f, 100, 0, 30, true, false, false),
 
     /*
         433.05 - 434.79 MHz, 25mW EIRP max, No duty cycle restrictions
         AU Low Interference Potential https://www.acma.gov.au/licences/low-interference-potential-devices-lipd-class-licence
         NZ General User Radio Licence for Short Range Devices https://gazette.govt.nz/notice/id/2022-go3100
      */
-    RDEF(ANZ_433, 433.05f, 434.79f, 100, 14, false, false, PROFILE_STD),
+    RDEF(ANZ_433, 433.05f, 434.79f, 100, 0, 14, true, false, false),
 
     /*
         https://digital.gov.ru/uploaded/files/prilozhenie-12-k-reshenyu-gkrch-18-46-03-1.pdf
@@ -123,13 +101,13 @@ const RegionInfo regions[] = {
         Note:
             - We do LBT, so 100% is allowed.
      */
-    RDEF(RU, 868.7f, 869.2f, 100, 20, false, false, PROFILE_STD),
+    RDEF(RU, 868.7f, 869.2f, 100, 0, 20, true, false, false),
 
     /*
         https://www.law.go.kr/LSW/admRulLsInfoP.do?admRulId=53943&efYd=0
         https://resources.lora-alliance.org/technical-specifications/rp002-1-0-4-regional-parameters
      */
-    RDEF(KR, 920.0f, 923.0f, 100, 23, false, false, PROFILE_STD),
+    RDEF(KR, 920.0f, 923.0f, 100, 0, 23, true, false, false),
 
     /*
         Taiwan, 920-925Mhz, limited to 0.5W indoor or coastal, 1.0W outdoor.
@@ -137,40 +115,44 @@ const RegionInfo regions[] = {
         https://www.ncc.gov.tw/english/files/23070/102_5190_230703_1_doc_C.PDF
         https://gazette.nat.gov.tw/egFront/e_detail.do?metaid=147283
      */
-    RDEF(TW, 920.0f, 925.0f, 100, 27, false, false, PROFILE_STD),
+    RDEF(TW, 920.0f, 925.0f, 100, 0, 27, true, false, false),
 
     /*
         https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
      */
-    RDEF(IN, 865.0f, 867.0f, 100, 30, false, false, PROFILE_STD),
+    RDEF(IN, 865.0f, 867.0f, 100, 0, 30, true, false, false),
 
     /*
          https://rrf.rsm.govt.nz/smart-web/smart/page/-smart/domain/licence/LicenceSummary.wdk?id=219752
          https://iotalliance.org.nz/wp-content/uploads/sites/4/2019/05/IoT-Spectrum-in-NZ-Briefing-Paper.pdf
       */
-    RDEF(NZ_865, 864.0f, 868.0f, 100, 36, false, false, PROFILE_STD),
+    RDEF(NZ_865, 864.0f, 868.0f, 100, 0, 36, true, false, false),
 
     /*
        https://lora-alliance.org/wp-content/uploads/2020/11/lorawan_regional_parameters_v1.0.3reva_0.pdf
        https://standard.nbtc.go.th/getattachment/Standards/%E0%B8%A1%E0%B8%B2%E0%B8%95%E0%B8%A3%E0%B8%90%E0%B8%B2%E0%B8%99%E0%B8%97%E0%B8%B2%E0%B8%87%E0%B9%80%E0%B8%97%E0%B8%84%E0%B8%99%E0%B8%B4%E0%B8%84%E0%B8%82%E0%B8%AD%E0%B8%87%E0%B9%80%E0%B8%84%E0%B8%A3%E0%B8%B7%E0%B9%88%E0%B8%AD%E0%B8%87%E0%B9%82%E0%B8%97%E0%B8%A3%E0%B8%84%E0%B8%A1%E0%B8%99%E0%B8%B2%E0%B8%84%E0%B8%A1/1033-2565.pdf.aspx?lang=th-TH
        Thailand 920–925 MHz set max TX power to 27 dBm and enforce 10% duty cycle, aligned with NBTC regulations.
     */
-    RDEF(TH, 920.0f, 925.0f, 10, 27, false, false, PROFILE_STD),
+    RDEF(TH, 920.0f, 925.0f, 10, 0, 27, true, false, false),
 
     /*
         433,05-434,7 Mhz 10 mW
+        https://nkrzi.gov.ua/images/upload/256/5810/PDF_UUZ_19_01_2016.pdf
+    */
+    RDEF(UA_433, 433.0f, 434.7f, 10, 0, 10, true, false, false),
+
+    /*
         868,0-868,6 Mhz 25 mW
         https://nkrzi.gov.ua/images/upload/256/5810/PDF_UUZ_19_01_2016.pdf
     */
-    RDEF(UA_433, 433.0f, 434.7f, 10, 10, false, false, PROFILE_STD),
-    RDEF(UA_868, 868.0f, 868.6f, 1, 14, false, false, PROFILE_STD),
+    RDEF(UA_868, 868.0f, 868.6f, 1, 0, 14, true, false, false),
 
     /*
         Malaysia
         433 - 435 MHz at 100mW, no restrictions.
         https://www.mcmc.gov.my/skmmgovmy/media/General/pdf/Short-Range-Devices-Specification.pdf
     */
-    RDEF(MY_433, 433.0f, 435.0f, 100, 20, false, false, PROFILE_STD),
+    RDEF(MY_433, 433.0f, 435.0f, 100, 0, 20, true, false, false),
 
     /*
         Malaysia
@@ -179,14 +161,14 @@ const RegionInfo regions[] = {
         Frequency hopping is used for 919 - 923 MHz.
         https://www.mcmc.gov.my/skmmgovmy/media/General/pdf/Short-Range-Devices-Specification.pdf
     */
-    RDEF(MY_919, 919.0f, 924.0f, 100, 27, true, false, PROFILE_STD),
+    RDEF(MY_919, 919.0f, 924.0f, 100, 0, 27, true, true, false),
 
     /*
         Singapore
         SG_923 Band 30d: 917 - 925 MHz at 100mW, no restrictions.
         https://www.imda.gov.sg/-/media/imda/files/regulation-licensing-and-consultations/ict-standards/telecommunication-standards/radio-comms/imdatssrd.pdf
     */
-    RDEF(SG_923, 917.0f, 925.0f, 100, 20, false, false, PROFILE_STD),
+    RDEF(SG_923, 917.0f, 925.0f, 100, 0, 20, true, false, false),
 
     /*
         Philippines
@@ -196,9 +178,8 @@ const RegionInfo regions[] = {
                 https://github.com/meshtastic/firmware/issues/4948#issuecomment-2394926135
     */
 
-    RDEF(PH_433, 433.0f, 434.7f, 100, 10, false, false, PROFILE_STD),
-    RDEF(PH_868, 868.0f, 869.4f, 100, 14, false, false, PROFILE_STD),
-    RDEF(PH_915, 915.0f, 918.0f, 100, 24, false, false, PROFILE_STD),
+    RDEF(PH_433, 433.0f, 434.7f, 100, 0, 10, true, false, false), RDEF(PH_868, 868.0f, 869.4f, 100, 0, 14, true, false, false),
+    RDEF(PH_915, 915.0f, 918.0f, 100, 0, 24, true, false, false),
 
     /*
         Kazakhstan
@@ -206,38 +187,37 @@ const RegionInfo regions[] = {
                 863 - 868 MHz <25 mW EIRP, 500kHz channels allowed, must not be used at airfields
                                 https://github.com/meshtastic/firmware/issues/7204
     */
-    RDEF(KZ_433, 433.075f, 434.775f, 100, 10, false, false, PROFILE_STD),
-    RDEF(KZ_863, 863.0f, 868.0f, 100, 30, false, false, PROFILE_STD),
+    RDEF(KZ_433, 433.075f, 434.775f, 100, 0, 10, true, false, false),
+    RDEF(KZ_863, 863.0f, 868.0f, 100, 0, 30, true, false, false),
 
     /*
         Nepal
         865 MHz to 868 MHz frequency band for IoT (Internet of Things), M2M (Machine-to-Machine), and smart metering use,
        specifically in non-cellular mode. https://www.nta.gov.np/uploads/contents/Radio-Frequency-Policy-2080-English.pdf
     */
-    RDEF(NP_865, 865.0f, 868.0f, 100, 30, false, false, PROFILE_STD),
+    RDEF(NP_865, 865.0f, 868.0f, 100, 0, 30, true, false, false),
 
     /*
         Brazil
         902 - 907.5 MHz , 1W power limit, no duty cycle restrictions
         https://github.com/meshtastic/firmware/issues/3741
     */
-    RDEF(BR_902, 902.0f, 907.5f, 100, 30, false, false, PROFILE_STD),
+    RDEF(BR_902, 902.0f, 907.5f, 100, 0, 30, true, false, false),
 
     /*
        2.4 GHZ WLAN Band equivalent. Only for SX128x chips.
     */
-    RDEF(LORA_24, 2400.0f, 2483.5f, 100, 10, false, true, PROFILE_STD),
+    RDEF(LORA_24, 2400.0f, 2483.5f, 100, 0, 10, true, false, true),
 
     /*
         This needs to be last. Same as US.
     */
-    RDEF(UNSET, 902.0f, 928.0f, 100, 30, false, false, PROFILE_UNDEF)
+    RDEF(UNSET, 902.0f, 928.0f, 100, 0, 30, true, false, false)
 
 };
 
 const RegionInfo *myRegion;
 bool RadioInterface::uses_default_frequency_slot = true;
-bool RadioInterface::uses_custom_channel_name = false;
 
 static uint8_t bytes[MAX_LORA_PAYLOAD_LEN + 1];
 
@@ -523,14 +503,45 @@ void initRegion()
     myRegion = r;
 }
 
-const RegionInfo *getRegion(meshtastic_Config_LoRaConfig_RegionCode code)
+void RadioInterface::bootstrapLoRaConfigFromPreset(meshtastic_Config_LoRaConfig &loraConfig)
 {
+    if (!loraConfig.use_preset) {
+        return;
+    }
+
+    // Find region info to determine whether "wide" LoRa is permitted (2.4 GHz uses wider bandwidth codes).
     const RegionInfo *r = regions;
-    for (; r->code != meshtastic_Config_LoRaConfig_RegionCode_UNSET && r->code != code; r++)
+    for (; r->code != meshtastic_Config_LoRaConfig_RegionCode_UNSET && r->code != loraConfig.region; r++)
         ;
-    return r;
+
+    const bool regionWideLora = r->wideLora;
+
+    float bwKHz = 0;
+    uint8_t sf = 0;
+    uint8_t cr = 0;
+    modemPresetToParams(loraConfig.modem_preset, regionWideLora, bwKHz, sf, cr);
+
+    // If selected preset requests a bandwidth larger than the region span, fall back to LONG_FAST.
+    if (r->code != meshtastic_Config_LoRaConfig_RegionCode_UNSET && (r->freqEnd - r->freqStart) < (bwKHz / 1000.0f)) {
+        loraConfig.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
+        modemPresetToParams(loraConfig.modem_preset, regionWideLora, bwKHz, sf, cr);
+    }
+
+    loraConfig.bandwidth = bwKHzToCode(bwKHz);
+    loraConfig.spread_factor = sf;
 }
 
+/**
+ * ## LoRaWAN for North America
+
+LoRaWAN defines 64, 125 kHz channels from 902.3 to 914.9 MHz increments.
+
+The maximum output power for North America is +30 dBM.
+
+The band is from 902 to 928 MHz. It mentions channel number and its respective channel frequency. All the 13 channels are
+separated by 2.16 MHz with respect to the adjacent channels. Channel zero starts at 903.08 MHz center frequency.
+*/
+
 uint32_t RadioInterface::getPacketTime(const meshtastic_MeshPacket *p, bool received)
 {
     uint32_t pl = 0;
@@ -740,7 +751,7 @@ void RadioInterface::saveFreq(float freq)
 }
 
 /**
- * Save our frequency slot (aka channel) for later reuse.
+ * Save our channel for later reuse.
  */
 void RadioInterface::saveChannelNum(uint32_t channel_num)
 {
@@ -763,304 +774,113 @@ uint32_t RadioInterface::getChannelNum()
     return savedChannelNum;
 }
 
-/**
- * Send an error-level client notification. Safe to call when service is null (e.g. in tests).
- */
-static void sendErrorNotification(const char *msg)
-{
-    if (!service)
-        return;
-    meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
-    if (!cn)
-        return;
-    cn->level = meshtastic_LogRecord_Level_ERROR;
-    snprintf(cn->message, sizeof(cn->message), "%s", msg);
-    service->sendClientNotification(cn);
-}
-
-/**
- * Checks if a region is valid for the current settings.
- * Returns false if not compatible.
- */
-bool RadioInterface::validateConfigRegion(const meshtastic_Config_LoRaConfig &loraConfig)
-{
-    const RegionInfo *newRegion = getRegion(loraConfig.region);
-
-    // If you are not licensed, you can't use ham regions.
-    if (newRegion->profile->licensedOnly && !devicestate.owner.is_licensed) {
-        char err_string[160];
-        snprintf(err_string, sizeof(err_string), "Region %s requires licensed mode", newRegion->name);
-        LOG_ERROR("%s", err_string);
-        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
-        sendErrorNotification(err_string);
-        return false;
-    }
-
-    return true;
-}
-
-/**
- * Internal helper: validate or clamp a LoRa config against its region.
- * When clamp==false, returns false on first error (pure validation).
- * When clamp==true, fixes invalid settings in-place and returns true.
- */
-bool RadioInterface::checkOrClampConfigLora(meshtastic_Config_LoRaConfig &loraConfig, bool clamp)
-{
-    char err_string[160];
-    float check_bw;
-
-    const RegionInfo *newRegion = getRegion(loraConfig.region);
-
-    const char *presetName = DisplayFormatters::getModemPresetDisplayName(loraConfig.modem_preset, false, loraConfig.use_preset);
-
-    // Check preset validity (only when use_preset is true)
-    if (loraConfig.use_preset) {
-        check_bw = modemPresetToBwKHz(loraConfig.modem_preset, newRegion->wideLora);
-
-        bool preset_valid = false;
-        for (size_t i = 0; i < newRegion->getNumPresets(); i++) {
-            if (loraConfig.modem_preset == newRegion->getAvailablePresets()[i]) {
-                preset_valid = true;
-                break;
-            }
-        }
-        if (!preset_valid) {
-            const char *defaultName = DisplayFormatters::getModemPresetDisplayName(newRegion->getDefaultPreset(), false, true);
-            if (clamp) {
-                snprintf(err_string, sizeof(err_string), "Preset %s invalid for %s, using %s", presetName, newRegion->name,
-                         defaultName);
-            } else {
-                snprintf(err_string, sizeof(err_string), "Preset %s invalid for %s", presetName, newRegion->name);
-            }
-            LOG_ERROR("%s", err_string);
-            RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
-            sendErrorNotification(err_string);
-
-            if (clamp) {
-                loraConfig.modem_preset = newRegion->getDefaultPreset();
-                check_bw = modemPresetToBwKHz(loraConfig.modem_preset, newRegion->wideLora);
-            } else {
-                return false;
-            }
-        }
-    } else {
-        check_bw = bwCodeToKHz(loraConfig.bandwidth);
-    }
-
-    // Calculate width of slots (aka channels) based on bandwidth and any spacing or padding required by the region:
-    // spacing = gap between slots (0 for continuous spectrum) and at the beginning of the band
-    // padding = gap at the beginning and end of the slots (0 for no padding)
-    float freqSlotWidth = newRegion->profile->spacing + (newRegion->profile->padding * 2) + (check_bw / 1000); // in MHz
-    uint32_t numFreqSlots = round((newRegion->freqEnd - newRegion->freqStart + newRegion->profile->spacing) / freqSlotWidth);
-
-    // Check if the region supports the requested bandwidth
-    if ((newRegion->freqEnd - newRegion->freqStart) < freqSlotWidth) {
-        const float regionSpanKHz = (newRegion->freqEnd - newRegion->freqStart) * 1000.0f;
-        snprintf(err_string, sizeof(err_string), "%s span %.0fkHz < requested %.0fkHz", newRegion->name, regionSpanKHz, check_bw);
-        LOG_ERROR("%s", err_string);
-        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
-        sendErrorNotification(err_string);
-
-        if (clamp) {
-            loraConfig.bandwidth = bwKHzToCode(modemPresetToBwKHz(newRegion->getDefaultPreset(), newRegion->wideLora));
-            check_bw = bwCodeToKHz(loraConfig.bandwidth);
-
-            // Recompute slot width and number of slots based on the new bandwidth
-            freqSlotWidth = newRegion->profile->spacing + (newRegion->profile->padding * 2) + (check_bw / 1000); // in MHz
-            numFreqSlots = round((newRegion->freqEnd - newRegion->freqStart + newRegion->profile->spacing) / freqSlotWidth);
-        } else {
-            return false;
-        }
-    }
-
-    const char *channelName = channels.getName(channels.getPrimaryIndex());
-    const char *presetNameDisplay =
-        DisplayFormatters::getModemPresetDisplayName(loraConfig.modem_preset, false, loraConfig.use_preset);
-    uint32_t channelNameHashSlot = hash(channelName) % numFreqSlots;
-    uint32_t presetNameHashSlot = hash(presetNameDisplay) % numFreqSlots;
-
-    if (loraConfig.override_frequency == 0) {
-
-        // Check if we use the default frequency slot
-        uses_default_frequency_slot =
-            (loraConfig.channel_num == 0) || // user choice unset, no frequency override, so use default
-            (newRegion->profile->overrideSlot != 0 &&
-             loraConfig.channel_num == newRegion->profile->overrideSlot) || // user setting matches override
-            ((newRegion->profile->overrideSlot == 0) &&
-             ((uint32_t)(loraConfig.channel_num - 1) == presetNameHashSlot)); // user setting matches preset hash, no override
-
-        // check if user setting different to preset name
-        uses_custom_channel_name = (strcmp(channelName, presetNameDisplay) != 0);
-
-        if (loraConfig.channel_num > numFreqSlots) {
-            snprintf(err_string, sizeof(err_string), "Channel number %u invalid for %s, max is %u", loraConfig.channel_num,
-                     newRegion->name, numFreqSlots);
-            LOG_ERROR("%s", err_string);
-            RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
-            sendErrorNotification(err_string);
-
-            if (clamp) {
-                if (uses_custom_channel_name) { // clamp to channel name hash
-                    loraConfig.channel_num =
-                        channelNameHashSlot + 1; // channel_num is 1-based, but hash slot is 0-based, so add 1
-                } else if ((loraConfig.use_preset) && (newRegion->profile->overrideSlot != 0)) { // clamp to preset override slot
-                    loraConfig.channel_num =
-                        newRegion->profile->overrideSlot; // use the override slot specified by the region profile
-                    uses_default_frequency_slot = true;
-                } else if (loraConfig.use_preset) {                  // clamp to preset slot
-                    loraConfig.channel_num = presetNameHashSlot + 1; // channel_num is 1-based, but hash slot is 0-based, so add 1
-                    uses_default_frequency_slot = true;
-                } else { // if not using preset, and no custom channel name, just clamp to default anyway
-                    uses_default_frequency_slot = true;
-                };
-            } else {
-                return false;
-            }
-        } // end of channel number check
-    } else {
-        // if we have a frequency override, we ignore the channel number and just use the override frequency
-        snprintf(err_string, sizeof(err_string), "Frequency override in place, using %.3f", loraConfig.override_frequency);
-    }
-    return true;
-}
-
-bool RadioInterface::validateConfigLora(const meshtastic_Config_LoRaConfig &loraConfig)
-{
-    auto copy = loraConfig;
-    return checkOrClampConfigLora(copy, false);
-}
-
-void RadioInterface::clampConfigLora(meshtastic_Config_LoRaConfig &loraConfig)
-{
-    checkOrClampConfigLora(loraConfig, true);
-}
-
 /**
  * Pull our channel settings etc... from protobufs to the dumb interface settings
- * Note: this must be given only settings which have been validated or clamped!
  */
 void RadioInterface::applyModemConfig()
 {
     // Set up default configuration
     // No Sync Words in LORA mode
     meshtastic_Config_LoRaConfig &loraConfig = config.lora;
-    const RegionInfo *newRegion = getRegion(loraConfig.region);
-    myRegion = newRegion;
-
-    if (loraConfig.use_preset) {
-        if (!validateConfigLora(loraConfig)) {
-            loraConfig.modem_preset = newRegion->getDefaultPreset();
-        }
-        uint8_t newcr;
-        modemPresetToParams(loraConfig.modem_preset, newRegion->wideLora, bw, sf, newcr);
-        // If custom CR is being used already, check if the new preset is higher
-        if (loraConfig.coding_rate >= 5 && loraConfig.coding_rate <= 8 && loraConfig.coding_rate < newcr) {
-            cr = newcr;
-            LOG_INFO("Default Coding Rate is higher than custom setting, using %u", cr);
-        }
-        // If the custom CR is higher than the preset, use it
-        else if (loraConfig.coding_rate >= 5 && loraConfig.coding_rate <= 8 && loraConfig.coding_rate > newcr) {
+    bool validConfig = false; // We need to check for a valid configuration
+    while (!validConfig) {
+        if (loraConfig.use_preset) {
+            modemPresetToParams(loraConfig.modem_preset, myRegion->wideLora, bw, sf, cr);
+            if (loraConfig.coding_rate >= 5 && loraConfig.coding_rate <= 8 && loraConfig.coding_rate != cr) {
+                cr = loraConfig.coding_rate;
+                LOG_INFO("Using custom Coding Rate %u", cr);
+            }
+        } else {
+            sf = loraConfig.spread_factor;
             cr = loraConfig.coding_rate;
-            LOG_INFO("Using custom Coding Rate %u", cr);
-        } else {
-            cr = newcr;
+            bw = bwCodeToKHz(loraConfig.bandwidth);
         }
 
-    } else { // if not using preset, then just use the custom settings
-        if (validateConfigLora(loraConfig)) {
+        if ((myRegion->freqEnd - myRegion->freqStart) < bw / 1000) {
+            const float regionSpanKHz = (myRegion->freqEnd - myRegion->freqStart) * 1000.0f;
+            const float requestedBwKHz = bw;
+            const bool isWideRequest = requestedBwKHz >= 499.5f; // treat as 500 kHz preset
+            const char *presetName =
+                DisplayFormatters::getModemPresetDisplayName(loraConfig.modem_preset, false, loraConfig.use_preset);
+
+            char err_string[160];
+            if (isWideRequest) {
+                snprintf(err_string, sizeof(err_string), "%s region too narrow for 500kHz preset (%s). Falling back to LongFast.",
+                         myRegion->name, presetName);
+            } else {
+                snprintf(err_string, sizeof(err_string), "%s region span %.0fkHz < requested %.0fkHz. Falling back to LongFast.",
+                         myRegion->name, regionSpanKHz, requestedBwKHz);
+            }
+            LOG_ERROR("%s", err_string);
+            RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
+
+            meshtastic_ClientNotification *cn = clientNotificationPool.allocZeroed();
+            cn->level = meshtastic_LogRecord_Level_ERROR;
+            snprintf(cn->message, sizeof(cn->message), "%s", err_string);
+            service->sendClientNotification(cn);
+
+            // Set to default modem preset
+            loraConfig.use_preset = true;
+            loraConfig.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
         } else {
-            LOG_WARN("Invalid LoRa config settings, cannot apply requested modem config - falling back to %s defaults",
-                     newRegion->name);
-            clampConfigLora(loraConfig);
+            validConfig = true;
         }
-        bw = bwCodeToKHz(loraConfig.bandwidth);
-        sf = loraConfig.spread_factor;
-        cr = loraConfig.coding_rate;
     }
 
     power = loraConfig.tx_power;
 
-    if ((power == 0) || ((power > newRegion->powerLimit) && !devicestate.owner.is_licensed))
-        power = newRegion->powerLimit;
+    if ((power == 0) || ((power > myRegion->powerLimit) && !devicestate.owner.is_licensed))
+        power = myRegion->powerLimit;
 
     if (power == 0)
-        power = 17; // Default to this power level if we don't have a valid regional power limit (powerLimit of newRegion defaults
+        power = 17; // Default to this power level if we don't have a valid regional power limit (powerLimit of myRegion defaults
                     // to 0, currently no region has an actual power limit of 0 [dBm] so we can assume regions which have this
                     // variable set to 0 don't have a valid power limit)
 
     // Set final tx_power back onto config
     loraConfig.tx_power = (int8_t)power; // cppcheck-suppress assignmentAddressToInteger
 
-    uint32_t channel_num;
-    float freq;
+    // Calculate the number of channels
+    uint32_t numChannels = floor((myRegion->freqEnd - myRegion->freqStart) / (myRegion->spacing + (bw / 1000)));
 
-    // Calculate number of frequency slots (aka Channels):
-    // spacing = gap between channels (0 for continuous spectrum) and at the beginning of the band
-    // padding = gap at the beginning and end of the channel (0 for no padding)
-    float freqSlotWidth = newRegion->profile->spacing + (newRegion->profile->padding * 2) + (bw / 1000); // in MHz
-    uint32_t numFreqSlots = round((newRegion->freqEnd - newRegion->freqStart + newRegion->profile->spacing) / freqSlotWidth);
+    // If user has manually specified a channel num, then use that, otherwise generate one by hashing the name
+    const char *channelName = channels.getName(channels.getPrimaryIndex());
+    // channel_num is actually (channel_num - 1), since modulus (%) returns values from 0 to (numChannels - 1)
+    uint32_t channel_num = (loraConfig.channel_num ? loraConfig.channel_num - 1 : hash(channelName)) % numChannels;
 
-    // Calculate hash of channel name and preset name to pick a default frequency slot if user has not specified one.
-    // Note that channel_num is actually (channel_num - 1), i.e. zero-based, since modulus (%) returns values from 0 to
-    // (numFreqSlots - 1).
-    uint32_t presetNameHashSlot =
-        hash(DisplayFormatters::getModemPresetDisplayName(loraConfig.modem_preset, false, loraConfig.use_preset)) % numFreqSlots;
+    // Check if we use the default frequency slot
+    RadioInterface::uses_default_frequency_slot =
+        channel_num ==
+        hash(DisplayFormatters::getModemPresetDisplayName(config.lora.modem_preset, false, config.lora.use_preset)) % numChannels;
+
+    // Old frequency selection formula
+    // float freq = myRegion->freqStart + ((((myRegion->freqEnd - myRegion->freqStart) / numChannels) / 2) * channel_num);
+
+    // New frequency selection formula
+    float freq = myRegion->freqStart + (bw / 2000) + (channel_num * (bw / 1000));
 
     // override if we have a verbatim frequency
     if (loraConfig.override_frequency) {
         freq = loraConfig.override_frequency;
         channel_num = -1;
-        uses_default_frequency_slot = false;
-    } else {
-
-        // If user has not manually specified a frequency slot, or has not specified one that is different than the default or the
-        // override for the new region, then use the default or override. If the user has not specified one, but has specified a
-        // custom channel name, then use the hash of that channel name to pick a frequency slot. Note that channel_num is actually
-        // (channel_num - 1), i.e. zero-based, since modulus (%) returns values from 0 to (numFreqSlots - 1).
-        // NB: channel_num is also know as frequency slot but it's too late to fix now.
-        if (uses_default_frequency_slot) {
-            // if there's an override slot, use that
-            if (newRegion->profile->overrideSlot != 0) {
-                channel_num = newRegion->profile->overrideSlot - 1;
-            } else {
-                channel_num = presetNameHashSlot;
-            }
-        } else { // use the manually defined one
-            channel_num = loraConfig.channel_num - 1;
-        }
-
-        // Calculate frequency: freqStart is band edge, add half bandwidth (plus optional padding) to get middle of first channel
-        // subsequent channels are spaced by freqSlotWidth
-        freq = newRegion->freqStart + (bw / 2000) + newRegion->profile->padding + (channel_num * freqSlotWidth); // in MHz
     }
 
     saveChannelNum(channel_num);
     saveFreq(freq + loraConfig.frequency_offset);
-    const char *channelName = channels.getName(channels.getPrimaryIndex());
-
-    if (newRegion->wideLora) {                          // clamp if wide freq range
-        preambleLength = wideLoraPreambleLengthDefault; // 12 is the default for operation above 2GHz
-    } else {
-        preambleLength =
-            preambleLengthDefault; // 8 is default, but we use longer to increase the amount of sleep time when receiving
-    }
 
     slotTimeMsec = computeSlotTimeMsec();
     preambleTimeMsec = preambleLength * (pow_of_2(sf) / bw);
 
     LOG_INFO("Radio freq=%.3f, config.lora.frequency_offset=%.3f", freq, loraConfig.frequency_offset);
-    LOG_INFO("Set radio: region=%s, name=%s, config=%u, ch=%d, power=%d", newRegion->name, channelName, loraConfig.modem_preset,
+    LOG_INFO("Set radio: region=%s, name=%s, config=%u, ch=%d, power=%d", myRegion->name, channelName, loraConfig.modem_preset,
              channel_num, power);
-    LOG_INFO("newRegion->freqStart -> newRegion->freqEnd: %f -> %f (%f MHz)", newRegion->freqStart, newRegion->freqEnd,
-             newRegion->freqEnd - newRegion->freqStart);
-    LOG_INFO("numFreqSlots: %d x %.3fkHz", numFreqSlots, bw);
-    if (newRegion->profile->overrideSlot != 0) {
-        LOG_INFO("Using region override slot: %d", newRegion->profile->overrideSlot);
-    }
+    LOG_INFO("myRegion->freqStart -> myRegion->freqEnd: %f -> %f (%f MHz)", myRegion->freqStart, myRegion->freqEnd,
+             myRegion->freqEnd - myRegion->freqStart);
+    LOG_INFO("numChannels: %d x %.3fkHz", numChannels, bw);
     LOG_INFO("channel_num: %d", channel_num + 1);
     LOG_INFO("frequency: %f", getFreq());
     LOG_INFO("Slot time: %u msec, preamble time: %u msec", slotTimeMsec, preambleTimeMsec);
-} // end of applyModemConfig
+}
 
 /** Slottime is the time to detect a transmission has started, consisting of:
   - CAD duration;
@@ -1174,4 +994,4 @@ size_t RadioInterface::beginSending(meshtastic_MeshPacket *p)
 
     sendingPacket = p;
     return p->encrypted.size + sizeof(PacketHeader);
-}
+}

src/mesh/RadioInterface.h

@@ -92,20 +92,15 @@ class RadioInterface
     uint8_t sf = 9;
     uint8_t cr = 5;
 
-    static constexpr uint8_t NUM_SYM_CAD =
-        2; // Number of symbols used for CAD, 2 is the default since RadioLib 6.3.0 as per AN1200.48
-    static constexpr uint8_t NUM_SYM_CAD_24GHZ =
-        4; // Number of symbols used for CAD in 2.4 GHz, 4 is recommended in AN1200.22 of SX1280
+    const uint8_t NUM_SYM_CAD = 2;       // Number of symbols used for CAD, 2 is the default since RadioLib 6.3.0 as per AN1200.48
+    const uint8_t NUM_SYM_CAD_24GHZ = 4; // Number of symbols used for CAD in 2.4 GHz, 4 is recommended in AN1200.22 of SX1280
     uint32_t slotTimeMsec = computeSlotTimeMsec();
-    uint16_t preambleLength = 16; // 8 is default, but we use longer to increase the amount of sleep time when receiving
-    static constexpr uint16_t preambleLengthDefault =
-        16; // 8 is default, but we use longer to increase the amount of sleep time when receiving
-    static constexpr uint16_t wideLoraPreambleLengthDefault = 12; // 12 is default for wide Lora
-    uint32_t preambleTimeMsec = 165;                              // calculated on startup, this is the default for LongFast
-    static constexpr uint32_t PROCESSING_TIME_MSEC =
-        4500;                           // time to construct, process and construct a packet again (empirically determined)
-    static constexpr uint8_t CWmin = 3; // minimum CWsize
-    static constexpr uint8_t CWmax = 8; // maximum CWsize
+    uint16_t preambleLength = 16;    // 8 is default, but we use longer to increase the amount of sleep time when receiving
+    uint32_t preambleTimeMsec = 165; // calculated on startup, this is the default for LongFast
+    const uint32_t PROCESSING_TIME_MSEC =
+        4500;                // time to construct, process and construct a packet again (empirically determined)
+    const uint8_t CWmin = 3; // minimum CWsize
+    const uint8_t CWmax = 8; // maximum CWsize
 
     meshtastic_MeshPacket *sendingPacket = NULL; // The packet we are currently sending
     uint32_t lastTxStart = 0L;
@@ -132,7 +127,7 @@ class RadioInterface
      * Coerce LoRa config fields (bandwidth/spread_factor) derived from presets.
      * This is used during early bootstrapping so UIs that display these fields directly remain consistent.
      */
-    // static void bootstrapLoRaConfigFromPreset(meshtastic_Config_LoRaConfig &loraConfig); // maybe superseded?
+    static void bootstrapLoRaConfigFromPreset(meshtastic_Config_LoRaConfig &loraConfig);
 
     /**
      * Return true if we think the board can go to sleep (i.e. our tx queue is empty, we are not sending or receiving)
@@ -239,20 +234,6 @@ class RadioInterface
     // Whether we use the default frequency slot given our LoRa config (region and modem preset)
     static bool uses_default_frequency_slot;
 
-    // Whether we have a custom channel name
-    static bool uses_custom_channel_name;
-
-    static bool checkOrClampConfigLora(meshtastic_Config_LoRaConfig &loraConfig, bool clamp);
-
-    // Check if a candidate region is compatible and valid.
-    static bool validateConfigRegion(const meshtastic_Config_LoRaConfig &loraConfig);
-
-    // Check if a candidate radio configuration is valid.
-    static bool validateConfigLora(const meshtastic_Config_LoRaConfig &loraConfig);
-
-    // Make a candidate radio configuration valid, even if it isn't.
-    static void clampConfigLora(meshtastic_Config_LoRaConfig &loraConfig);
-
   protected:
     int8_t power = 17; // Set by applyModemConfig()
 

src/mesh/RadioLibInterface.cpp

@@ -246,24 +246,6 @@ bool RadioLibInterface::findInTxQueue(NodeNum from, PacketId id)
     return txQueue.find(from, id);
 }
 
-bool RadioLibInterface::randomBytes(uint8_t *buffer, size_t length)
-{
-    if (!buffer || length == 0 || !iface) {
-        return false;
-    }
-
-    // Older RadioLib versions only expose random(min, max), so fill the buffer byte-by-byte.
-    for (size_t i = 0; i < length; ++i) {
-        int32_t value = iface->random(0, 255);
-        if (value < 0) {
-            return false;
-        }
-        buffer[i] = static_cast<uint8_t>(value & 0xFF);
-    }
-
-    return true;
-}
-
 /** radio helper thread callback.
 We never immediately transmit after any operation (either Rx or Tx). Instead we should wait a random multiple of
 'slotTimes' (see definition in RadioInterface.h) taken from a contention window (CW) to lower the chance of collision.
@@ -605,4 +587,4 @@ bool RadioLibInterface::startSend(meshtastic_MeshPacket *txp)
 
         return res == RADIOLIB_ERR_NONE;
     }
-}
+}

src/mesh/RadioLibInterface.h

@@ -172,12 +172,6 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
     /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
     virtual bool findInTxQueue(NodeNum from, PacketId id) override;
 
-    /**
-     * Request randomness sourced from the LoRa modem, if supported by the active RadioLib interface.
-     * @return true if len bytes were produced, false otherwise.
-     */
-    bool randomBytes(uint8_t *buffer, size_t length);
-
   private:
     /** if we have something waiting to send, start a short (random) timer so we can come check for collision before actually
      * doing the transmit */

src/mesh/Router.cpp

@@ -11,9 +11,6 @@
 #include "mesh-pb-constants.h"
 #include "meshUtils.h"
 #include "modules/RoutingModule.h"
-#if HAS_TRAFFIC_MANAGEMENT
-#include "modules/TrafficManagementModule.h"
-#endif
 #if !MESHTASTIC_EXCLUDE_MQTT
 #include "mqtt/MQTT.h"
 #endif
@@ -98,20 +95,6 @@ bool Router::shouldDecrementHopLimit(const meshtastic_MeshPacket *p)
         return true;
     }
 
-#if HAS_TRAFFIC_MANAGEMENT
-    // When router_preserve_hops is enabled, preserve hops for decoded packets that are not
-    // position or telemetry (those have their own exhaust_hop controls).
-    if (moduleConfig.has_traffic_management && moduleConfig.traffic_management.enabled &&
-        moduleConfig.traffic_management.router_preserve_hops && p->which_payload_variant == meshtastic_MeshPacket_decoded_tag &&
-        p->decoded.portnum != meshtastic_PortNum_POSITION_APP && p->decoded.portnum != meshtastic_PortNum_TELEMETRY_APP) {
-        LOG_DEBUG("Router hop preserved: port=%d from=0x%08x (traffic_management)", p->decoded.portnum, getFrom(p));
-        if (trafficManagementModule) {
-            trafficManagementModule->recordRouterHopPreserved();
-        }
-        return false;
-    }
-#endif
-
     // For subsequent hops, check if previous relay is a favorite router
     // Optimized search for favorite routers with matching last byte
     // Check ordering optimized for IoT devices (cheapest checks first)
@@ -875,12 +858,6 @@ void Router::perhapsHandleReceived(meshtastic_MeshPacket *p)
         return;
     }
 
-    if (shouldDropPacketForPreHop(*p)) {
-        logHopStartDrop(*p, "pre-hop drop");
-        packetPool.release(p);
-        return;
-    }
-
     if (shouldFilterReceived(p)) {
         LOG_DEBUG("Incoming msg was filtered from 0x%x", p->from);
         packetPool.release(p);

src/mesh/SX126xInterface.cpp

@@ -245,21 +245,14 @@ template <typename T> bool SX126xInterface<T>::reconfigure()
     if (err != RADIOLIB_ERR_NONE)
         RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
 
-    limitPower(SX126X_MAX_POWER);
-    // Make sure we reach the minimum power supported to turn the chip on (-9dBm)
-    if (power < -9)
-        power = -9;
+    if (power > SX126X_MAX_POWER) // This chip has lower power limits than some
+        power = SX126X_MAX_POWER;
 
     err = lora.setOutputPower(power);
     if (err != RADIOLIB_ERR_NONE)
         LOG_ERROR("SX126X setOutputPower %s%d", radioLibErr, err);
     assert(err == RADIOLIB_ERR_NONE);
 
-    // Apply RX gain mode — valid in STDBY (datasheet §9.6), matches resetAGC() pattern
-    err = lora.setRxBoostedGainMode(config.lora.sx126x_rx_boosted_gain);
-    if (err != RADIOLIB_ERR_NONE)
-        LOG_WARN("SX126X setRxBoostedGainMode %s%d", radioLibErr, err);
-
     startReceive(); // restart receiving
 
     return RADIOLIB_ERR_NONE;

src/mesh/SX128xInterface.cpp

@@ -144,7 +144,8 @@ template <typename T> bool SX128xInterface<T>::reconfigure()
     if (err != RADIOLIB_ERR_NONE)
         RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_INVALID_RADIO_SETTING);
 
-    limitPower(SX128X_MAX_POWER);
+    if (power > SX128X_MAX_POWER) // This chip has lower power limits than some
+        power = SX128X_MAX_POWER;
 
     err = lora.setOutputPower(power);
     if (err != RADIOLIB_ERR_NONE)

src/mesh/generated/meshtastic/atak.pb.cpp

@@ -27,33 +27,6 @@ PB_BIND(meshtastic_PLI, meshtastic_PLI, AUTO)
 PB_BIND(meshtastic_AircraftTrack, meshtastic_AircraftTrack, AUTO)
 
 
-PB_BIND(meshtastic_CotGeoPoint, meshtastic_CotGeoPoint, AUTO)
-
-
-PB_BIND(meshtastic_DrawnShape, meshtastic_DrawnShape, 2)
-
-
-PB_BIND(meshtastic_Marker, meshtastic_Marker, AUTO)
-
-
-PB_BIND(meshtastic_RangeAndBearing, meshtastic_RangeAndBearing, AUTO)
-
-
-PB_BIND(meshtastic_Route, meshtastic_Route, 2)
-
-
-PB_BIND(meshtastic_Route_Link, meshtastic_Route_Link, AUTO)
-
-
-PB_BIND(meshtastic_CasevacReport, meshtastic_CasevacReport, AUTO)
-
-
-PB_BIND(meshtastic_EmergencyAlert, meshtastic_EmergencyAlert, AUTO)
-
-
-PB_BIND(meshtastic_TaskRequest, meshtastic_TaskRequest, AUTO)
-
-
 PB_BIND(meshtastic_TAKPacketV2, meshtastic_TAKPacketV2, 2)
 
 
@@ -68,27 +41,3 @@ PB_BIND(meshtastic_TAKPacketV2, meshtastic_TAKPacketV2, 2)
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

src/mesh/generated/meshtastic/mesh.pb.cpp

@@ -27,9 +27,6 @@ PB_BIND(meshtastic_KeyVerification, meshtastic_KeyVerification, AUTO)
 PB_BIND(meshtastic_StoreForwardPlusPlus, meshtastic_StoreForwardPlusPlus, 2)
 
 
-PB_BIND(meshtastic_RemoteShell, meshtastic_RemoteShell, AUTO)
-
-
 PB_BIND(meshtastic_Waypoint, meshtastic_Waypoint, AUTO)
 
 
@@ -132,8 +129,6 @@ PB_BIND(meshtastic_ChunkedPayloadResponse, meshtastic_ChunkedPayloadResponse, AU
 
 
 
-
-
 
 
 

src/mesh/generated/meshtastic/mesh.pb.h

@@ -308,13 +308,8 @@ typedef enum _meshtastic_HardwareModel {
     meshtastic_HardwareModel_TDISPLAY_S3_PRO = 126,
     /* Heltec Mesh Node T096 board features an nRF52840 CPU and a TFT screen. */
     meshtastic_HardwareModel_HELTEC_MESH_NODE_T096 = 127,
-    /* Seeed studio T1000-E Pro tracker card. NRF52840 w/ LR2021 radio,
- GPS, button, buzzer, and sensors. */
+    /* Seeed studio T1000-E Pro tracker card. NRF52840 w/ LR2021 radio, GPS, button, buzzer, and sensors. */
     meshtastic_HardwareModel_TRACKER_T1000_E_PRO = 128,
-    /* Elecrow ThinkNode M7, M8 and M9 */
-    meshtastic_HardwareModel_THINKNODE_M7 = 129,
-    meshtastic_HardwareModel_THINKNODE_M8 = 130,
-    meshtastic_HardwareModel_THINKNODE_M9 = 131,
     /* ------------------------------------------------------------------------------------------------------------------------------------------
  Reserved ID For developing private Ports. These will show up in live traffic sparsely, so we can use a high number. Keep it within 8 bits.
  ------------------------------------------------------------------------------------------------------------------------------------------ */
@@ -518,27 +513,6 @@ typedef enum _meshtastic_StoreForwardPlusPlus_SFPP_message_type {
     meshtastic_StoreForwardPlusPlus_SFPP_message_type_LINK_PROVIDE_SECONDHALF = 6
 } meshtastic_StoreForwardPlusPlus_SFPP_message_type;
 
-/* Frame op code for PTY session control and stream transport.
-
- Values 1-63 are client->server requests.
- Values 64-127 are server->client responses/events. */
-typedef enum _meshtastic_RemoteShell_OpCode {
-    meshtastic_RemoteShell_OpCode_OP_UNSET = 0,
-    /* Client -> server */
-    meshtastic_RemoteShell_OpCode_OPEN = 1,
-    meshtastic_RemoteShell_OpCode_INPUT = 2,
-    meshtastic_RemoteShell_OpCode_RESIZE = 3,
-    meshtastic_RemoteShell_OpCode_CLOSE = 4,
-    meshtastic_RemoteShell_OpCode_PING = 5,
-    meshtastic_RemoteShell_OpCode_ACK = 6,
-    /* Server -> client */
-    meshtastic_RemoteShell_OpCode_OPEN_OK = 64,
-    meshtastic_RemoteShell_OpCode_OUTPUT = 65,
-    meshtastic_RemoteShell_OpCode_CLOSED = 66,
-    meshtastic_RemoteShell_OpCode_ERROR = 67,
-    meshtastic_RemoteShell_OpCode_PONG = 68
-} meshtastic_RemoteShell_OpCode;
-
 /* The priority of this message for sending.
  Higher priorities are sent first (when managing the transmit queue).
  This field is never sent over the air, it is only used internally inside of a local device node.
@@ -871,27 +845,6 @@ typedef struct _meshtastic_StoreForwardPlusPlus {
     uint32_t chain_count;
 } meshtastic_StoreForwardPlusPlus;
 
-typedef PB_BYTES_ARRAY_T(200) meshtastic_RemoteShell_payload_t;
-/* The actual over-the-mesh message doing RemoteShell */
-typedef struct _meshtastic_RemoteShell {
-    /* Structured frame operation. */
-    meshtastic_RemoteShell_OpCode op;
-    /* Logical PTY session identifier. */
-    uint32_t session_id;
-    /* Monotonic sequence number for this frame. */
-    uint32_t seq;
-    /* Cumulative ack sequence number. */
-    uint32_t ack_seq;
-    /* Opaque bytes payload for INPUT/OUTPUT/ERROR and other frame bodies. */
-    meshtastic_RemoteShell_payload_t payload;
-    /* Terminal size columns used for OPEN/RESIZE signaling. */
-    uint32_t cols;
-    /* Terminal size rows used for OPEN/RESIZE signaling. */
-    uint32_t rows;
-    /* Bit flags for protocol extensions. */
-    uint32_t flags;
-} meshtastic_RemoteShell;
-
 /* Waypoint message, used to share arbitrary locations across the mesh */
 typedef struct _meshtastic_Waypoint {
     /* Id of the waypoint */
@@ -1432,10 +1385,6 @@ extern "C" {
 #define _meshtastic_StoreForwardPlusPlus_SFPP_message_type_MAX meshtastic_StoreForwardPlusPlus_SFPP_message_type_LINK_PROVIDE_SECONDHALF
 #define _meshtastic_StoreForwardPlusPlus_SFPP_message_type_ARRAYSIZE ((meshtastic_StoreForwardPlusPlus_SFPP_message_type)(meshtastic_StoreForwardPlusPlus_SFPP_message_type_LINK_PROVIDE_SECONDHALF+1))
 
-#define _meshtastic_RemoteShell_OpCode_MIN meshtastic_RemoteShell_OpCode_OP_UNSET
-#define _meshtastic_RemoteShell_OpCode_MAX meshtastic_RemoteShell_OpCode_PONG
-#define _meshtastic_RemoteShell_OpCode_ARRAYSIZE ((meshtastic_RemoteShell_OpCode)(meshtastic_RemoteShell_OpCode_PONG+1))
-
 #define _meshtastic_MeshPacket_Priority_MIN meshtastic_MeshPacket_Priority_UNSET
 #define _meshtastic_MeshPacket_Priority_MAX meshtastic_MeshPacket_Priority_MAX
 #define _meshtastic_MeshPacket_Priority_ARRAYSIZE ((meshtastic_MeshPacket_Priority)(meshtastic_MeshPacket_Priority_MAX+1))
@@ -1466,8 +1415,6 @@ extern "C" {
 
 #define meshtastic_StoreForwardPlusPlus_sfpp_message_type_ENUMTYPE meshtastic_StoreForwardPlusPlus_SFPP_message_type
 
-#define meshtastic_RemoteShell_op_ENUMTYPE meshtastic_RemoteShell_OpCode
-
 
 
 
@@ -1512,7 +1459,6 @@ extern "C" {
 #define meshtastic_Data_init_default             {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0}
 #define meshtastic_KeyVerification_init_default  {0, {0, {0}}, {0, {0}}}
 #define meshtastic_StoreForwardPlusPlus_init_default {_meshtastic_StoreForwardPlusPlus_SFPP_message_type_MIN, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, 0, 0, 0, 0, 0}
-#define meshtastic_RemoteShell_init_default      {_meshtastic_RemoteShell_OpCode_MIN, 0, 0, 0, {0, {0}}, 0, 0, 0}
 #define meshtastic_Waypoint_init_default         {0, false, 0, false, 0, 0, 0, "", "", 0}
 #define meshtastic_StatusMessage_init_default    {""}
 #define meshtastic_MqttClientProxyMessage_init_default {"", 0, {{0, {0}}}, 0}
@@ -1546,7 +1492,6 @@ extern "C" {
 #define meshtastic_Data_init_zero                {_meshtastic_PortNum_MIN, {0, {0}}, 0, 0, 0, 0, 0, 0, false, 0}
 #define meshtastic_KeyVerification_init_zero     {0, {0, {0}}, {0, {0}}}
 #define meshtastic_StoreForwardPlusPlus_init_zero {_meshtastic_StoreForwardPlusPlus_SFPP_message_type_MIN, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, 0, 0, 0, 0, 0}
-#define meshtastic_RemoteShell_init_zero         {_meshtastic_RemoteShell_OpCode_MIN, 0, 0, 0, {0, {0}}, 0, 0, 0}
 #define meshtastic_Waypoint_init_zero            {0, false, 0, false, 0, 0, 0, "", "", 0}
 #define meshtastic_StatusMessage_init_zero       {""}
 #define meshtastic_MqttClientProxyMessage_init_zero {"", 0, {{0, {0}}}, 0}
@@ -1636,14 +1581,6 @@ extern "C" {
 #define meshtastic_StoreForwardPlusPlus_encapsulated_from_tag 8
 #define meshtastic_StoreForwardPlusPlus_encapsulated_rxtime_tag 9
 #define meshtastic_StoreForwardPlusPlus_chain_count_tag 10
-#define meshtastic_RemoteShell_op_tag            1
-#define meshtastic_RemoteShell_session_id_tag    2
-#define meshtastic_RemoteShell_seq_tag           3
-#define meshtastic_RemoteShell_ack_seq_tag       4
-#define meshtastic_RemoteShell_payload_tag       5
-#define meshtastic_RemoteShell_cols_tag          6
-#define meshtastic_RemoteShell_rows_tag          7
-#define meshtastic_RemoteShell_flags_tag         8
 #define meshtastic_Waypoint_id_tag               1
 #define meshtastic_Waypoint_latitude_i_tag       2
 #define meshtastic_Waypoint_longitude_i_tag      3
@@ -1876,18 +1813,6 @@ X(a, STATIC,   SINGULAR, UINT32,   chain_count,      10)
 #define meshtastic_StoreForwardPlusPlus_CALLBACK NULL
 #define meshtastic_StoreForwardPlusPlus_DEFAULT NULL
 
-#define meshtastic_RemoteShell_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UENUM,    op,                1) \
-X(a, STATIC,   SINGULAR, UINT32,   session_id,        2) \
-X(a, STATIC,   SINGULAR, UINT32,   seq,               3) \
-X(a, STATIC,   SINGULAR, UINT32,   ack_seq,           4) \
-X(a, STATIC,   SINGULAR, BYTES,    payload,           5) \
-X(a, STATIC,   SINGULAR, UINT32,   cols,              6) \
-X(a, STATIC,   SINGULAR, UINT32,   rows,              7) \
-X(a, STATIC,   SINGULAR, UINT32,   flags,             8)
-#define meshtastic_RemoteShell_CALLBACK NULL
-#define meshtastic_RemoteShell_DEFAULT NULL
-
 #define meshtastic_Waypoint_FIELDLIST(X, a) \
 X(a, STATIC,   SINGULAR, UINT32,   id,                1) \
 X(a, STATIC,   OPTIONAL, SFIXED32, latitude_i,        2) \
@@ -2170,7 +2095,6 @@ extern const pb_msgdesc_t meshtastic_Routing_msg;
 extern const pb_msgdesc_t meshtastic_Data_msg;
 extern const pb_msgdesc_t meshtastic_KeyVerification_msg;
 extern const pb_msgdesc_t meshtastic_StoreForwardPlusPlus_msg;
-extern const pb_msgdesc_t meshtastic_RemoteShell_msg;
 extern const pb_msgdesc_t meshtastic_Waypoint_msg;
 extern const pb_msgdesc_t meshtastic_StatusMessage_msg;
 extern const pb_msgdesc_t meshtastic_MqttClientProxyMessage_msg;
@@ -2206,7 +2130,6 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_Data_fields &meshtastic_Data_msg
 #define meshtastic_KeyVerification_fields &meshtastic_KeyVerification_msg
 #define meshtastic_StoreForwardPlusPlus_fields &meshtastic_StoreForwardPlusPlus_msg
-#define meshtastic_RemoteShell_fields &meshtastic_RemoteShell_msg
 #define meshtastic_Waypoint_fields &meshtastic_Waypoint_msg
 #define meshtastic_StatusMessage_fields &meshtastic_StatusMessage_msg
 #define meshtastic_MqttClientProxyMessage_fields &meshtastic_MqttClientProxyMessage_msg
@@ -2262,7 +2185,6 @@ extern const pb_msgdesc_t meshtastic_ChunkedPayloadResponse_msg;
 #define meshtastic_NodeRemoteHardwarePin_size    29
 #define meshtastic_Position_size                 144
 #define meshtastic_QueueStatus_size              23
-#define meshtastic_RemoteShell_size              241
 #define meshtastic_RouteDiscovery_size           256
 #define meshtastic_Routing_size                  259
 #define meshtastic_StatusMessage_size            81

src/mesh/generated/meshtastic/portnums.pb.h

@@ -76,8 +76,6 @@ typedef enum _meshtastic_PortNum {
     meshtastic_PortNum_ALERT_APP = 11,
     /* Module/port for handling key verification requests. */
     meshtastic_PortNum_KEY_VERIFICATION_APP = 12,
-    /* Module/port for handling primitive remote shell access. */
-    meshtastic_PortNum_REMOTE_SHELL_APP = 13,
     /* Provides a 'ping' service that replies to any packet it receives.
  Also serves as a small example module.
  ENCODING: ASCII Plaintext */

src/mesh/generated/meshtastic/telemetry.pb.h

@@ -113,9 +113,7 @@ typedef enum _meshtastic_TelemetrySensorType {
     /* SCD30 CO2, humidity, temperature sensor */
     meshtastic_TelemetrySensorType_SCD30 = 49,
     /* SHT family of sensors for temperature and humidity */
-    meshtastic_TelemetrySensorType_SHTXX = 50,
-    /* DS248X Bridge for one-wire temperature sensors */
-    meshtastic_TelemetrySensorType_DS248X = 51
+    meshtastic_TelemetrySensorType_SHTXX = 50
 } meshtastic_TelemetrySensorType;
 
 /* Struct definitions */
@@ -208,9 +206,6 @@ typedef struct _meshtastic_EnvironmentMetrics {
     /* Soil temperature measured (*C) */
     bool has_soil_temperature;
     float soil_temperature;
-    /* One-wire temperature (*C) */
-    pb_size_t one_wire_temperature_count;
-    float one_wire_temperature[8];
 } meshtastic_EnvironmentMetrics;
 
 /* Power Metrics (voltage / current / etc) */
@@ -496,8 +491,8 @@ extern "C" {
 
 /* Helper constants for enums */
 #define _meshtastic_TelemetrySensorType_MIN meshtastic_TelemetrySensorType_SENSOR_UNSET
-#define _meshtastic_TelemetrySensorType_MAX meshtastic_TelemetrySensorType_DS248X
-#define _meshtastic_TelemetrySensorType_ARRAYSIZE ((meshtastic_TelemetrySensorType)(meshtastic_TelemetrySensorType_DS248X+1))
+#define _meshtastic_TelemetrySensorType_MAX meshtastic_TelemetrySensorType_SHTXX
+#define _meshtastic_TelemetrySensorType_ARRAYSIZE ((meshtastic_TelemetrySensorType)(meshtastic_TelemetrySensorType_SHTXX+1))
 
 
 
@@ -513,7 +508,7 @@ extern "C" {
 
 /* Initializer values for message structs */
 #define meshtastic_DeviceMetrics_init_default    {false, 0, false, 0, false, 0, false, 0, false, 0}
-#define meshtastic_EnvironmentMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}}
+#define meshtastic_EnvironmentMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_PowerMetrics_init_default     {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_AirQualityMetrics_init_default {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_LocalStats_init_default       {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
@@ -524,7 +519,7 @@ extern "C" {
 #define meshtastic_Nau7802Config_init_default    {0, 0}
 #define meshtastic_SEN5XState_init_default       {0, 0, 0, false, 0, false, 0, false, 0}
 #define meshtastic_DeviceMetrics_init_zero       {false, 0, false, 0, false, 0, false, 0, false, 0}
-#define meshtastic_EnvironmentMetrics_init_zero  {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}}
+#define meshtastic_EnvironmentMetrics_init_zero  {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_PowerMetrics_init_zero        {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_AirQualityMetrics_init_zero   {false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0, false, 0}
 #define meshtastic_LocalStats_init_zero          {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
@@ -563,7 +558,6 @@ extern "C" {
 #define meshtastic_EnvironmentMetrics_rainfall_24h_tag 20
 #define meshtastic_EnvironmentMetrics_soil_moisture_tag 21
 #define meshtastic_EnvironmentMetrics_soil_temperature_tag 22
-#define meshtastic_EnvironmentMetrics_one_wire_temperature_tag 23
 #define meshtastic_PowerMetrics_ch1_voltage_tag  1
 #define meshtastic_PowerMetrics_ch1_current_tag  2
 #define meshtastic_PowerMetrics_ch2_voltage_tag  3
@@ -689,8 +683,7 @@ X(a, STATIC,   OPTIONAL, FLOAT,    radiation,        18) \
 X(a, STATIC,   OPTIONAL, FLOAT,    rainfall_1h,      19) \
 X(a, STATIC,   OPTIONAL, FLOAT,    rainfall_24h,     20) \
 X(a, STATIC,   OPTIONAL, UINT32,   soil_moisture,    21) \
-X(a, STATIC,   OPTIONAL, FLOAT,    soil_temperature,  22) \
-X(a, STATIC,   REPEATED, FLOAT,    one_wire_temperature,  23)
+X(a, STATIC,   OPTIONAL, FLOAT,    soil_temperature,  22)
 #define meshtastic_EnvironmentMetrics_CALLBACK NULL
 #define meshtastic_EnvironmentMetrics_DEFAULT NULL
 
@@ -859,7 +852,7 @@ extern const pb_msgdesc_t meshtastic_SEN5XState_msg;
 #define MESHTASTIC_MESHTASTIC_TELEMETRY_PB_H_MAX_SIZE meshtastic_Telemetry_size
 #define meshtastic_AirQualityMetrics_size        150
 #define meshtastic_DeviceMetrics_size            27
-#define meshtastic_EnvironmentMetrics_size       161
+#define meshtastic_EnvironmentMetrics_size       113
 #define meshtastic_HealthMetrics_size            11
 #define meshtastic_HostMetrics_size              264
 #define meshtastic_LocalStats_size               87

src/mesh/mesh-pb-constants.h

@@ -69,22 +69,6 @@ static inline int get_max_num_nodes()
 /// Max number of channels allowed
 #define MAX_NUM_CHANNELS (member_size(meshtastic_ChannelFile, channels) / member_size(meshtastic_ChannelFile, channels[0]))
 
-// Traffic Management module configuration
-// Enable per-variant by defining HAS_TRAFFIC_MANAGEMENT=1 in variant.h
-#ifndef HAS_TRAFFIC_MANAGEMENT
-#define HAS_TRAFFIC_MANAGEMENT 0
-#endif
-
-// Cache size for traffic management (number of nodes to track)
-// Can be overridden per-variant based on available memory
-#ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#if HAS_TRAFFIC_MANAGEMENT
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 1000
-#else
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 0
-#endif
-#endif
-
 /// helper function for encoding a record as a protobuf, any failures to encode are fatal and we will panic
 /// returns the encoded packet size
 size_t pb_encode_to_bytes(uint8_t *destbuf, size_t destbufsize, const pb_msgdesc_t *fields, const void *src_struct);
@@ -106,4 +90,4 @@ bool writecb(pb_ostream_t *stream, const uint8_t *buf, size_t count);
  */
 bool is_in_helper(uint32_t n, const uint32_t *array, pb_size_t count);
 
-#define is_in_repeated(name, n) is_in_helper(n, name, name##_count)
+#define is_in_repeated(name, n) is_in_helper(n, name, name##_count)

src/mesh/wifi/WiFiAPClient.cpp

@@ -401,9 +401,7 @@ static void WiFiEvent(WiFiEvent_t event)
             WiFi.disconnect(false, true);
             syslog.disable();
             needReconnect = true;
-            if (wifiReconnect) {
-                wifiReconnect->setIntervalFromNow(1000);
-            }
+            wifiReconnect->setIntervalFromNow(1000);
         }
         break;
     case ARDUINO_EVENT_WIFI_STA_AUTHMODE_CHANGE:
@@ -433,9 +431,7 @@ static void WiFiEvent(WiFiEvent_t event)
             WiFi.disconnect(false, true);
             syslog.disable();
             needReconnect = true;
-            if (wifiReconnect) {
-                wifiReconnect->setIntervalFromNow(1000);
-            }
+            wifiReconnect->setIntervalFromNow(1000);
         }
         break;
     case ARDUINO_EVENT_WPS_ER_SUCCESS:

src/modules/AdminModule.cpp

@@ -24,9 +24,7 @@
 
 #include "Default.h"
 #include "MeshRadio.h"
-#include "RadioInterface.h"
 #include "TypeConversions.h"
-#include "mesh/RadioLibInterface.h"
 
 #if !MESHTASTIC_EXCLUDE_MQTT
 #include "mqtt/MQTT.h"
@@ -199,35 +197,10 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
         handleSetOwner(r->set_owner);
         break;
 
-    case meshtastic_AdminMessage_set_config_tag: {
+    case meshtastic_AdminMessage_set_config_tag:
         LOG_DEBUG("Client set config");
-
-        // Non-LoRa configs need no further validation.
-        if (r->set_config.which_payload_variant != meshtastic_Config_lora_tag) {
-            LOG_DEBUG("Non-LoRa config, applying directly");
-            handleSetConfig(r->set_config, fromOthers);
-            break;
-        }
-
-        // Only LORA_24 requires hardware capability validation.
-        if (r->set_config.payload_variant.lora.region != meshtastic_Config_LoRaConfig_RegionCode_LORA_24) {
-            LOG_DEBUG("LoRa config, region is not LORA_24, applying directly");
-            handleSetConfig(r->set_config, fromOthers);
-            break;
-        }
-
-        // Hardware supports 2.4 GHz — apply the config.
-        // Fail closed: null instance is treated as incapable.
-        if (RadioLibInterface::instance && RadioLibInterface::instance->wideLora()) {
-            LOG_DEBUG("LORA_24 requested, radio hardware supports 2.4 GHz, applying");
-            handleSetConfig(r->set_config, fromOthers);
-            break;
-        }
-
-        LOG_WARN("Radio hardware does not support 2.4 GHz; rejecting LORA_24 region");
-        myReply = allocErrorResponse(meshtastic_Routing_Error_BAD_REQUEST, &mp);
+        handleSetConfig(r->set_config);
         break;
-    }
 
     case meshtastic_AdminMessage_set_module_config_tag:
         LOG_DEBUG("Client set module config");
@@ -480,7 +453,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
 #if HAS_SCREEN
         IF_SCREEN(screen->showSimpleBanner("Device is rebooting\ninto DFU mode.", 0));
 #endif
-#if defined(ARCH_NRF52) || defined(ARCH_RP2040) || defined(ARCH_STM32WL)
+#if defined(ARCH_NRF52) || defined(ARCH_RP2040)
         enterDfuMode();
 #endif
         break;
@@ -653,7 +626,7 @@ void AdminModule::handleSetOwner(const meshtastic_User &o)
     }
 }
 
-void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers)
+void AdminModule::handleSetConfig(const meshtastic_Config &c)
 {
     auto changes = SEGMENT_CONFIG;
     auto existingRole = config.device.role;
@@ -797,57 +770,18 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers)
             validatedLora.spread_factor = LORA_SF_DEFAULT;
         }
 
-        // If we're setting a new region, check the region is valid and then init the region or discard the change
-        if (validatedLora.region != myRegion->code) {
-            //  Region has changed so check whether it is valid for e.g. licensing conditions and if the lora config is valid
-            if (RadioInterface::validateConfigRegion(validatedLora) && RadioInterface::validateConfigLora(validatedLora)) {
-                // If we're setting region for the first time, init the region and regenerate the keys
-                if (isRegionUnset && validatedLora.region > meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
-#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
-                    if (crypto) {
-                        crypto->ensurePkiKeys(config.security, owner);
-                    }
-#endif
-                    // new region is valid and we're coming from an unset region, so enable tx
-                    validatedLora.tx_enabled = true;
-                }
-                // If we're unsetting the region for some reason, disable tx
-                if (!isRegionUnset && validatedLora.region == meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
-                    validatedLora.tx_enabled = false;
-                }
-                // Ensure initRegion() uses the newly validated region
-                config.lora.region = validatedLora.region;
-                initRegion();
-                if (myRegion->dutyCycle < 100) {
-                    validatedLora.ignore_mqtt = true; // Ignore MQTT by default if region has a duty cycle limit
-                }
-                if (strncmp(moduleConfig.mqtt.root, default_mqtt_root, strlen(default_mqtt_root)) == 0) {
-                    //  Default root is in use, so subscribe to the appropriate MQTT topic for this region
-                    sprintf(moduleConfig.mqtt.root, "%s/%s", default_mqtt_root, myRegion->name);
-                }
-                changes = SEGMENT_CONFIG | SEGMENT_MODULECONFIG;
-            } else {
-                //  Region validation has failed, so just copy all of the old config over the new config
-                validatedLora = oldLoraConfig;
-            }
-        } // end of new region handling
-
-        if (!RadioInterface::validateConfigLora(validatedLora)) {
-            if (fromOthers) {
-                LOG_WARN("Invalid LoRa config received from another node, rejecting changes");
-                //  modem_preset set to use the old setting if the check fails
-                validatedLora.modem_preset = oldLoraConfig.modem_preset;
-            } else {
-                LOG_WARN("Invalid LoRa config received from client, using corrected values");
-                RadioInterface::clampConfigLora(validatedLora);
-            }
-            //  use_preset and bandwidth are coerced into valid values by the check.
+        // If no lora radio parameters change, don't need to reboot
+        if (oldLoraConfig.use_preset == validatedLora.use_preset && oldLoraConfig.region == validatedLora.region &&
+            oldLoraConfig.modem_preset == validatedLora.modem_preset && oldLoraConfig.bandwidth == validatedLora.bandwidth &&
+            oldLoraConfig.spread_factor == validatedLora.spread_factor &&
+            oldLoraConfig.coding_rate == validatedLora.coding_rate && oldLoraConfig.tx_power == validatedLora.tx_power &&
+            oldLoraConfig.frequency_offset == validatedLora.frequency_offset &&
+            oldLoraConfig.override_frequency == validatedLora.override_frequency &&
+            oldLoraConfig.channel_num == validatedLora.channel_num &&
+            oldLoraConfig.sx126x_rx_boosted_gain == validatedLora.sx126x_rx_boosted_gain) {
+            requiresReboot = false;
         }
 
-        // All LoRa radio changes apply live via configChanged observer → reconfigure().
-        // reconfigure() puts the radio in standby, reprograms all modem parameters, and restarts receive.
-        requiresReboot = false;
-
 #if defined(ARCH_PORTDUINO)
         // If running on portduino and using SimRadio, do not require reboot
         if (SimRadio::instance) {
@@ -863,21 +797,63 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers)
             digitalWrite(RF95_FAN_EN, HIGH ^ 0);
         }
 #endif
+        config.lora = validatedLora;
 
 #if HAS_LORA_FEM
         // Apply FEM LNA mode from config (only meaningful on hardware that supports it)
-        // Note that a rejected lora config will revert this as well.
         if (loraFEMInterface.isLnaCanControl()) {
-            loraFEMInterface.setLNAEnable(validatedLora.fem_lna_mode != meshtastic_Config_LoRaConfig_FEM_LNA_Mode_DISABLED);
-        } else if (validatedLora.fem_lna_mode != meshtastic_Config_LoRaConfig_FEM_LNA_Mode_NOT_PRESENT) {
+            loraFEMInterface.setLNAEnable(config.lora.fem_lna_mode != meshtastic_Config_LoRaConfig_FEM_LNA_Mode_DISABLED);
+        } else if (config.lora.fem_lna_mode != meshtastic_Config_LoRaConfig_FEM_LNA_Mode_NOT_PRESENT) {
             // Hardware FEM does not support LNA control; normalize stored config to match actual capability
             LOG_WARN("FEM LNA mode configured but current FEM does not support LNA control; normalizing to NOT_PRESENT");
-            validatedLora.fem_lna_mode = meshtastic_Config_LoRaConfig_FEM_LNA_Mode_NOT_PRESENT;
+            config.lora.fem_lna_mode = meshtastic_Config_LoRaConfig_FEM_LNA_Mode_NOT_PRESENT;
         }
 #endif
+        // If we're setting region for the first time, init the region and regenerate the keys
+        if (isRegionUnset && config.lora.region > meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
+#if !(MESHTASTIC_EXCLUDE_PKI_KEYGEN || MESHTASTIC_EXCLUDE_PKI)
+            if (!owner.is_licensed) {
+                bool keygenSuccess = false;
+                if (config.security.private_key.size == 32) {
+                    if (crypto->regeneratePublicKey(config.security.public_key.bytes, config.security.private_key.bytes)) {
+                        keygenSuccess = true;
+                    }
+                } else {
+                    LOG_INFO("Generate new PKI keys");
+                    crypto->generateKeyPair(config.security.public_key.bytes, config.security.private_key.bytes);
+                    keygenSuccess = true;
+                }
+                if (keygenSuccess) {
+                    config.security.public_key.size = 32;
+                    config.security.private_key.size = 32;
+                    owner.public_key.size = 32;
+                    memcpy(owner.public_key.bytes, config.security.public_key.bytes, 32);
+                }
+            }
+#endif
+            config.lora.tx_enabled = true;
+            initRegion();
+            if (myRegion->dutyCycle < 100) {
+                config.lora.ignore_mqtt = true; // Ignore MQTT by default if region has a duty cycle limit
+            }
+            //  Compare the entire string, we are sure of the length as a topic has never been set
+            if (strcmp(moduleConfig.mqtt.root, default_mqtt_root) == 0) {
+                sprintf(moduleConfig.mqtt.root, "%s/%s", default_mqtt_root, myRegion->name);
+                changes = SEGMENT_CONFIG | SEGMENT_MODULECONFIG;
+            }
+        }
+        if (config.lora.region != myRegion->code) {
+            //  Region has changed so check whether there is a regulatory one we should be using instead.
+            //  Additionally as a side-effect, assume a new value under myRegion
+            initRegion();
 
-        config.lora = validatedLora; // Finally, return the validated config back to the main config
+            if (strncmp(moduleConfig.mqtt.root, default_mqtt_root, strlen(default_mqtt_root)) == 0) {
+                //  Default root is in use, so subscribe to the appropriate MQTT topic for this region
+                sprintf(moduleConfig.mqtt.root, "%s/%s", default_mqtt_root, myRegion->name);
+            }
 
+            changes = SEGMENT_CONFIG | SEGMENT_MODULECONFIG;
+        }
         break;
     }
     case meshtastic_Config_bluetooth_tag:
@@ -925,10 +901,10 @@ void AdminModule::handleSetConfig(const meshtastic_Config &c, bool fromOthers)
     }
     if (requiresReboot && !hasOpenEditTransaction) {
         disableBluetooth();
-    } // end of switch case which_payload_variant
+    }
 
     saveChanges(changes, requiresReboot);
-} // end of handleSetConfig
+}
 
 bool AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c)
 {
@@ -1034,11 +1010,6 @@ bool AdminModule::handleSetModuleConfig(const meshtastic_ModuleConfig &c)
         moduleConfig.statusmessage = c.payload_variant.statusmessage;
         shouldReboot = false;
         break;
-    case meshtastic_ModuleConfig_traffic_management_tag:
-        LOG_INFO("Set module config: Traffic Management");
-        moduleConfig.has_traffic_management = true;
-        moduleConfig.traffic_management = c.payload_variant.traffic_management;
-        break;
     }
     saveChanges(SEGMENT_MODULECONFIG, shouldReboot);
     return true;
@@ -1153,85 +1124,78 @@ void AdminModule::handleGetModuleConfig(const meshtastic_MeshPacket &req, const
     meshtastic_AdminMessage res = meshtastic_AdminMessage_init_default;
 
     if (req.decoded.want_response) {
-        const char *configName = "?";
         switch (configType) {
         case meshtastic_AdminMessage_ModuleConfigType_MQTT_CONFIG:
-            configName = "MQTT";
+            LOG_INFO("Get module config: MQTT");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_mqtt_tag;
             res.get_module_config_response.payload_variant.mqtt = moduleConfig.mqtt;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_SERIAL_CONFIG:
-            configName = "Serial";
+            LOG_INFO("Get module config: Serial");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_serial_tag;
             res.get_module_config_response.payload_variant.serial = moduleConfig.serial;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_EXTNOTIF_CONFIG:
-            configName = "External Notification";
+            LOG_INFO("Get module config: External Notification");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_external_notification_tag;
             res.get_module_config_response.payload_variant.external_notification = moduleConfig.external_notification;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_STOREFORWARD_CONFIG:
-            configName = "Store & Forward";
+            LOG_INFO("Get module config: Store & Forward");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_store_forward_tag;
             res.get_module_config_response.payload_variant.store_forward = moduleConfig.store_forward;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_RANGETEST_CONFIG:
-            configName = "Range Test";
+            LOG_INFO("Get module config: Range Test");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_range_test_tag;
             res.get_module_config_response.payload_variant.range_test = moduleConfig.range_test;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_TELEMETRY_CONFIG:
-            configName = "Telemetry";
+            LOG_INFO("Get module config: Telemetry");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_telemetry_tag;
             res.get_module_config_response.payload_variant.telemetry = moduleConfig.telemetry;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_CANNEDMSG_CONFIG:
-            configName = "Canned Message";
+            LOG_INFO("Get module config: Canned Message");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_canned_message_tag;
             res.get_module_config_response.payload_variant.canned_message = moduleConfig.canned_message;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_AUDIO_CONFIG:
-            configName = "Audio";
+            LOG_INFO("Get module config: Audio");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_audio_tag;
             res.get_module_config_response.payload_variant.audio = moduleConfig.audio;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_REMOTEHARDWARE_CONFIG:
-            configName = "Remote Hardware";
+            LOG_INFO("Get module config: Remote Hardware");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_remote_hardware_tag;
             res.get_module_config_response.payload_variant.remote_hardware = moduleConfig.remote_hardware;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_NEIGHBORINFO_CONFIG:
-            configName = "Neighbor Info";
+            LOG_INFO("Get module config: Neighbor Info");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_neighbor_info_tag;
             res.get_module_config_response.payload_variant.neighbor_info = moduleConfig.neighbor_info;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_DETECTIONSENSOR_CONFIG:
-            configName = "Detection Sensor";
+            LOG_INFO("Get module config: Detection Sensor");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_detection_sensor_tag;
             res.get_module_config_response.payload_variant.detection_sensor = moduleConfig.detection_sensor;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_AMBIENTLIGHTING_CONFIG:
-            configName = "Ambient Lighting";
+            LOG_INFO("Get module config: Ambient Lighting");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_ambient_lighting_tag;
             res.get_module_config_response.payload_variant.ambient_lighting = moduleConfig.ambient_lighting;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_PAXCOUNTER_CONFIG:
-            configName = "Paxcounter";
+            LOG_INFO("Get module config: Paxcounter");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_paxcounter_tag;
             res.get_module_config_response.payload_variant.paxcounter = moduleConfig.paxcounter;
             break;
         case meshtastic_AdminMessage_ModuleConfigType_STATUSMESSAGE_CONFIG:
-            configName = "StatusMessage";
+            LOG_INFO("Get module config: StatusMessage");
             res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_statusmessage_tag;
             res.get_module_config_response.payload_variant.statusmessage = moduleConfig.statusmessage;
             break;
-        case meshtastic_AdminMessage_ModuleConfigType_TRAFFICMANAGEMENT_CONFIG:
-            configName = "Traffic Management";
-            res.get_module_config_response.which_payload_variant = meshtastic_ModuleConfig_traffic_management_tag;
-            res.get_module_config_response.payload_variant.traffic_management = moduleConfig.traffic_management;
-            break;
         }
-        LOG_INFO("Get module config: %s", configName);
 
         // NOTE: The phone app needs to know the ls_secsvalue so it can properly expect sleep behavior.
         // So even if we internally use 0 to represent 'use default' we still need to send the value we are
@@ -1414,17 +1378,23 @@ void AdminModule::handleStoreDeviceUIConfig(const meshtastic_DeviceUIConfig &uic
 void AdminModule::handleSetHamMode(const meshtastic_HamParameters &p)
 {
     // Validate ham parameters before setting since this would bypass validation in the owner struct
-    const char *fieldsToCheck[] = {p.call_sign, p.short_name};
-    const char *fieldNames[] = {"call_sign", "short_name"};
-    for (int i = 0; i < 2; i++) {
-        if (*fieldsToCheck[i]) {
-            const char *start = fieldsToCheck[i];
-            while (*start && isspace((unsigned char)*start))
-                start++;
-            if (*start == '\0') {
-                LOG_WARN("Rejected ham %s: must contain at least 1 non-whitespace character", fieldNames[i]);
-                return;
-            }
+    if (*p.call_sign) {
+        const char *start = p.call_sign;
+        // Skip all whitespace
+        while (*start && isspace((unsigned char)*start))
+            start++;
+        if (*start == '\0') {
+            LOG_WARN("Rejected ham call_sign: must contain at least 1 non-whitespace character");
+            return;
+        }
+    }
+    if (*p.short_name) {
+        const char *start = p.short_name;
+        while (*start && isspace((unsigned char)*start))
+            start++;
+        if (*start == '\0') {
+            LOG_WARN("Rejected ham short_name: must contain at least 1 non-whitespace character");
+            return;
         }
     }
 

src/modules/AdminModule.h

@@ -60,11 +60,7 @@ class AdminModule : public ProtobufModule<meshtastic_AdminMessage>, public Obser
      */
     void handleSetOwner(const meshtastic_User &o);
     void handleSetChannel(const meshtastic_Channel &cc);
-
-  protected:
-    void handleSetConfig(const meshtastic_Config &c, bool fromOthers);
-
-  private:
+    void handleSetConfig(const meshtastic_Config &c);
     bool handleSetModuleConfig(const meshtastic_ModuleConfig &c);
     void handleSetChannel();
     void handleSetHamMode(const meshtastic_HamParameters &req);

src/modules/Modules.cpp

@@ -38,9 +38,6 @@
 #include "modules/PowerStressModule.h"
 #endif
 #include "modules/RoutingModule.h"
-#if HAS_TRAFFIC_MANAGEMENT && !MESHTASTIC_EXCLUDE_TRAFFIC_MANAGEMENT
-#include "modules/TrafficManagementModule.h"
-#endif
 #include "modules/TextMessageModule.h"
 #if !MESHTASTIC_EXCLUDE_TRACEROUTE
 #include "modules/TraceRouteModule.h"
@@ -123,14 +120,6 @@ void setupModules()
 #if !MESHTASTIC_EXCLUDE_REPLYBOT
     new ReplyBotModule();
 #endif
-
-#if HAS_TRAFFIC_MANAGEMENT && !MESHTASTIC_EXCLUDE_TRAFFIC_MANAGEMENT
-    // Instantiate only when enabled to avoid extra memory use and background work.
-    if (moduleConfig.has_traffic_management && moduleConfig.traffic_management.enabled) {
-        trafficManagementModule = new TrafficManagementModule();
-    }
-#endif
-
 #if !MESHTASTIC_EXCLUDE_ADMIN
     adminModule = new AdminModule();
 #endif

src/modules/SerialModule.cpp

@@ -651,7 +651,7 @@ void SerialModule::processWXSerial()
         LOG_INFO("WS8X : %i %.1fg%.1f %.1fv %.1fv %.1fC rain: %.1f, %i sum", atoi(windDir), strtof(windVel, nullptr),
                  strtof(windGust, nullptr), batVoltageF, capVoltageF, temperatureF, rain, rainSum);
     }
-    if (gotwind && !Throttle::isWithinTimespanMs(lastAveraged, averageIntervalMillis) && velCount > 0 && dirCount > 0) {
+    if (gotwind && !Throttle::isWithinTimespanMs(lastAveraged, averageIntervalMillis)) {
         // calculate averages and send to the mesh
         float velAvg = 1.0 * velSum / velCount;
 

src/modules/Telemetry/EnvironmentTelemetry.cpp

@@ -66,10 +66,18 @@ extern void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const c
 #include "Sensor/MCP9808Sensor.h"
 #endif
 
+#if __has_include(<Adafruit_SHT31.h>)
+#include "Sensor/SHT31Sensor.h"
+#endif
+
 #if __has_include(<Adafruit_LPS2X.h>)
 #include "Sensor/LPS22HBSensor.h"
 #endif
 
+#if __has_include(<Adafruit_SHTC3.h>)
+#include "Sensor/SHTC3Sensor.h"
+#endif
+
 #if __has_include("RAK12035_SoilMoisture.h") && defined(RAK_4631) && RAK_4631 == 1
 #include "Sensor/RAK12035Sensor.h"
 #endif
@@ -86,8 +94,8 @@ extern void drawCommonHeader(OLEDDisplay *display, int16_t x, int16_t y, const c
 #include "Sensor/OPT3001Sensor.h"
 #endif
 
-#if __has_include(<SHTSensor.h>)
-#include "Sensor/SHTXXSensor.h"
+#if __has_include(<Adafruit_SHT4x.h>)
+#include "Sensor/SHT4XSensor.h"
 #endif
 
 #if __has_include(<SparkFun_MLX90632_Arduino_Library.h>)
@@ -147,15 +155,6 @@ void EnvironmentTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner)
     }
     LOG_INFO("Environment Telemetry adding I2C devices...");
 
-    /*
-        Uncomment the preferences below if you want to use the module
-        without having to configure it from the PythonAPI or WebUI.
-    */
-
-    // moduleConfig.telemetry.environment_measurement_enabled = 1;
-    // moduleConfig.telemetry.environment_screen_enabled = 1;
-    // moduleConfig.telemetry.environment_update_interval = 15;
-
     // order by priority of metrics/values (low top, high bottom)
 
 #if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
@@ -203,9 +202,15 @@ void EnvironmentTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner)
 #if __has_include(<Adafruit_MCP9808.h>)
     addSensor<MCP9808Sensor>(i2cScanner, ScanI2C::DeviceType::MCP9808);
 #endif
+#if __has_include(<Adafruit_SHT31.h>)
+    addSensor<SHT31Sensor>(i2cScanner, ScanI2C::DeviceType::SHT31);
+#endif
 #if __has_include(<Adafruit_LPS2X.h>)
     addSensor<LPS22HBSensor>(i2cScanner, ScanI2C::DeviceType::LPS22HB);
 #endif
+#if __has_include(<Adafruit_SHTC3.h>)
+    addSensor<SHTC3Sensor>(i2cScanner, ScanI2C::DeviceType::SHTC3);
+#endif
 #if __has_include("RAK12035_SoilMoisture.h") && defined(RAK_4631) && RAK_4631 == 1
     addSensor<RAK12035Sensor>(i2cScanner, ScanI2C::DeviceType::RAK12035);
 #endif
@@ -218,9 +223,13 @@ void EnvironmentTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner)
 #if __has_include(<ClosedCube_OPT3001.h>)
     addSensor<OPT3001Sensor>(i2cScanner, ScanI2C::DeviceType::OPT3001);
 #endif
+#if __has_include(<Adafruit_SHT4x.h>)
+    addSensor<SHT4XSensor>(i2cScanner, ScanI2C::DeviceType::SHT4X);
+#endif
 #if __has_include(<SparkFun_MLX90632_Arduino_Library.h>)
     addSensor<MLX90632Sensor>(i2cScanner, ScanI2C::DeviceType::MLX90632);
 #endif
+
 #if __has_include(<Adafruit_BMP3XX.h>)
     addSensor<BMP3XXSensor>(i2cScanner, ScanI2C::DeviceType::BMP_3XX);
 #endif
@@ -236,10 +245,7 @@ void EnvironmentTelemetryModule::i2cScanFinished(ScanI2C *i2cScanner)
 #if __has_include(<BH1750_WE.h>)
     addSensor<BH1750Sensor>(i2cScanner, ScanI2C::DeviceType::BH1750);
 #endif
-#if __has_include(<SHTSensor.h>)
-    // TODO Can we scan for multiple sensors connected on the same bus?
-    addSensor<SHTXXSensor>(i2cScanner, ScanI2C::DeviceType::SHTXX);
-#endif
+
 #endif
 }
 
@@ -254,6 +260,14 @@ int32_t EnvironmentTelemetryModule::runOnce()
     }
 
     uint32_t result = UINT32_MAX;
+    /*
+        Uncomment the preferences below if you want to use the module
+        without having to configure it from the PythonAPI or WebUI.
+    */
+
+    // moduleConfig.telemetry.environment_measurement_enabled = 1;
+    // moduleConfig.telemetry.environment_screen_enabled = 1;
+    // moduleConfig.telemetry.environment_update_interval = 15;
 
     if (!(moduleConfig.telemetry.environment_measurement_enabled || moduleConfig.telemetry.environment_screen_enabled ||
           ENVIRONMENTAL_TELEMETRY_MODULE_ENABLE)) {

src/modules/Telemetry/Sensor/SHT31Sensor.cpp

@@ -0,0 +1,31 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<Adafruit_SHT31.h>)
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "SHT31Sensor.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_SHT31.h>
+
+SHT31Sensor::SHT31Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_SHT31, "SHT31") {}
+
+bool SHT31Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
+{
+    LOG_INFO("Init sensor: %s", sensorName);
+    sht31 = Adafruit_SHT31(bus);
+    status = sht31.begin(dev->address.address);
+    initI2CSensor();
+    return status;
+}
+
+bool SHT31Sensor::getMetrics(meshtastic_Telemetry *measurement)
+{
+    measurement->variant.environment_metrics.has_temperature = true;
+    measurement->variant.environment_metrics.has_relative_humidity = true;
+    measurement->variant.environment_metrics.temperature = sht31.readTemperature();
+    measurement->variant.environment_metrics.relative_humidity = sht31.readHumidity();
+
+    return true;
+}
+
+#endif

src/modules/Telemetry/Sensor/SHT31Sensor.h

@@ -0,0 +1,20 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<Adafruit_SHT31.h>)
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_SHT31.h>
+
+class SHT31Sensor : public TelemetrySensor
+{
+  private:
+    Adafruit_SHT31 sht31;
+
+  public:
+    SHT31Sensor();
+    virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
+};
+
+#endif

src/modules/Telemetry/Sensor/SHT4XSensor.cpp

@@ -0,0 +1,48 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<Adafruit_SHT4x.h>)
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "SHT4XSensor.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_SHT4x.h>
+
+SHT4XSensor::SHT4XSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_SHT4X, "SHT4X") {}
+
+bool SHT4XSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
+{
+    LOG_INFO("Init sensor: %s", sensorName);
+
+    uint32_t serialNumber = 0;
+
+    status = sht4x.begin(bus);
+    if (!status) {
+        return status;
+    }
+
+    serialNumber = sht4x.readSerial();
+    if (serialNumber != 0) {
+        LOG_DEBUG("serialNumber : %x", serialNumber);
+        status = 1;
+    } else {
+        LOG_DEBUG("Error trying to execute readSerial(): ");
+        status = 0;
+    }
+
+    initI2CSensor();
+    return status;
+}
+
+bool SHT4XSensor::getMetrics(meshtastic_Telemetry *measurement)
+{
+    measurement->variant.environment_metrics.has_temperature = true;
+    measurement->variant.environment_metrics.has_relative_humidity = true;
+
+    sensors_event_t humidity, temp;
+    sht4x.getEvent(&humidity, &temp);
+    measurement->variant.environment_metrics.temperature = temp.temperature;
+    measurement->variant.environment_metrics.relative_humidity = humidity.relative_humidity;
+    return true;
+}
+
+#endif

src/modules/Telemetry/Sensor/SHT4XSensor.h

@@ -0,0 +1,20 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<Adafruit_SHT4x.h>)
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_SHT4x.h>
+
+class SHT4XSensor : public TelemetrySensor
+{
+  private:
+    Adafruit_SHT4x sht4x = Adafruit_SHT4x();
+
+  public:
+    SHT4XSensor();
+    virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
+};
+
+#endif

src/modules/Telemetry/Sensor/SHTC3Sensor.cpp

@@ -0,0 +1,35 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<Adafruit_SHTC3.h>)
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "SHTC3Sensor.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_SHTC3.h>
+
+SHTC3Sensor::SHTC3Sensor() : TelemetrySensor(meshtastic_TelemetrySensorType_SHTC3, "SHTC3") {}
+
+bool SHTC3Sensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
+{
+    LOG_INFO("Init sensor: %s", sensorName);
+    status = shtc3.begin(bus);
+
+    initI2CSensor();
+    return status;
+}
+
+bool SHTC3Sensor::getMetrics(meshtastic_Telemetry *measurement)
+{
+    measurement->variant.environment_metrics.has_temperature = true;
+    measurement->variant.environment_metrics.has_relative_humidity = true;
+
+    sensors_event_t humidity, temp;
+    shtc3.getEvent(&humidity, &temp);
+
+    measurement->variant.environment_metrics.temperature = temp.temperature;
+    measurement->variant.environment_metrics.relative_humidity = humidity.relative_humidity;
+
+    return true;
+}
+
+#endif

src/modules/Telemetry/Sensor/SHTC3Sensor.h

@@ -0,0 +1,20 @@
+#include "configuration.h"
+
+#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<Adafruit_SHTC3.h>)
+
+#include "../mesh/generated/meshtastic/telemetry.pb.h"
+#include "TelemetrySensor.h"
+#include <Adafruit_SHTC3.h>
+
+class SHTC3Sensor : public TelemetrySensor
+{
+  private:
+    Adafruit_SHTC3 shtc3 = Adafruit_SHTC3();
+
+  public:
+    SHTC3Sensor();
+    virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
+    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
+};
+
+#endif

src/modules/Telemetry/Sensor/SHTXXSensor.cpp

@@ -1,145 +0,0 @@
-#include "configuration.h"
-
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<SHTSensor.h>)
-
-#include "../mesh/generated/meshtastic/telemetry.pb.h"
-#include "SHTXXSensor.h"
-#include "TelemetrySensor.h"
-#include <SHTSensor.h>
-
-SHTXXSensor::SHTXXSensor() : TelemetrySensor(meshtastic_TelemetrySensorType_SHTXX, "SHTXX") {}
-
-void SHTXXSensor::getSensorVariant(SHTSensor::SHTSensorType sensorType)
-{
-    switch (sensorType) {
-    case SHTSensor::SHTSensorType::SHT2X:
-        sensorVariant = "SHT2x";
-        break;
-
-    case SHTSensor::SHTSensorType::SHT3X:
-    case SHTSensor::SHTSensorType::SHT85:
-        sensorVariant = "SHT3x/SHT85";
-        break;
-
-    case SHTSensor::SHTSensorType::SHT3X_ALT:
-        sensorVariant = "SHT3x";
-        break;
-
-    case SHTSensor::SHTSensorType::SHTW1:
-    case SHTSensor::SHTSensorType::SHTW2:
-    case SHTSensor::SHTSensorType::SHTC1:
-    case SHTSensor::SHTSensorType::SHTC3:
-        sensorVariant = "SHTC1/SHTC3/SHTW1/SHTW2";
-        break;
-
-    case SHTSensor::SHTSensorType::SHT4X:
-        sensorVariant = "SHT4x";
-        break;
-
-    default:
-        sensorVariant = "Unknown";
-        break;
-    }
-}
-
-bool SHTXXSensor::initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev)
-{
-    LOG_INFO("Init sensor: %s", sensorName);
-
-    _bus = bus;
-    _address = dev->address.address;
-
-    if (sht.init(*_bus)) {
-        LOG_INFO("%s: init(): success", sensorName);
-        getSensorVariant(sht.mSensorType);
-        LOG_INFO("%s Sensor detected: %s on 0x%x", sensorName, sensorVariant, _address);
-        status = 1;
-    } else {
-        LOG_ERROR("%s: init(): failed", sensorName);
-    }
-
-    initI2CSensor();
-    return status;
-}
-
-/**
- * Accuracy setting of measurement.
- * Not all sensors support changing the sampling accuracy (only SHT3X and SHT4X)
- * SHTAccuracy:
- * - SHT_ACCURACY_HIGH: Highest repeatability at the cost of slower measurement
- * - SHT_ACCURACY_MEDIUM: Balanced repeatability and speed of measurement
- * - SHT_ACCURACY_LOW: Fastest measurement but lowest repeatability
- */
-bool SHTXXSensor::setAccuracy(SHTSensor::SHTAccuracy newAccuracy)
-{
-    // Only SHT3X-family (including alternates) and SHT4X support changing accuracy
-    if (sht.mSensorType != SHTSensor::SHTSensorType::SHT3X && sht.mSensorType != SHTSensor::SHTSensorType::SHT3X_ALT &&
-        sht.mSensorType != SHTSensor::SHTSensorType::SHT85 && sht.mSensorType != SHTSensor::SHTSensorType::SHT4X) {
-        LOG_WARN("%s doesn't support accuracy setting", sensorVariant);
-        return false;
-    }
-    LOG_INFO("%s: setting new accuracy setting", sensorVariant);
-    accuracy = newAccuracy;
-    return sht.setAccuracy(accuracy);
-}
-
-bool SHTXXSensor::getMetrics(meshtastic_Telemetry *measurement)
-{
-    if (sht.readSample()) {
-        measurement->variant.environment_metrics.has_temperature = true;
-        measurement->variant.environment_metrics.has_relative_humidity = true;
-        measurement->variant.environment_metrics.temperature = sht.getTemperature();
-        measurement->variant.environment_metrics.relative_humidity = sht.getHumidity();
-
-        LOG_INFO("%s (%s): Got: temp:%fdegC, hum:%f%%rh", sensorName, sensorVariant,
-                 measurement->variant.environment_metrics.temperature,
-                 measurement->variant.environment_metrics.relative_humidity);
-
-        return true;
-    } else {
-        LOG_ERROR("%s (%s): read sample failed", sensorName, sensorVariant);
-        return false;
-    }
-}
-
-AdminMessageHandleResult SHTXXSensor::handleAdminMessage(const meshtastic_MeshPacket &mp, meshtastic_AdminMessage *request,
-                                                         meshtastic_AdminMessage *response)
-{
-    AdminMessageHandleResult result;
-    result = AdminMessageHandleResult::NOT_HANDLED;
-
-    switch (request->which_payload_variant) {
-    case meshtastic_AdminMessage_sensor_config_tag:
-        if (!request->sensor_config.has_shtxx_config) {
-            result = AdminMessageHandleResult::NOT_HANDLED;
-            break;
-        }
-
-        // Check for sensor accuracy setting
-        if (request->sensor_config.shtxx_config.has_set_accuracy) {
-            SHTSensor::SHTAccuracy newAccuracy;
-            if (request->sensor_config.shtxx_config.set_accuracy == 0) {
-                newAccuracy = SHTSensor::SHT_ACCURACY_LOW;
-            } else if (request->sensor_config.shtxx_config.set_accuracy == 1) {
-                newAccuracy = SHTSensor::SHT_ACCURACY_MEDIUM;
-            } else if (request->sensor_config.shtxx_config.set_accuracy == 2) {
-                newAccuracy = SHTSensor::SHT_ACCURACY_HIGH;
-            } else {
-                LOG_ERROR("%s: incorrect accuracy setting", sensorName);
-                result = AdminMessageHandleResult::HANDLED;
-                break;
-            }
-            this->setAccuracy(newAccuracy);
-        }
-
-        result = AdminMessageHandleResult::HANDLED;
-        break;
-
-    default:
-        result = AdminMessageHandleResult::NOT_HANDLED;
-    }
-
-    return result;
-}
-
-#endif

src/modules/Telemetry/Sensor/SHTXXSensor.h

@@ -1,29 +0,0 @@
-#include "configuration.h"
-
-#if !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<SHTSensor.h>)
-
-#include "../mesh/generated/meshtastic/telemetry.pb.h"
-#include "TelemetrySensor.h"
-#include <SHTSensor.h>
-
-class SHTXXSensor : public TelemetrySensor
-{
-  private:
-    SHTSensor sht;
-    TwoWire *_bus{};
-    uint8_t _address{};
-    SHTSensor::SHTAccuracy accuracy{};
-    bool setAccuracy(SHTSensor::SHTAccuracy newAccuracy);
-
-  public:
-    SHTXXSensor();
-    virtual bool getMetrics(meshtastic_Telemetry *measurement) override;
-    virtual bool initDevice(TwoWire *bus, ScanI2C::FoundDevice *dev) override;
-    void getSensorVariant(SHTSensor::SHTSensorType);
-    const char *sensorVariant{};
-
-    AdminMessageHandleResult handleAdminMessage(const meshtastic_MeshPacket &mp, meshtastic_AdminMessage *request,
-                                                meshtastic_AdminMessage *response) override;
-};
-
-#endif

src/modules/TrafficManagementModule.h

@@ -1,434 +0,0 @@
-#pragma once
-
-#include "MeshModule.h"
-#include "concurrency/Lock.h"
-#include "concurrency/OSThread.h"
-#include "mesh/generated/meshtastic/mesh.pb.h"
-#include "mesh/generated/meshtastic/telemetry.pb.h"
-
-#if HAS_TRAFFIC_MANAGEMENT
-
-/**
- * TrafficManagementModule - Packet inspection and traffic shaping for mesh networks.
- *
- * This module provides:
- * - Position deduplication (drop redundant position broadcasts)
- * - Per-node rate limiting (throttle chatty nodes)
- * - Unknown packet filtering (drop undecoded packets from repeat offenders)
- * - NodeInfo direct response (answer queries from cache to reduce mesh chatter)
- * - Local-only telemetry/position (exhaust hop_limit for local broadcasts)
- * - Router hop preservation (maintain hop_limit for router-to-router traffic)
- *
- * Memory Optimization:
- * Uses a unified cache with cuckoo hashing for O(1) lookups and 56% memory reduction
- * compared to separate per-feature caches. Timestamps are stored as 8-bit relative
- * offsets from a rolling epoch to further reduce memory footprint.
- */
-class TrafficManagementModule : public MeshModule, private concurrency::OSThread
-{
-  public:
-    TrafficManagementModule();
-    ~TrafficManagementModule();
-
-    // Singleton — no copying or moving
-    TrafficManagementModule(const TrafficManagementModule &) = delete;
-    TrafficManagementModule &operator=(const TrafficManagementModule &) = delete;
-
-    meshtastic_TrafficManagementStats getStats() const;
-    void resetStats();
-    void recordRouterHopPreserved();
-
-    /**
-     * Check if this packet should have its hops exhausted.
-     * Called from perhapsRebroadcast() to force hop_limit = 0 regardless of
-     * router_preserve_hops or favorite node logic.
-     */
-    bool shouldExhaustHops(const meshtastic_MeshPacket &mp) const
-    {
-        return exhaustRequested && exhaustRequestedFrom == getFrom(&mp) && exhaustRequestedId == mp.id;
-    }
-
-  protected:
-    ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
-    bool wantPacket(const meshtastic_MeshPacket *p) override { return true; }
-    void alterReceived(meshtastic_MeshPacket &mp) override;
-    int32_t runOnce() override;
-    // Protected so test shims can force epoch rollover behavior.
-    void resetEpoch(uint32_t nowMs);
-
-  private:
-    // =========================================================================
-    // Unified Cache Entry (10 bytes) - Same for ALL platforms
-    // =========================================================================
-    //
-    // A single compact structure used across ESP32, NRF52, and all other platforms.
-    // Memory: 10 bytes × 2048 entries = 20KB
-    //
-    // Position Fingerprinting:
-    //   Instead of storing full coordinates (8 bytes) or a computed hash,
-    //   we store an 8-bit fingerprint derived deterministically from the
-    //   truncated lat/lon. This extracts the lower 4 significant bits from
-    //   each coordinate: fingerprint = (lat_low4 << 4) | lon_low4
-    //
-    //   Benefits over hash:
-    //   - Adjacent grid cells have sequential fingerprints (no collision)
-    //   - Two positions only collide if 16+ grid cells apart in BOTH dimensions
-    //   - Deterministic: same input always produces same output
-    //
-    // Adaptive Timestamp Resolution:
-    //   All timestamps use 8-bit values with adaptive resolution calculated
-    //   from config at startup. Resolution = max(60, min(339, interval/2)).
-    //   - Min 60 seconds ensures reasonable precision
-    //   - Max 339 seconds allows ~24 hour range (255 * 339 = 86445 sec)
-    //   - interval/2 ensures at least 2 ticks per configured interval
-    //
-    // Layout:
-    //   [0-3]   node            - NodeNum (4 bytes)
-    //   [4]     pos_fingerprint - 4 bits lat + 4 bits lon (1 byte)
-    //   [5]     rate_count      - Packets in current window (1 byte)
-    //   [6]     unknown_count   - Unknown packets count (1 byte)
-    //   [7]     pos_time        - Position timestamp (1 byte, adaptive resolution)
-    //   [8]     rate_time       - Rate window start (1 byte, adaptive resolution)
-    //   [9]     unknown_time    - Unknown tracking start (1 byte, adaptive resolution)
-    //
-    struct __attribute__((packed)) UnifiedCacheEntry {
-        NodeNum node;            // 4 bytes - Node identifier (0 = empty slot)
-        uint8_t pos_fingerprint; // 1 byte  - Lower 4 bits of lat + lon
-        uint8_t rate_count;      // 1 byte  - Packet count (saturates at 255)
-        uint8_t unknown_count;   // 1 byte  - Unknown packet count (saturates at 255)
-        uint8_t pos_time;        // 1 byte  - Position timestamp (adaptive resolution)
-        uint8_t rate_time;       // 1 byte  - Rate window start (adaptive resolution)
-        uint8_t unknown_time;    // 1 byte  - Unknown tracking start (adaptive resolution)
-    };
-    static_assert(sizeof(UnifiedCacheEntry) == 10, "UnifiedCacheEntry should be 10 bytes");
-
-    // =========================================================================
-    // Cuckoo Hash Table Implementation
-    // =========================================================================
-    //
-    // Cuckoo hashing provides O(1) worst-case lookup time using two hash functions.
-    // Each key can be in one of two possible locations (h1 or h2). On collision,
-    // the existing entry is "kicked" to its alternate location.
-    //
-    // Benefits over linear scan:
-    // - O(1) lookup vs O(n) - critical at packet processing rates
-    // - O(1) insertion (amortized) with simple eviction on cycles
-    // - ~95% load factor achievable
-    //
-    // Cache size rounds to power-of-2 for fast modulo via bitmask.
-    // TRAFFIC_MANAGEMENT_CACHE_SIZE=2000 → cacheSize()=2048
-    //
-    static constexpr uint16_t cacheSize();
-    static constexpr uint16_t cacheMask();
-
-    // Hash functions for cuckoo hashing
-    inline uint16_t cuckooHash1(NodeNum node) const { return node & cacheMask(); }
-    inline uint16_t cuckooHash2(NodeNum node) const { return ((node * 2654435769u) >> (32 - cuckooHashBits())) & cacheMask(); }
-    static constexpr uint8_t cuckooHashBits();
-
-    // NodeInfo cache configuration (PSRAM path):
-    // - Payload lives in PSRAM
-    // - DRAM keeps packed 12-bit tags with 4-way bucketed cuckoo hashing
-    //   (Fan et al., CoNEXT 2014). Tag value 0 is reserved as "empty".
-    static constexpr uint16_t kNodeInfoIndexMetadataBudgetBytes = 3072; // 3KB DRAM tag store
-    static constexpr uint8_t kNodeInfoTargetOccupancyPercent = 95;
-    static constexpr uint8_t kNodeInfoBucketSize = 4;
-    static constexpr uint8_t kNodeInfoTagBits = 12;
-    static constexpr uint16_t kNodeInfoTagMask = static_cast<uint16_t>((1u << kNodeInfoTagBits) - 1u);
-    static constexpr uint16_t kNodeInfoIndexSlotsRaw =
-        static_cast<uint16_t>((kNodeInfoIndexMetadataBudgetBytes * 8u) / kNodeInfoTagBits);
-    static constexpr uint16_t kNodeInfoIndexSlots =
-        static_cast<uint16_t>(kNodeInfoIndexSlotsRaw - (kNodeInfoIndexSlotsRaw % kNodeInfoBucketSize));
-    static constexpr uint16_t kNodeInfoTargetEntries =
-        static_cast<uint16_t>((kNodeInfoIndexSlots * kNodeInfoTargetOccupancyPercent) / 100u);
-    static_assert((kNodeInfoIndexSlots % kNodeInfoBucketSize) == 0, "NodeInfo slot count must align to bucket size");
-    static_assert(kNodeInfoTargetEntries < (1u << kNodeInfoTagBits), "NodeInfo tag bits must encode payload index");
-
-    static constexpr uint16_t nodeInfoTargetEntries();
-    static constexpr uint16_t nodeInfoIndexMetadataBudgetBytes();
-    static constexpr uint8_t nodeInfoTargetOccupancyPercent();
-    static constexpr uint8_t nodeInfoBucketSize();
-    static constexpr uint8_t nodeInfoTagBits();
-    static constexpr uint16_t nodeInfoTagMask();
-    static constexpr uint16_t nodeInfoIndexSlots();
-    static constexpr uint16_t nodeInfoBucketCount();
-    static constexpr uint16_t nodeInfoBucketMask();
-    static constexpr uint8_t nodeInfoBucketHashBits();
-    inline uint16_t nodeInfoHash1(NodeNum node) const { return node & nodeInfoBucketMask(); }
-    inline uint16_t nodeInfoHash2(NodeNum node) const
-    {
-        return ((node * 2246822519u) >> (32 - nodeInfoBucketHashBits())) & nodeInfoBucketMask();
-    }
-
-    // =========================================================================
-    // Adaptive Timestamp Resolution
-    // =========================================================================
-    //
-    // All timestamps use 8-bit values with adaptive resolution calculated from
-    // config at startup. This allows ~24 hour range while maintaining precision.
-    //
-    // Resolution formula: max(60, min(339, interval/2))
-    //   - 60 sec minimum ensures reasonable precision
-    //   - 339 sec maximum allows 24 hour range (255 * 339 ≈ 86400 sec)
-    //   - interval/2 ensures at least 2 ticks per configured interval
-    //
-    // Since config changes require reboot, resolution is calculated once.
-    //
-    uint32_t cacheEpochMs = 0;
-    uint16_t posTimeResolution = 60;     // Seconds per tick for position
-    uint16_t rateTimeResolution = 60;    // Seconds per tick for rate limiting
-    uint16_t unknownTimeResolution = 60; // Seconds per tick for unknown tracking
-
-    // Calculate resolution from configured interval (called once at startup)
-    static uint16_t calcTimeResolution(uint32_t intervalSecs)
-    {
-        // Resolution = interval/2 to ensure at least 2 ticks per interval
-        // Clamped to [60, 339] for min precision and max 24h range
-        uint32_t res = (intervalSecs > 0) ? (intervalSecs / 2) : 60;
-        if (res < 60)
-            res = 60;
-        if (res > 339)
-            res = 339;
-        return static_cast<uint16_t>(res);
-    }
-
-    // Convert to/from 8-bit relative timestamps with given resolution
-    uint8_t toRelativeTime(uint32_t nowMs, uint16_t resolutionSecs) const
-    {
-        uint32_t ticks = (nowMs - cacheEpochMs) / (resolutionSecs * 1000UL);
-        return (ticks > UINT8_MAX) ? UINT8_MAX : static_cast<uint8_t>(ticks);
-    }
-    uint32_t fromRelativeTime(uint8_t ticks, uint16_t resolutionSecs) const
-    {
-        return cacheEpochMs + (static_cast<uint32_t>(ticks) * resolutionSecs * 1000UL);
-    }
-
-    // Convenience wrappers for each timestamp type
-    uint8_t toRelativePosTime(uint32_t nowMs) const { return toRelativeTime(nowMs, posTimeResolution); }
-    uint32_t fromRelativePosTime(uint8_t t) const { return fromRelativeTime(t, posTimeResolution); }
-
-    uint8_t toRelativeRateTime(uint32_t nowMs) const { return toRelativeTime(nowMs, rateTimeResolution); }
-    uint32_t fromRelativeRateTime(uint8_t t) const { return fromRelativeTime(t, rateTimeResolution); }
-
-    uint8_t toRelativeUnknownTime(uint32_t nowMs) const { return toRelativeTime(nowMs, unknownTimeResolution); }
-    uint32_t fromRelativeUnknownTime(uint8_t t) const { return fromRelativeTime(t, unknownTimeResolution); }
-
-    // Epoch reset when any timestamp approaches overflow
-    // With max resolution of 339 sec, 200 ticks = ~19 hours (safe margin for 24h max)
-    bool needsEpochReset(uint32_t nowMs) const
-    {
-        uint16_t maxRes = posTimeResolution;
-        if (rateTimeResolution > maxRes)
-            maxRes = rateTimeResolution;
-        if (unknownTimeResolution > maxRes)
-            maxRes = unknownTimeResolution;
-        return (nowMs - cacheEpochMs) > (200UL * maxRes * 1000UL);
-    }
-    // =========================================================================
-    // Position Fingerprint
-    // =========================================================================
-    //
-    // Computes 8-bit fingerprint from truncated lat/lon coordinates.
-    // Extracts lower 4 significant bits from each coordinate.
-    //
-    // fingerprint = (lat_low4 << 4) | lon_low4
-    //
-    // Unlike a hash, adjacent grid cells have sequential fingerprints,
-    // so nearby positions never collide. Collisions only occur for
-    // positions 16+ grid cells apart in both dimensions.
-    //
-    // Guards: If precision < 4 bits, uses min(precision, 4) bits.
-    //
-    static uint8_t computePositionFingerprint(int32_t lat_truncated, int32_t lon_truncated, uint8_t precision);
-
-    // =========================================================================
-    // Cache Storage
-    // =========================================================================
-
-    mutable concurrency::Lock cacheLock; // Protects all cache access
-    UnifiedCacheEntry *cache = nullptr;  // Cuckoo hash table (unified for all platforms)
-    bool cacheFromPsram = false;         // Tracks allocator for correct deallocation
-
-    struct NodeInfoPayloadEntry {
-        // Node identifier associated with this payload slot.
-        // 0 means the slot is currently unused.
-        NodeNum node;
-
-        // Cached NODEINFO_APP payload body. This is separate from NodeDB and is only
-        // used by the PSRAM-backed direct-response path in this module.
-        meshtastic_User user;
-
-        // Extra response metadata captured from the latest observed NODEINFO_APP
-        // packet for this node. shouldRespondToNodeInfo() uses this metadata when
-        // building spoofed replies for requesting clients.
-
-        // Last local uptime tick (millis) when this entry was refreshed.
-        uint32_t lastObservedMs;
-
-        // Last RTC/packet timestamp (seconds) observed for this NodeInfo frame.
-        // If unavailable in packet, remains 0.
-        uint32_t lastObservedRxTime;
-
-        // Channel where we most recently heard this node's NodeInfo.
-        uint8_t sourceChannel;
-
-        // Cached decoded bitfield metadata from the source packet.
-        // We preserve non-OK_TO_MQTT bits in direct replies when available.
-        bool hasDecodedBitfield;
-        uint8_t decodedBitfield;
-    };
-
-    NodeInfoPayloadEntry *nodeInfoPayload = nullptr; // NodeInfo payloads in PSRAM
-    bool nodeInfoPayloadFromPsram = false;           // Tracks allocator for correct deallocation
-    uint8_t *nodeInfoIndex = nullptr;                // Packed 12-bit NodeInfo tags in DRAM
-    uint16_t nodeInfoAllocHint = 0;
-    uint16_t nodeInfoEvictCursor = 0;
-
-    meshtastic_TrafficManagementStats stats;
-
-    // Flag set during alterReceived() when packet should be exhausted.
-    // Checked by perhapsRebroadcast() to force hop_limit = 0 only for the
-    // matching packet key (from + id). Reset at start of handleReceived().
-    bool exhaustRequested = false;
-    NodeNum exhaustRequestedFrom = 0;
-    PacketId exhaustRequestedId = 0;
-
-    // =========================================================================
-    // Cache Operations
-    // =========================================================================
-
-    // Find or create entry for node using cuckoo hashing
-    // Returns nullptr if cache is full and eviction fails
-    UnifiedCacheEntry *findOrCreateEntry(NodeNum node, bool *isNew);
-
-    // Find existing entry (no creation)
-    UnifiedCacheEntry *findEntry(NodeNum node);
-
-    // NodeInfo cache operations (bucketed cuckoo index + PSRAM payloads)
-    const NodeInfoPayloadEntry *findNodeInfoEntry(NodeNum node) const;
-    NodeInfoPayloadEntry *findOrCreateNodeInfoEntry(NodeNum node, bool *usedEmptySlot);
-    uint16_t findNodeInfoPayloadIndex(NodeNum node) const;
-    bool removeNodeInfoIndexEntry(NodeNum node, uint16_t payloadIndex);
-    uint16_t allocateNodeInfoPayloadSlot();
-    uint16_t evictNodeInfoPayloadSlot();
-    bool tryInsertNodeInfoEntryInBucket(uint16_t bucket, uint16_t tag);
-    uint16_t encodeNodeInfoTag(uint16_t payloadIndex) const;
-    uint16_t decodeNodeInfoPayloadIndex(uint16_t tag) const;
-    uint16_t getNodeInfoTag(uint16_t slot) const;
-    void setNodeInfoTag(uint16_t slot, uint16_t tag);
-    uint16_t countNodeInfoEntriesLocked() const;
-    void cacheNodeInfoPacket(const meshtastic_MeshPacket &mp);
-
-    // =========================================================================
-    // Traffic Management Logic
-    // =========================================================================
-
-    bool shouldDropPosition(const meshtastic_MeshPacket *p, const meshtastic_Position *pos, uint32_t nowMs);
-    bool shouldRespondToNodeInfo(const meshtastic_MeshPacket *p, bool sendResponse);
-    bool isMinHopsFromRequestor(const meshtastic_MeshPacket *p) const;
-    bool isRateLimited(NodeNum from, uint32_t nowMs);
-    bool shouldDropUnknown(const meshtastic_MeshPacket *p, uint32_t nowMs);
-
-    void logAction(const char *action, const meshtastic_MeshPacket *p, const char *reason) const;
-    void incrementStat(uint32_t *field);
-};
-
-// =========================================================================
-// Compile-time Cache Size Calculations
-// =========================================================================
-//
-// Round TRAFFIC_MANAGEMENT_CACHE_SIZE up to next power of 2 for efficient
-// cuckoo hash indexing (allows bitmask instead of modulo).
-//
-// These use C++11-compatible constexpr (single return statement).
-//
-
-namespace detail
-{
-// Helper: round up to next power of 2 using bit manipulation
-constexpr uint16_t nextPow2(uint16_t n)
-{
-    return n == 0 ? 0 : (((n - 1) | ((n - 1) >> 1) | ((n - 1) >> 2) | ((n - 1) >> 4) | ((n - 1) >> 8)) + 1);
-}
-
-// Helper: floor(log2(n)) for n >= 0, C++11-compatible constexpr.
-constexpr uint8_t log2Floor(uint16_t n)
-{
-    return n <= 1 ? 0 : static_cast<uint8_t>(1 + log2Floor(static_cast<uint16_t>(n >> 1)));
-}
-
-// Helper: ceil(log2(n)) for n >= 1, C++11-compatible constexpr.
-constexpr uint8_t log2Ceil(uint16_t n)
-{
-    return n <= 1 ? 0 : static_cast<uint8_t>(1 + log2Floor(static_cast<uint16_t>(n - 1)));
-}
-} // namespace detail
-
-constexpr uint16_t TrafficManagementModule::cacheSize()
-{
-    return detail::nextPow2(TRAFFIC_MANAGEMENT_CACHE_SIZE);
-}
-
-constexpr uint16_t TrafficManagementModule::cacheMask()
-{
-    return cacheSize() > 0 ? cacheSize() - 1 : 0;
-}
-
-constexpr uint8_t TrafficManagementModule::cuckooHashBits()
-{
-    return detail::log2Floor(cacheSize());
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoTargetEntries()
-{
-    return kNodeInfoTargetEntries;
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoIndexMetadataBudgetBytes()
-{
-    return kNodeInfoIndexMetadataBudgetBytes;
-}
-
-constexpr uint8_t TrafficManagementModule::nodeInfoTargetOccupancyPercent()
-{
-    return kNodeInfoTargetOccupancyPercent;
-}
-
-constexpr uint8_t TrafficManagementModule::nodeInfoBucketSize()
-{
-    return kNodeInfoBucketSize;
-}
-
-constexpr uint8_t TrafficManagementModule::nodeInfoTagBits()
-{
-    return kNodeInfoTagBits;
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoTagMask()
-{
-    return kNodeInfoTagMask;
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoIndexSlots()
-{
-    return kNodeInfoIndexSlots;
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoBucketCount()
-{
-    return static_cast<uint16_t>(nodeInfoIndexSlots() / nodeInfoBucketSize());
-}
-
-constexpr uint16_t TrafficManagementModule::nodeInfoBucketMask()
-{
-    return nodeInfoBucketCount() > 0 ? nodeInfoBucketCount() - 1 : 0;
-}
-
-constexpr uint8_t TrafficManagementModule::nodeInfoBucketHashBits()
-{
-    return detail::log2Floor(nodeInfoBucketCount());
-}
-
-extern TrafficManagementModule *trafficManagementModule;
-
-#endif

src/modules/esp32/AudioModule.cpp

@@ -100,7 +100,7 @@ AudioModule::AudioModule() : SinglePortModule("Audio", meshtastic_PortNum_AUDIO_
     // moduleConfig.audio.i2s_sck = 14;
     // moduleConfig.audio.ptt_pin = 39;
 
-    if ((moduleConfig.audio.codec2_enabled) && (myRegion->profile->audioPermitted)) {
+    if ((moduleConfig.audio.codec2_enabled) && (myRegion->audioPermitted)) {
         LOG_INFO("Set up codec2 in mode %u", (moduleConfig.audio.bitrate ? moduleConfig.audio.bitrate : AUDIO_MODULE_MODE) - 1);
         codec2 = codec2_create((moduleConfig.audio.bitrate ? moduleConfig.audio.bitrate : AUDIO_MODULE_MODE) - 1);
         memcpy(tx_header.magic, c2_magic, sizeof(c2_magic));
@@ -143,7 +143,7 @@ void AudioModule::drawFrame(OLEDDisplay *display, OLEDDisplayUiState *state, int
 
 int32_t AudioModule::runOnce()
 {
-    if ((moduleConfig.audio.codec2_enabled) && (myRegion->profile->audioPermitted)) {
+    if ((moduleConfig.audio.codec2_enabled) && (myRegion->audioPermitted)) {
         esp_err_t res;
         if (firstTime) {
             // Set up I2S Processor configuration. This will produce 16bit samples at 8 kHz instead of 12 from the ADC
@@ -270,7 +270,7 @@ void AudioModule::sendPayload(NodeNum dest, bool wantReplies)
 
 ProcessMessage AudioModule::handleReceived(const meshtastic_MeshPacket &mp)
 {
-    if ((moduleConfig.audio.codec2_enabled) && (myRegion->profile->audioPermitted)) {
+    if ((moduleConfig.audio.codec2_enabled) && (myRegion->audioPermitted)) {
         auto &p = mp.decoded;
         if (!isFromUs(&mp)) {
             memcpy(rx_encode_frame, p.payload.bytes, p.payload.size);

src/mqtt/MQTT.cpp

@@ -322,8 +322,8 @@ bool connectPubSub(const PubSubConfig &config, PubSubClient &pubSub, Client &cli
     pubSub.setClient(client);
     pubSub.setServer(config.serverAddr.c_str(), config.serverPort);
 
-    LOG_INFO("Connecting directly to MQTT server %s, port: %d, username: %s, password: ***", config.serverAddr.c_str(),
-             config.serverPort, config.mqttUsername);
+    LOG_INFO("Connecting directly to MQTT server %s, port: %d, username: %s, password: %s", config.serverAddr.c_str(),
+             config.serverPort, config.mqttUsername, config.mqttPassword);
 
     // Generate node ID from nodenum for client identification
     std::string nodeId = nodeDB->getNodeId();

src/platform/esp32/main-esp32.cpp

@@ -1,7 +1,6 @@
 #include "PowerFSM.h"
 #include "PowerMon.h"
 #include "configuration.h"
-#include "esp_idf_version.h"
 #include "esp_task_wdt.h"
 #include "main.h"
 
@@ -127,12 +126,9 @@ void esp32Setup()
 
     nvs_stats_t nvs_stats;
     auto res = nvs_get_stats(NULL, &nvs_stats);
-    if (res != ESP_OK) {
-        LOG_WARN("nvs_get_stats failed: 0x%x", res);
-    } else {
-        LOG_DEBUG("NVS: UsedEntries %d, FreeEntries %d, AllEntries %d, NameSpaces %d", nvs_stats.used_entries,
-                  nvs_stats.free_entries, nvs_stats.total_entries, nvs_stats.namespace_count);
-    }
+    assert(res == ESP_OK);
+    LOG_DEBUG("NVS: UsedEntries %d, FreeEntries %d, AllEntries %d, NameSpaces %d", nvs_stats.used_entries, nvs_stats.free_entries,
+              nvs_stats.total_entries, nvs_stats.namespace_count);
 
     LOG_DEBUG("Setup Preferences in Flash Storage");
 
@@ -169,34 +165,18 @@ void esp32Setup()
 // #define APP_WATCHDOG_SECS 45
 #define APP_WATCHDOG_SECS 90
 
-#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
-    // IDF v5.x API: use esp_task_wdt_config_t for both init and reconfigure
-    {
-        esp_task_wdt_config_t wdt_config = {
-            .timeout_ms = APP_WATCHDOG_SECS * 1000,
-            .idle_core_mask = 0,
-            .trigger_panic = true,
-        };
-        // Try reconfigure first (TWDT may already be initialized by the Arduino framework)
-        res = esp_task_wdt_reconfigure(&wdt_config);
-        if (res == ESP_ERR_INVALID_STATE) {
-            // TWDT not yet initialized, initialize it now
-            res = esp_task_wdt_init(&wdt_config);
-        }
-        if (res != ESP_OK) {
-            LOG_WARN("Failed to (re)configure watchdog timer: 0x%x", res);
-        }
-    }
+#ifdef CONFIG_IDF_TARGET_ESP32C6
+    esp_task_wdt_config_t *wdt_config = (esp_task_wdt_config_t *)malloc(sizeof(esp_task_wdt_config_t));
+    wdt_config->timeout_ms = APP_WATCHDOG_SECS * 1000;
+    wdt_config->trigger_panic = true;
+    res = esp_task_wdt_init(wdt_config);
+    assert(res == ESP_OK);
 #else
     res = esp_task_wdt_init(APP_WATCHDOG_SECS, true);
-    if (res != ESP_OK) {
-        LOG_WARN("Failed to initialize watchdog timer: 0x%x", res);
-    }
+    assert(res == ESP_OK);
 #endif
     res = esp_task_wdt_add(NULL);
-    if (res != ESP_OK && res != ESP_ERR_INVALID_ARG) {
-        LOG_WARN("Failed to add main task to watchdog: 0x%x", res);
-    }
+    assert(res == ESP_OK);
 
 #if HAS_32768HZ
     enableSlowCLK();

src/platform/nrf52/main-nrf52.cpp

@@ -17,7 +17,6 @@
 #include <nrfx_wdt.h>
 #include <stdio.h>
 // #include <Adafruit_USBD_Device.h>
-#include "HardwareRNG.h"
 #include "NodeDB.h"
 #include "PowerMon.h"
 #include "error.h"
@@ -399,14 +398,15 @@ void nrf52Setup()
 #endif
 
     // Init random seed
-    uint32_t seed = 0;
-    if (!HardwareRNG::seed(seed)) {
-        LOG_WARN("Hardware RNG seed unavailable, using PRNG fallback");
-        // Use a hardware timer value as a fallback seed for better entropy
-        seed = micros();
-    }
-    LOG_DEBUG("Set random seed %u", seed);
-    randomSeed(seed);
+    union seedParts {
+        uint32_t seed32;
+        uint8_t seed8[4];
+    } seed;
+    nRFCrypto.begin();
+    nRFCrypto.Random.generate(seed.seed8, sizeof(seed.seed8));
+    LOG_DEBUG("Set random seed %u", seed.seed32);
+    randomSeed(seed.seed32);
+    nRFCrypto.end();
 
     // Set up nrfx watchdog. Do not enable the watchdog yet (we do that
     // the first time through the main loop), so that other threads can
@@ -497,6 +497,9 @@ void cpuDeepSleep(uint32_t msecToWake)
             ;
 #endif
 
+#ifdef POWER_ON_OFF
+        digitalWrite(POWER_ON_OFF, HIGH);
+#endif
         auto ok = sd_power_system_off();
         if (ok != NRF_SUCCESS) {
             LOG_ERROR("FIXME: Ignoring soft device (EasyDMA pending?) and forcing system-off!");

src/platform/portduino/PortduinoGlue.cpp

@@ -1,5 +1,4 @@
 #include "CryptoEngine.h"
-#include "HardwareRNG.h"
 #include "PortduinoGPIO.h"
 #include "SPIChip.h"
 #include "mesh/RF95Interface.h"
@@ -182,10 +181,6 @@ void portduinoSetup()
     // Force stdout to be line buffered
     setvbuf(stdout, stdoutBuffer, _IOLBF, sizeof(stdoutBuffer));
 
-    // We do this super early so that we can log from the rest of the init code
-    concurrency::hasBeenSetup = true;
-    consoleInit();
-
     if (portduino_config.force_simradio == true) {
         portduino_config.lora_module = use_simradio;
     } else if (configPath != nullptr) {
@@ -238,9 +233,7 @@ void portduinoSetup()
         std::cout << "Running in simulated mode." << std::endl;
         portduino_config.MaxNodes = 200; // Default to 200 nodes
         // Set the random seed equal to TCPPort to have a different seed per instance
-        uint32_t seed = TCPPort;
-        HardwareRNG::seed(seed);
-        randomSeed(seed);
+        randomSeed(TCPPort);
         return;
     }
 
@@ -519,9 +512,7 @@ void portduinoSetup()
 #endif
     printf("MAC ADDRESS: %02X:%02X:%02X:%02X:%02X:%02X\n", dmac[0], dmac[1], dmac[2], dmac[3], dmac[4], dmac[5]);
     // Rather important to set this, if not running simulated.
-    uint32_t seed = static_cast<uint32_t>(time(NULL));
-    HardwareRNG::seed(seed);
-    randomSeed(seed);
+    randomSeed(time(NULL));
 
     std::string defaultGpioChipName = gpioChipName + std::to_string(portduino_config.lora_default_gpiochip);
 
@@ -654,9 +645,7 @@ void portduinoSetup()
     if (verboseEnabled && portduino_config.logoutputlevel != level_trace) {
         portduino_config.logoutputlevel = level_debug;
     }
-    if (portduino_config.lora_spi_dev != "") {
-        portduinoSetOptions({.realHardware = true});
-    }
+
     return;
 }
 

src/platform/rp2xx0/main-rp2xx0.cpp

@@ -1,4 +1,3 @@
-#include "HardwareRNG.h"
 #include "configuration.h"
 #include "hardware/xosc.h"
 #include <hardware/clocks.h>
@@ -99,12 +98,10 @@ void getMacAddr(uint8_t *dmac)
 
 void rp2040Setup()
 {
-    /* Sets a random seed to make sure we get different random numbers on each boot. */
-    uint32_t seed = 0;
-    if (!HardwareRNG::seed(seed)) {
-        seed = rp2040.hwrand32();
-    }
-    randomSeed(seed);
+    /* Sets a random seed to make sure we get different random numbers on each boot.
+       Taken from CPU cycle counter and ROSC oscillator, so should be pretty random.
+    */
+    randomSeed(rp2040.hwrand32());
 
 #ifdef RP2040_SLOW_CLOCK
     uint f_pll_sys = frequency_count_khz(CLOCKS_FC0_SRC_VALUE_PLL_SYS_CLKSRC_PRIMARY);

src/platform/stm32wl/hardfault_handler.s

@@ -1,11 +0,0 @@
-.globl HardFault_Handler
-.syntax unified
-.thumb
-
-.type HardFault_Handler, %function
-HardFault_Handler:
-tst lr, #4
-ite eq
-mrseq r0, msp
-mrsne r0, psp
-b HardFault_Handler_C

src/platform/stm32wl/main-stm32wl.cpp

@@ -1,60 +1,8 @@
 #include "RTC.h"
 #include "configuration.h"
-#include <stdarg.h>
 #include <stm32wle5xx.h>
 #include <stm32wlxx_hal.h>
 
-// ─── Bootloader redirect ──────────────────────────────────────────────────────
-//
-// Why .noinit + constructor instead of TAMP backup registers:
-//
-//   The STM32duino startup sequence initialises clocks which may call
-//   __HAL_RCC_BACKUPRESET_FORCE/RELEASE when configuring the LSE oscillator,
-//   wiping the entire backup domain (including TAMP->BKP0R) before setup()
-//   ever runs. The backup-register approach therefore cannot reliably survive
-//   a soft reset in this toolchain.
-//
-//   Solution: store the magic in a .noinit SRAM variable.
-//   - NVIC_SystemReset() does NOT clear SRAM.
-//   - The linker script skips zero-init for .noinit sections.
-//   - __attribute__((constructor)) fires before main()/HAL_Init(), so we can
-//     intercept and jump before anything disturbs peripheral state.
-
-#define BOOTLOADER_MAGIC 0xD00DB007UL
-#define SYS_MEM_BASE 0x1FFF0000UL
-
-// Placed in .noinit — not zeroed at startup, survives NVIC_SystemReset().
-__attribute__((section(".noinit"), used)) volatile uint32_t g_bootloaderMagic;
-
-// Fires before main() / HAL_Init(). Must use only core Cortex-M registers.
-__attribute__((constructor(101), used)) static void earlyBootCheck(void)
-{
-    if (g_bootloaderMagic != BOOTLOADER_MAGIC)
-        return;
-    g_bootloaderMagic = 0;
-
-    SysTick->CTRL = 0;
-    SysTick->LOAD = 0;
-    SysTick->VAL = 0;
-    for (int i = 0; i < 8; i++) {
-        NVIC->ICER[i] = 0xFFFFFFFF;
-        NVIC->ICPR[i] = 0xFFFFFFFF;
-    }
-    __DSB();
-    __ISB();
-    SCB->VTOR = SYS_MEM_BASE;
-    __set_MSP(*(volatile uint32_t *)SYS_MEM_BASE);
-    ((void (*)(void))(*(volatile uint32_t *)(SYS_MEM_BASE + 4)))();
-    while (1)
-        ;
-}
-
-void enterDfuMode()
-{
-    g_bootloaderMagic = BOOTLOADER_MAGIC;
-    HAL_NVIC_SystemReset();
-}
-
 void setBluetoothEnable(bool enable) {}
 
 void playStartMelody() {}
@@ -105,99 +53,4 @@ extern "C" void __wrap__tzset_unlocked_r(struct _reent *reent_ptr)
 {
     return;
 }
-#endif
-
-// Taken from https://interrupt.memfault.com/blog/cortex-m-hardfault-debug
-typedef struct __attribute__((packed)) ContextStateFrame {
-    uint32_t r0;
-    uint32_t r1;
-    uint32_t r2;
-    uint32_t r3;
-    uint32_t r12;
-    uint32_t lr;
-    uint32_t return_address;
-    uint32_t xpsr;
-} sContextStateFrame;
-
-// NOTE: If you are using CMSIS, the registers can also be
-// accessed through CoreDebug->DHCSR & CoreDebug_DHCSR_C_DEBUGEN_Msk
-#define HALT_IF_DEBUGGING()                                                                                                      \
-    do {                                                                                                                         \
-        if ((*(volatile uint32_t *)0xE000EDF0) & (1 << 0)) {                                                                     \
-            __asm("bkpt 1");                                                                                                     \
-        }                                                                                                                        \
-    } while (0)
-
-static char hardfault_message_buffer[256];
-
-// printf directly using srcwrapper's debug UART function.
-static void debug_printf(const char *format, ...)
-{
-    va_list args;
-    va_start(args, format);
-    int length = vsnprintf(hardfault_message_buffer, sizeof(hardfault_message_buffer), format, args);
-    va_end(args);
-
-    if (length < 0)
-        return;
-    uart_debug_write((uint8_t *)hardfault_message_buffer, min((unsigned int)length, sizeof(hardfault_message_buffer) - 1));
-}
-
-// N picked by guessing
-#define DOT_TIME 1200000
-static void dot()
-{
-    digitalWrite(LED_POWER, LED_STATE_ON);
-    for (volatile int i = 0; i < DOT_TIME; i++) { /* busy wait */
-    }
-    digitalWrite(LED_POWER, LED_STATE_OFF);
-    for (volatile int i = 0; i < DOT_TIME; i++) { /* busy wait */
-    }
-}
-
-static void dash()
-{
-    digitalWrite(LED_POWER, LED_STATE_ON);
-    for (volatile int i = 0; i < (DOT_TIME * 3); i++) { /* busy wait */
-    }
-    digitalWrite(LED_POWER, LED_STATE_OFF);
-    for (volatile int i = 0; i < DOT_TIME; i++) { /* busy wait */
-    }
-}
-
-static void space()
-{
-    for (volatile int i = 0; i < (DOT_TIME * 3); i++) { /* busy wait */
-    }
-}
-
-// Disable optimizations for this function so "frame" argument
-// does not get optimized away
-extern "C" __attribute__((optimize("O0"))) void HardFault_Handler_C(sContextStateFrame *frame)
-{
-    debug_printf("HardFault!\r\n");
-    debug_printf("r0: %08x\r\n", frame->r0);
-    debug_printf("r1: %08x\r\n", frame->r1);
-    debug_printf("r2: %08x\r\n", frame->r2);
-    debug_printf("r3: %08x\r\n", frame->r3);
-    debug_printf("r12: %08x\r\n", frame->r12);
-    debug_printf("lr: %08x\r\n", frame->lr);
-    debug_printf("pc[return address]: %08x\r\n", frame->return_address);
-    debug_printf("xpsr: %08x\r\n", frame->xpsr);
-
-    HALT_IF_DEBUGGING();
-
-    // blink SOS forever
-    while (1) {
-        dot();
-        dot();
-        dot();
-        dash();
-        dash();
-        dash();
-        dot();
-        dot();
-        dot();
-        space();
-    }
-}
+#endif

src/power.h

@@ -15,13 +15,8 @@
 
 // Device specific curves go in variant.h
 #ifndef OCV_ARRAY
-#if defined(ARCH_STM32WL) && BATTERY_PIN == AVBAT
-// STM32 VDD/VBAT absolute maximum is 4V so use an LFP curve
-#define OCV_ARRAY 3650, 3400, 3340, 3320, 3300, 3280, 3270, 3260, 3240, 3200, 2500
-#else
 #define OCV_ARRAY 4190, 4050, 3990, 3890, 3800, 3720, 3630, 3530, 3420, 3300, 3100
 #endif
-#endif
 
 /*Note: 12V lead acid is 6 cells, most board accept only 1 cell LiIon/LiPo*/
 #ifndef NUM_CELLS

test/test_admin_radio/test_main.cpp

@@ -1,814 +0,0 @@
-/**
- * Tests for the radio configuration validation and clamping functions
- * introduced in the radio_interface_cherrypick branch.
- *
- * Targets:
- *  1. getRegion()
- *  2. RadioInterface::validateConfigRegion()
- *  3. RadioInterface::validateConfigLora()
- *  4. RadioInterface::clampConfigLora()
- *  5. RegionInfo preset lists (PRESETS_STD, PRESETS_EU_868, PRESETS_UNDEF)
- *  6. Channel spacing calculation (placeholder for future protobuf changes)
- */
-
-#include "MeshRadio.h"
-#include "MeshService.h"
-#include "NodeDB.h"
-#include "RadioInterface.h"
-#include "TestUtil.h"
-#include "modules/AdminModule.h"
-#include <unity.h>
-
-#include "meshtastic/config.pb.h"
-
-class MockMeshService : public MeshService
-{
-  public:
-    void sendClientNotification(meshtastic_ClientNotification *n) override { releaseClientNotificationToPool(n); }
-};
-
-static MockMeshService *mockMeshService;
-
-// -----------------------------------------------------------------------
-// getRegion() tests
-// -----------------------------------------------------------------------
-extern const RegionInfo *getRegion(meshtastic_Config_LoRaConfig_RegionCode code);
-
-static void test_getRegion_returnsCorrectRegion_US()
-{
-    const RegionInfo *r = getRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
-    TEST_ASSERT_NOT_NULL(r);
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_RegionCode_US, r->code);
-    TEST_ASSERT_EQUAL_STRING("US", r->name);
-}
-
-static void test_getRegion_returnsCorrectRegion_EU868()
-{
-    const RegionInfo *r = getRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_868);
-    TEST_ASSERT_NOT_NULL(r);
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_RegionCode_EU_868, r->code);
-    TEST_ASSERT_EQUAL_STRING("EU_868", r->name);
-}
-
-static void test_getRegion_returnsCorrectRegion_LORA24()
-{
-    const RegionInfo *r = getRegion(meshtastic_Config_LoRaConfig_RegionCode_LORA_24);
-    TEST_ASSERT_NOT_NULL(r);
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_RegionCode_LORA_24, r->code);
-    TEST_ASSERT_TRUE(r->wideLora);
-}
-
-static void test_getRegion_unsetCodeReturnsUnsetEntry()
-{
-    const RegionInfo *r = getRegion(meshtastic_Config_LoRaConfig_RegionCode_UNSET);
-    TEST_ASSERT_NOT_NULL(r);
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_RegionCode_UNSET, r->code);
-    TEST_ASSERT_EQUAL_STRING("UNSET", r->name);
-}
-
-static void test_getRegion_unknownCodeFallsToUnset()
-{
-    // A code not in the table should iterate to the UNSET sentinel
-    const RegionInfo *r = getRegion((meshtastic_Config_LoRaConfig_RegionCode)255);
-    TEST_ASSERT_NOT_NULL(r);
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_RegionCode_UNSET, r->code);
-}
-
-// -----------------------------------------------------------------------
-// validateConfigRegion() tests
-// -----------------------------------------------------------------------
-
-static void test_validateConfigRegion_validRegionReturnsTrue()
-{
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-
-    // Ensure owner is not licensed (should not matter for non-licensed-only regions)
-    devicestate.owner.is_licensed = false;
-
-    TEST_ASSERT_TRUE(RadioInterface::validateConfigRegion(cfg));
-}
-
-static void test_validateConfigRegion_unsetRegionReturnsTrue()
-{
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_UNSET;
-
-    devicestate.owner.is_licensed = false;
-
-    // UNSET region has licensedOnly=false, so should pass
-    TEST_ASSERT_TRUE(RadioInterface::validateConfigRegion(cfg));
-}
-
-// -----------------------------------------------------------------------
-// Shadow tables for testing (preset lists → profiles → regions → lookup)
-// -----------------------------------------------------------------------
-
-// A minimal preset list with only one entry
-static const meshtastic_Config_LoRaConfig_ModemPreset TEST_PRESETS_SINGLE[] = {
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,
-    MODEM_PRESET_END,
-};
-
-// A preset list that includes all turbo variants only
-static const meshtastic_Config_LoRaConfig_ModemPreset TEST_PRESETS_TURBO_ONLY[] = {
-    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO,
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO,
-    MODEM_PRESET_END,
-};
-
-// A restricted list simulating a hypothetical tight-regulation region
-static const meshtastic_Config_LoRaConfig_ModemPreset TEST_PRESETS_RESTRICTED[] = {
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW,
-    meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE,
-    MODEM_PRESET_END,
-};
-
-// Mirrors PROFILE_STD but with non-zero spacing/padding for testing
-static const RegionProfile TEST_PROFILE_SPACED = {
-    TEST_PRESETS_SINGLE,
-    /* spacing */ 0.025f,
-    /* padding */ 0.010f,
-    /* audioPermitted */ true,
-    /* licensedOnly */ false,
-    /* textThrottle */ 0,
-    /* positionThrottle */ 0,
-    /* telemetryThrottle */ 0,
-    /* overrideSlot */ 0,
-};
-
-// A licensed-only profile for testing access control
-static const RegionProfile TEST_PROFILE_LICENSED = {
-    TEST_PRESETS_RESTRICTED,
-    /* spacing */ 0.0f,
-    /* padding */ 0.0f,
-    /* audioPermitted */ false,
-    /* licensedOnly */ true,
-    /* textThrottle */ 5,
-    /* positionThrottle */ 10,
-    /* telemetryThrottle */ 10,
-    /* overrideSlot */ 3,
-};
-
-// Turbo-only profile
-static const RegionProfile TEST_PROFILE_TURBO = {
-    TEST_PRESETS_TURBO_ONLY,
-    /* spacing */ 0.0f,
-    /* padding */ 0.0f,
-    /* audioPermitted */ true,
-    /* licensedOnly */ false,
-    /* textThrottle */ 0,
-    /* positionThrottle */ 0,
-    /* telemetryThrottle */ 0,
-    /* overrideSlot */ 0,
-};
-
-static const RegionInfo testRegions[] = {
-    // A wide US-like region with spacing + padding
-    {meshtastic_Config_LoRaConfig_RegionCode_US, 902.0f, 928.0f, 100, 30, false, false, &TEST_PROFILE_SPACED, "TEST_US_SPACED"},
-
-    // A narrow band simulating tight EU regulation
-    {meshtastic_Config_LoRaConfig_RegionCode_EU_868, 869.4f, 869.65f, 10, 14, false, false, &TEST_PROFILE_LICENSED,
-     "TEST_EU_LICENSED"},
-
-    // A wide-LoRa region with turbo-only presets
-    {meshtastic_Config_LoRaConfig_RegionCode_LORA_24, 2400.0f, 2483.5f, 100, 10, false, true, &TEST_PROFILE_TURBO,
-     "TEST_LORA24_TURBO"},
-
-    // Sentinel — must be last
-    {meshtastic_Config_LoRaConfig_RegionCode_UNSET, 902.0f, 928.0f, 100, 30, false, false, &TEST_PROFILE_SPACED, "TEST_UNSET"},
-};
-
-static const RegionInfo *getTestRegion(meshtastic_Config_LoRaConfig_RegionCode code)
-{
-    const RegionInfo *r = testRegions;
-    while (r->code != meshtastic_Config_LoRaConfig_RegionCode_UNSET) {
-        if (r->code == code)
-            return r;
-        r++;
-    }
-    return r; // Returns the UNSET sentinel
-}
-
-// -----------------------------------------------------------------------
-// Shadow table tests
-// -----------------------------------------------------------------------
-
-static void test_shadowTable_spacedProfileHasNonZeroSpacing()
-{
-    const RegionInfo *r = getTestRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
-    TEST_ASSERT_EQUAL_STRING("TEST_US_SPACED", r->name);
-    TEST_ASSERT_FLOAT_WITHIN(0.001f, 0.025f, r->profile->spacing);
-    TEST_ASSERT_FLOAT_WITHIN(0.001f, 0.010f, r->profile->padding);
-}
-
-static void test_shadowTable_licensedProfileFlagsCorrect()
-{
-    const RegionInfo *r = getTestRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_868);
-    TEST_ASSERT_TRUE(r->profile->licensedOnly);
-    TEST_ASSERT_FALSE(r->profile->audioPermitted);
-    TEST_ASSERT_EQUAL(3, r->profile->overrideSlot);
-}
-
-static void test_shadowTable_presetCountMatchesExpected()
-{
-    const RegionInfo *spaced = getTestRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
-    TEST_ASSERT_EQUAL(1, spaced->getNumPresets());
-
-    const RegionInfo *licensed = getTestRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_868);
-    TEST_ASSERT_EQUAL(2, licensed->getNumPresets());
-
-    const RegionInfo *turbo = getTestRegion(meshtastic_Config_LoRaConfig_RegionCode_LORA_24);
-    TEST_ASSERT_EQUAL(2, turbo->getNumPresets());
-}
-
-static void test_shadowTable_defaultPresetIsFirstInList()
-{
-    const RegionInfo *spaced = getTestRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, spaced->getDefaultPreset());
-
-    const RegionInfo *licensed = getTestRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_868);
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW, licensed->getDefaultPreset());
-
-    const RegionInfo *turbo = getTestRegion(meshtastic_Config_LoRaConfig_RegionCode_LORA_24);
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO, turbo->getDefaultPreset());
-}
-
-static void test_shadowTable_channelSpacingWithPadding()
-{
-    // Verify channel count when spacing + padding are non-zero
-    const RegionInfo *r = getTestRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
-    float bw = modemPresetToBwKHz(r->getDefaultPreset(), r->wideLora);
-    float channelSpacing = r->profile->spacing + (r->profile->padding * 2) + (bw / 1000.0f);
-
-    // spacing=0.025, padding=0.010*2=0.020, bw=250kHz=0.250
-    // channelSpacing = 0.025 + 0.020 + 0.250 = 0.295 MHz
-    TEST_ASSERT_FLOAT_WITHIN(0.001f, 0.295f, channelSpacing);
-
-    uint32_t numChannels = (uint32_t)(((r->freqEnd - r->freqStart + r->profile->spacing) / channelSpacing) + 0.5f);
-    // (928 - 902 + 0.025) / 0.295 = 88.2 → 88
-    TEST_ASSERT_EQUAL_UINT32(88, numChannels);
-}
-
-static void test_shadowTable_turboOnlyOnWideLora()
-{
-    const RegionInfo *r = getTestRegion(meshtastic_Config_LoRaConfig_RegionCode_LORA_24);
-    TEST_ASSERT_TRUE(r->wideLora);
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO, r->getDefaultPreset());
-
-    // Verify wide-LoRa bandwidth for SHORT_TURBO
-    float bw = modemPresetToBwKHz(r->getDefaultPreset(), r->wideLora);
-    TEST_ASSERT_FLOAT_WITHIN(0.1f, 1625.0f, bw); // 1625 kHz in wide mode
-}
-
-static void test_shadowTable_unknownCodeFallsToSentinel()
-{
-    const RegionInfo *r = getTestRegion((meshtastic_Config_LoRaConfig_RegionCode)200);
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_RegionCode_UNSET, r->code);
-    TEST_ASSERT_EQUAL_STRING("TEST_UNSET", r->name);
-}
-
-// -----------------------------------------------------------------------
-// validateConfigLora() tests
-// -----------------------------------------------------------------------
-
-static void test_validateConfigLora_validPresetForUS()
-{
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    cfg.use_preset = true;
-    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
-
-    TEST_ASSERT_TRUE(RadioInterface::validateConfigLora(cfg));
-}
-
-static void test_validateConfigLora_allStdPresetsValidForUS()
-{
-    meshtastic_Config_LoRaConfig_ModemPreset stdPresets[] = {
-        meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,     meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW,
-        meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW,   meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST,
-        meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW,    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST,
-        meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE, meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO,
-        meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO,
-    };
-
-    for (size_t i = 0; i < sizeof(stdPresets) / sizeof(stdPresets[0]); i++) {
-        meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-        cfg.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-        cfg.use_preset = true;
-        cfg.modem_preset = stdPresets[i];
-        TEST_ASSERT_TRUE_MESSAGE(RadioInterface::validateConfigLora(cfg), "Expected valid preset for US");
-    }
-}
-
-static void test_validateConfigLora_turboPresetsInvalidForEU868()
-{
-    // EU_868 has PRESETS_EU_868 which excludes SHORT_TURBO and LONG_TURBO
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
-    cfg.use_preset = true;
-
-    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO;
-    TEST_ASSERT_FALSE_MESSAGE(RadioInterface::validateConfigLora(cfg), "SHORT_TURBO should be invalid for EU_868");
-
-    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO;
-    TEST_ASSERT_FALSE_MESSAGE(RadioInterface::validateConfigLora(cfg), "LONG_TURBO should be invalid for EU_868");
-}
-
-static void test_validateConfigLora_validPresetsForEU868()
-{
-    meshtastic_Config_LoRaConfig_ModemPreset eu868Presets[] = {
-        meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,     meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW,
-        meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW,   meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST,
-        meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW,    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST,
-        meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE,
-    };
-
-    for (size_t i = 0; i < sizeof(eu868Presets) / sizeof(eu868Presets[0]); i++) {
-        meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-        cfg.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
-        cfg.use_preset = true;
-        cfg.modem_preset = eu868Presets[i];
-        TEST_ASSERT_TRUE_MESSAGE(RadioInterface::validateConfigLora(cfg), "Expected valid preset for EU_868");
-    }
-}
-
-static void test_validateConfigLora_customBandwidthTooWideForEU868()
-{
-    // EU_868 spans 869.4 - 869.65 = 0.25 MHz = 250 kHz
-    // A 500 kHz custom BW should be rejected
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
-    cfg.use_preset = false;
-    cfg.bandwidth = 500;
-    cfg.spread_factor = 11;
-    cfg.coding_rate = 5;
-
-    TEST_ASSERT_FALSE(RadioInterface::validateConfigLora(cfg));
-}
-
-static void test_validateConfigLora_customBandwidthFitsUS()
-{
-    // US spans 902 - 928 = 26 MHz, so 250 kHz BW fits easily
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    cfg.use_preset = false;
-    cfg.bandwidth = 250;
-    cfg.spread_factor = 11;
-    cfg.coding_rate = 5;
-
-    TEST_ASSERT_TRUE(RadioInterface::validateConfigLora(cfg));
-}
-
-static void test_validateConfigLora_customBandwidthFitsEU868()
-{
-    // EU_868 spans 250 kHz, 125 kHz BW should fit
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
-    cfg.use_preset = false;
-    cfg.bandwidth = 125;
-    cfg.spread_factor = 12;
-    cfg.coding_rate = 8;
-
-    TEST_ASSERT_TRUE(RadioInterface::validateConfigLora(cfg));
-}
-
-static void test_validateConfigLora_bogusPresetRejected()
-{
-    // A fabricated preset value not in any list should be rejected
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    cfg.use_preset = true;
-    cfg.modem_preset = (meshtastic_Config_LoRaConfig_ModemPreset)99;
-
-    TEST_ASSERT_FALSE(RadioInterface::validateConfigLora(cfg));
-}
-
-static void test_validateConfigLora_unsetRegionOnlyAcceptsLongFast()
-{
-    // UNSET uses PROFILE_UNDEF which has only LONG_FAST
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_UNSET;
-    cfg.use_preset = true;
-
-    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
-    TEST_ASSERT_TRUE_MESSAGE(RadioInterface::validateConfigLora(cfg), "LONG_FAST should be valid for UNSET");
-
-    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST;
-    TEST_ASSERT_FALSE_MESSAGE(RadioInterface::validateConfigLora(cfg), "MEDIUM_FAST should be invalid for UNSET");
-
-    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO;
-    TEST_ASSERT_FALSE_MESSAGE(RadioInterface::validateConfigLora(cfg), "SHORT_TURBO should be invalid for UNSET");
-}
-
-static void test_validateConfigLora_allPresetsValidForLORA24()
-{
-    // LORA_24 uses PROFILE_STD (9 presets) with wideLora=true
-    meshtastic_Config_LoRaConfig_ModemPreset stdPresets[] = {
-        meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST,     meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW,
-        meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_SLOW,   meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST,
-        meshtastic_Config_LoRaConfig_ModemPreset_SHORT_SLOW,    meshtastic_Config_LoRaConfig_ModemPreset_SHORT_FAST,
-        meshtastic_Config_LoRaConfig_ModemPreset_LONG_MODERATE, meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO,
-        meshtastic_Config_LoRaConfig_ModemPreset_LONG_TURBO,
-    };
-
-    for (size_t i = 0; i < sizeof(stdPresets) / sizeof(stdPresets[0]); i++) {
-        meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-        cfg.region = meshtastic_Config_LoRaConfig_RegionCode_LORA_24;
-        cfg.use_preset = true;
-        cfg.modem_preset = stdPresets[i];
-        TEST_ASSERT_TRUE_MESSAGE(RadioInterface::validateConfigLora(cfg), "Expected valid preset for LORA_24");
-    }
-}
-
-// -----------------------------------------------------------------------
-// clampConfigLora() tests
-// -----------------------------------------------------------------------
-
-static void test_clampConfigLora_invalidPresetClampedToDefault()
-{
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
-    cfg.use_preset = true;
-    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO; // not in EU_868 preset list
-
-    RadioInterface::clampConfigLora(cfg);
-
-    const RegionInfo *eu868 = getRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_868);
-    TEST_ASSERT_EQUAL(eu868->getDefaultPreset(), cfg.modem_preset);
-}
-
-static void test_clampConfigLora_validPresetUnchanged()
-{
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    cfg.use_preset = true;
-    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST;
-
-    RadioInterface::clampConfigLora(cfg);
-
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST, cfg.modem_preset);
-}
-
-static void test_clampConfigLora_customBwTooWideClampedToDefaultBw()
-{
-    // EU_868 span is 250kHz. A 500kHz custom BW should be clamped to default preset BW.
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
-    cfg.use_preset = false;
-    cfg.bandwidth = 500;
-    cfg.spread_factor = 11;
-    cfg.coding_rate = 5;
-
-    RadioInterface::clampConfigLora(cfg);
-
-    const RegionInfo *eu868 = getRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_868);
-    float expectedBw = modemPresetToBwKHz(eu868->getDefaultPreset(), eu868->wideLora);
-    TEST_ASSERT_FLOAT_WITHIN(0.01f, expectedBw, (float)cfg.bandwidth);
-}
-
-static void test_clampConfigLora_customBwValidLeftUnchanged()
-{
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    cfg.use_preset = false;
-    cfg.bandwidth = 125;
-    cfg.spread_factor = 12;
-    cfg.coding_rate = 8;
-
-    RadioInterface::clampConfigLora(cfg);
-
-    TEST_ASSERT_EQUAL_UINT16(125, cfg.bandwidth);
-}
-
-static void test_clampConfigLora_bogusPresetOnUnsetClampedToLongFast()
-{
-    // UNSET uses PROFILE_UNDEF with only LONG_FAST; any other preset should clamp to it
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_UNSET;
-    cfg.use_preset = true;
-    cfg.modem_preset = (meshtastic_Config_LoRaConfig_ModemPreset)99;
-
-    RadioInterface::clampConfigLora(cfg);
-
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, cfg.modem_preset);
-}
-
-static void test_clampConfigLora_invalidPresetOnLORA24ClampedToDefault()
-{
-    // LORA_24 uses PROFILE_STD; a bogus preset should clamp to LONG_FAST (first in PRESETS_STD)
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_LORA_24;
-    cfg.use_preset = true;
-    cfg.modem_preset = (meshtastic_Config_LoRaConfig_ModemPreset)99;
-
-    RadioInterface::clampConfigLora(cfg);
-
-    const RegionInfo *lora24 = getRegion(meshtastic_Config_LoRaConfig_RegionCode_LORA_24);
-    TEST_ASSERT_EQUAL(lora24->getDefaultPreset(), cfg.modem_preset);
-}
-
-// -----------------------------------------------------------------------
-// RegionInfo preset list integrity tests
-// -----------------------------------------------------------------------
-
-static void test_presetsStd_hasNineEntries()
-{
-    // PROFILE_STD should have exactly 9 presets
-    const RegionInfo *us = getRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
-    TEST_ASSERT_EQUAL(9, us->getNumPresets());
-    TEST_ASSERT_EQUAL_PTR(PROFILE_STD.presets, us->getAvailablePresets());
-}
-
-static void test_presetsEU868_hasSevenEntries()
-{
-    const RegionInfo *eu = getRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_868);
-    TEST_ASSERT_EQUAL(7, eu->getNumPresets());
-    TEST_ASSERT_EQUAL_PTR(PROFILE_EU868.presets, eu->getAvailablePresets());
-}
-
-static void test_presetsUndef_hasOneEntry()
-{
-    const RegionInfo *unset = getRegion(meshtastic_Config_LoRaConfig_RegionCode_UNSET);
-    TEST_ASSERT_EQUAL(1, unset->getNumPresets());
-    TEST_ASSERT_EQUAL_PTR(PROFILE_UNDEF.presets, unset->getAvailablePresets());
-}
-
-static void test_defaultPresetIsInAvailablePresets()
-{
-    // For every region, the defaultPreset must appear in its own availablePresets list
-    const RegionInfo *r = regions;
-    while (true) {
-        bool found = false;
-        for (size_t i = 0; i < r->getNumPresets(); i++) {
-            if (r->getAvailablePresets()[i] == r->getDefaultPreset()) {
-                found = true;
-                break;
-            }
-        }
-        char msg[80];
-        snprintf(msg, sizeof(msg), "Region %s defaultPreset not in availablePresets", r->name);
-        TEST_ASSERT_TRUE_MESSAGE(found, msg);
-
-        if (r->code == meshtastic_Config_LoRaConfig_RegionCode_UNSET)
-            break; // UNSET is the sentinel, stop after it
-        r++;
-    }
-}
-
-static void test_regionFieldsAreSane()
-{
-    // Basic sanity check: all regions have freqEnd > freqStart and a non-null name
-    const RegionInfo *r = regions;
-    while (true) {
-        char msg[80];
-        snprintf(msg, sizeof(msg), "Region %s: freqEnd must be > freqStart", r->name);
-        TEST_ASSERT_TRUE_MESSAGE(r->freqEnd > r->freqStart, msg);
-        TEST_ASSERT_NOT_NULL(r->name);
-        TEST_ASSERT_TRUE_MESSAGE(r->getNumPresets() > 0, "numPresets must be > 0");
-        TEST_ASSERT_NOT_NULL(r->getAvailablePresets());
-
-        if (r->code == meshtastic_Config_LoRaConfig_RegionCode_UNSET)
-            break;
-        r++;
-    }
-}
-
-static void test_onlyLORA24HasWideLora()
-{
-    // Verify that LORA_24 is the only region with wideLora=true
-    const RegionInfo *r = regions;
-    while (true) {
-        char msg[80];
-        if (r->code == meshtastic_Config_LoRaConfig_RegionCode_LORA_24) {
-            snprintf(msg, sizeof(msg), "Region %s should have wideLora=true", r->name);
-            TEST_ASSERT_TRUE_MESSAGE(r->wideLora, msg);
-        } else {
-            snprintf(msg, sizeof(msg), "Region %s should have wideLora=false", r->name);
-            TEST_ASSERT_FALSE_MESSAGE(r->wideLora, msg);
-        }
-
-        if (r->code == meshtastic_Config_LoRaConfig_RegionCode_UNSET)
-            break;
-        r++;
-    }
-}
-
-// -----------------------------------------------------------------------
-// Channel spacing calculation (placeholder for future protobuf updates)
-// -----------------------------------------------------------------------
-
-static void test_channelSpacingCalculation_US_LONG_FAST()
-{
-    // Current formula: channelSpacing = spacing + (padding * 2) + (bw / 1000)
-    // US: spacing=0, padding=0
-    // LONG_FAST on non-wide region: bw=250 kHz
-    // channelSpacing = 0 + 0 + 0.250 = 0.250 MHz
-    // numChannels = round((928 - 902 + 0) / 0.250) = round(104) = 104
-    const RegionInfo *us = getRegion(meshtastic_Config_LoRaConfig_RegionCode_US);
-    float bw = modemPresetToBwKHz(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, us->wideLora);
-    float channelSpacing = us->profile->spacing + (us->profile->padding * 2) + (bw / 1000.0f);
-    uint32_t numChannels = (uint32_t)(((us->freqEnd - us->freqStart + us->profile->spacing) / channelSpacing) + 0.5f);
-
-    TEST_ASSERT_FLOAT_WITHIN(0.001f, 0.250f, channelSpacing);
-    TEST_ASSERT_EQUAL_UINT32(104, numChannels);
-}
-
-static void test_channelSpacingCalculation_EU868_LONG_FAST()
-{
-    // EU_868: freqStart=869.4, freqEnd=869.65, spacing=0, padding=0
-    // LONG_FAST: bw=250 kHz => channelSpacing = 0.250 MHz
-    // numChannels = round((0.25 + 0) / 0.250) = 1
-    const RegionInfo *eu = getRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_868);
-    float bw = modemPresetToBwKHz(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, eu->wideLora);
-    float channelSpacing = eu->profile->spacing + (eu->profile->padding * 2) + (bw / 1000.0f);
-    uint32_t numChannels = (uint32_t)(((eu->freqEnd - eu->freqStart + eu->profile->spacing) / channelSpacing) + 0.5f);
-
-    TEST_ASSERT_FLOAT_WITHIN(0.001f, 0.250f, channelSpacing);
-    TEST_ASSERT_EQUAL_UINT32(1, numChannels);
-}
-
-// Placeholder: when protobuf region definitions include non-zero padding/spacing,
-// add tests here to verify the channel count and frequency calculations.
-static void test_channelSpacingCalculation_placeholder()
-{
-    // TODO: Once protobuf RegionInfo entries have non-zero padding or spacing values,
-    // verify:
-    //  - Channel count matches expected value for each (region, preset) pair
-    //  - First channel frequency = freqStart + (bw/2000) + padding
-    //  - Nth channel frequency = first + (n * channelSpacing)
-    //  - overrideSlot, when non-zero, forces the channel_num
-    TEST_PASS_MESSAGE("Placeholder for future channel spacing tests with updated protobuf region fields");
-}
-
-// -----------------------------------------------------------------------
-// handleSetConfig fromOthers dispatch tests
-// -----------------------------------------------------------------------
-
-class AdminModuleTestShim : public AdminModule
-{
-  public:
-    using AdminModule::handleSetConfig;
-};
-
-static AdminModuleTestShim *testAdmin;
-
-static meshtastic_Config makeLoraSetConfig(meshtastic_Config_LoRaConfig_RegionCode region, bool usePreset,
-                                           meshtastic_Config_LoRaConfig_ModemPreset preset)
-{
-    meshtastic_Config c = meshtastic_Config_init_zero;
-    c.which_payload_variant = meshtastic_Config_lora_tag;
-    c.payload_variant.lora.region = region;
-    c.payload_variant.lora.use_preset = usePreset;
-    c.payload_variant.lora.modem_preset = preset;
-    return c;
-}
-
-static void test_handleSetConfig_fromOthers_invalidPresetRejected()
-{
-    // Set up a known-good baseline in the global config
-    config.lora = meshtastic_Config_LoRaConfig_init_zero;
-    config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
-    config.lora.use_preset = true;
-    config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
-    initRegion();
-
-    // Build an admin set_config with an invalid preset for EU_868
-    meshtastic_Config c = makeLoraSetConfig(meshtastic_Config_LoRaConfig_RegionCode_EU_868, true,
-                                            meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO);
-
-    testAdmin->handleSetConfig(c, true); // fromOthers = true
-
-    // fromOthers=true: invalid preset should be rejected, old preset preserved
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, config.lora.modem_preset);
-}
-
-static void test_handleSetConfig_fromLocal_invalidPresetClamped()
-{
-    // Set up a known-good baseline
-    config.lora = meshtastic_Config_LoRaConfig_init_zero;
-    config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
-    config.lora.use_preset = true;
-    config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
-    initRegion();
-
-    // Build an admin set_config with an invalid preset for EU_868
-    meshtastic_Config c = makeLoraSetConfig(meshtastic_Config_LoRaConfig_RegionCode_EU_868, true,
-                                            meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO);
-
-    testAdmin->handleSetConfig(c, false); // fromOthers = false (local client)
-
-    // fromOthers=false: invalid preset should be clamped to the region's default
-    const RegionInfo *eu868 = getRegion(meshtastic_Config_LoRaConfig_RegionCode_EU_868);
-    TEST_ASSERT_EQUAL(eu868->getDefaultPreset(), config.lora.modem_preset);
-}
-
-static void test_handleSetConfig_fromOthers_validPresetAccepted()
-{
-    // Set up baseline
-    config.lora = meshtastic_Config_LoRaConfig_init_zero;
-    config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
-    config.lora.use_preset = true;
-    config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
-    initRegion();
-
-    // Build an admin set_config with a valid preset for EU_868
-    meshtastic_Config c = makeLoraSetConfig(meshtastic_Config_LoRaConfig_RegionCode_EU_868, true,
-                                            meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST);
-
-    testAdmin->handleSetConfig(c, true); // fromOthers = true
-
-    // Valid preset should be accepted regardless of fromOthers
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST, config.lora.modem_preset);
-}
-
-// -----------------------------------------------------------------------
-// Test runner
-// -----------------------------------------------------------------------
-
-void setUp(void)
-{
-    mockMeshService = new MockMeshService();
-    service = mockMeshService;
-    testAdmin = new AdminModuleTestShim();
-}
-void tearDown(void)
-{
-    service = nullptr;
-    delete mockMeshService;
-    mockMeshService = nullptr;
-    delete testAdmin;
-    testAdmin = nullptr;
-}
-
-void setup()
-{
-    delay(10);
-    delay(2000);
-
-    initializeTestEnvironment();
-
-    UNITY_BEGIN();
-
-    // getRegion()
-    RUN_TEST(test_getRegion_returnsCorrectRegion_US);
-    RUN_TEST(test_getRegion_returnsCorrectRegion_EU868);
-    RUN_TEST(test_getRegion_returnsCorrectRegion_LORA24);
-    RUN_TEST(test_getRegion_unsetCodeReturnsUnsetEntry);
-    RUN_TEST(test_getRegion_unknownCodeFallsToUnset);
-
-    // validateConfigRegion()
-    RUN_TEST(test_validateConfigRegion_validRegionReturnsTrue);
-    RUN_TEST(test_validateConfigRegion_unsetRegionReturnsTrue);
-
-    // Shadow table tests
-    RUN_TEST(test_shadowTable_spacedProfileHasNonZeroSpacing);
-    RUN_TEST(test_shadowTable_licensedProfileFlagsCorrect);
-    RUN_TEST(test_shadowTable_presetCountMatchesExpected);
-    RUN_TEST(test_shadowTable_defaultPresetIsFirstInList);
-    RUN_TEST(test_shadowTable_channelSpacingWithPadding);
-    RUN_TEST(test_shadowTable_turboOnlyOnWideLora);
-    RUN_TEST(test_shadowTable_unknownCodeFallsToSentinel);
-
-    // validateConfigLora()
-    RUN_TEST(test_validateConfigLora_validPresetForUS);
-    RUN_TEST(test_validateConfigLora_allStdPresetsValidForUS);
-    RUN_TEST(test_validateConfigLora_turboPresetsInvalidForEU868);
-    RUN_TEST(test_validateConfigLora_validPresetsForEU868);
-    RUN_TEST(test_validateConfigLora_customBandwidthTooWideForEU868);
-    RUN_TEST(test_validateConfigLora_customBandwidthFitsUS);
-    RUN_TEST(test_validateConfigLora_customBandwidthFitsEU868);
-    RUN_TEST(test_validateConfigLora_bogusPresetRejected);
-    RUN_TEST(test_validateConfigLora_unsetRegionOnlyAcceptsLongFast);
-    RUN_TEST(test_validateConfigLora_allPresetsValidForLORA24);
-
-    // clampConfigLora()
-    RUN_TEST(test_clampConfigLora_invalidPresetClampedToDefault);
-    RUN_TEST(test_clampConfigLora_validPresetUnchanged);
-    RUN_TEST(test_clampConfigLora_customBwTooWideClampedToDefaultBw);
-    RUN_TEST(test_clampConfigLora_customBwValidLeftUnchanged);
-    RUN_TEST(test_clampConfigLora_bogusPresetOnUnsetClampedToLongFast);
-    RUN_TEST(test_clampConfigLora_invalidPresetOnLORA24ClampedToDefault);
-
-    // RegionInfo preset list integrity
-    RUN_TEST(test_presetsStd_hasNineEntries);
-    RUN_TEST(test_presetsEU868_hasSevenEntries);
-    RUN_TEST(test_presetsUndef_hasOneEntry);
-    RUN_TEST(test_defaultPresetIsInAvailablePresets);
-    RUN_TEST(test_regionFieldsAreSane);
-    RUN_TEST(test_onlyLORA24HasWideLora);
-
-    // Channel spacing (current + placeholder)
-    RUN_TEST(test_channelSpacingCalculation_US_LONG_FAST);
-    RUN_TEST(test_channelSpacingCalculation_EU868_LONG_FAST);
-    RUN_TEST(test_channelSpacingCalculation_placeholder);
-
-    // handleSetConfig fromOthers dispatch
-    RUN_TEST(test_handleSetConfig_fromOthers_invalidPresetRejected);
-    RUN_TEST(test_handleSetConfig_fromLocal_invalidPresetClamped);
-    RUN_TEST(test_handleSetConfig_fromOthers_validPresetAccepted);
-
-    exit(UNITY_END());
-}
-
-void loop() {}

test/test_radio/test_main.cpp

@@ -1,36 +1,10 @@
 #include "MeshRadio.h"
-#include "MeshService.h"
 #include "RadioInterface.h"
 #include "TestUtil.h"
 #include <unity.h>
 
 #include "meshtastic/config.pb.h"
 
-class MockMeshService : public MeshService
-{
-  public:
-    void sendClientNotification(meshtastic_ClientNotification *n) override { releaseClientNotificationToPool(n); }
-};
-
-static MockMeshService *mockMeshService;
-
-// Test shim to expose protected radio parameters set by applyModemConfig()
-class TestableRadioInterface : public RadioInterface
-{
-  public:
-    TestableRadioInterface() : RadioInterface() {}
-    uint8_t getCr() const { return cr; }
-    uint8_t getSf() const { return sf; }
-    float getBw() const { return bw; }
-
-    // Override reconfigure to call the base which invokes applyModemConfig()
-    bool reconfigure() override { return RadioInterface::reconfigure(); }
-
-    // Stubs for pure virtual methods required by RadioInterface
-    uint32_t getPacketTime(uint32_t, bool) override { return 0; }
-    ErrorCode send(meshtastic_MeshPacket *p) override { return ERRNO_OK; }
-};
-
 static void test_bwCodeToKHz_specialMappings()
 {
     TEST_ASSERT_FLOAT_WITHIN(0.0001f, 31.25f, bwCodeToKHz(31));
@@ -47,7 +21,7 @@ static void test_bwCodeToKHz_passthrough()
     TEST_ASSERT_FLOAT_WITHIN(0.0001f, 250.0f, bwCodeToKHz(250));
 }
 
-static void test_validateConfigLora_noopWhenUsePresetFalse()
+static void test_bootstrapLoRaConfigFromPreset_noopWhenUsePresetFalse()
 {
     meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
     cfg.use_preset = false;
@@ -56,152 +30,55 @@ static void test_validateConfigLora_noopWhenUsePresetFalse()
     cfg.bandwidth = 123;
     cfg.spread_factor = 8;
 
-    RadioInterface::validateConfigLora(cfg);
+    RadioInterface::bootstrapLoRaConfigFromPreset(cfg);
 
     TEST_ASSERT_EQUAL_UINT16(123, cfg.bandwidth);
     TEST_ASSERT_EQUAL_UINT32(8, cfg.spread_factor);
     TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST, cfg.modem_preset);
 }
 
-static void test_validateConfigLora_validPreset_nonWideRegion()
+static void test_bootstrapLoRaConfigFromPreset_setsDerivedFields_nonWideRegion()
 {
     meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
     cfg.use_preset = true;
     cfg.region = meshtastic_Config_LoRaConfig_RegionCode_US;
     cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST;
 
-    TEST_ASSERT_TRUE(RadioInterface::validateConfigLora(cfg));
+    RadioInterface::bootstrapLoRaConfigFromPreset(cfg);
+
+    TEST_ASSERT_EQUAL_UINT16(250, cfg.bandwidth);
+    TEST_ASSERT_EQUAL_UINT32(9, cfg.spread_factor);
 }
 
-static void test_validateConfigLora_validPreset_wideRegion()
+static void test_bootstrapLoRaConfigFromPreset_setsDerivedFields_wideRegion()
 {
     meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
     cfg.use_preset = true;
     cfg.region = meshtastic_Config_LoRaConfig_RegionCode_LORA_24;
     cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST;
 
-    TEST_ASSERT_TRUE(RadioInterface::validateConfigLora(cfg));
+    RadioInterface::bootstrapLoRaConfigFromPreset(cfg);
+
+    TEST_ASSERT_EQUAL_UINT16(800, cfg.bandwidth);
+    TEST_ASSERT_EQUAL_UINT32(9, cfg.spread_factor);
 }
 
-static void test_validateConfigLora_rejectsInvalidPresetForRegion()
+static void test_bootstrapLoRaConfigFromPreset_fallsBackIfBandwidthExceedsRegionSpan()
 {
     meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
     cfg.use_preset = true;
     cfg.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
     cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO;
 
-    TEST_ASSERT_FALSE(RadioInterface::validateConfigLora(cfg));
-}
-
-static void test_clampConfigLora_invalidPresetClampedToDefault()
-{
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.use_preset = true;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_EU_868;
-    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_SHORT_TURBO;
-
-    RadioInterface::clampConfigLora(cfg);
+    RadioInterface::bootstrapLoRaConfigFromPreset(cfg);
 
     TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST, cfg.modem_preset);
+    TEST_ASSERT_EQUAL_UINT16(250, cfg.bandwidth);
+    TEST_ASSERT_EQUAL_UINT32(11, cfg.spread_factor);
 }
 
-static void test_clampConfigLora_validPresetUnchanged()
-{
-    meshtastic_Config_LoRaConfig cfg = meshtastic_Config_LoRaConfig_init_zero;
-    cfg.use_preset = true;
-    cfg.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    cfg.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST;
-
-    RadioInterface::clampConfigLora(cfg);
-
-    TEST_ASSERT_EQUAL(meshtastic_Config_LoRaConfig_ModemPreset_MEDIUM_FAST, cfg.modem_preset);
-}
-
-// -----------------------------------------------------------------------
-// applyModemConfig() coding rate tests (via reconfigure)
-// -----------------------------------------------------------------------
-
-static TestableRadioInterface *testRadio;
-
-// After fresh flash: coding_rate=0, use_preset=true, modem_preset=LONG_FAST
-// CR should come from the preset (5 for LONG_FAST), not from the zero default.
-static void test_applyModemConfig_freshFlashCodingRateNotZero()
-{
-    config.lora = meshtastic_Config_LoRaConfig_init_zero;
-    config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    config.lora.use_preset = true;
-    config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
-    // coding_rate is 0 (default after init_zero, same as fresh flash)
-
-    testRadio->reconfigure();
-
-    // LONG_FAST preset has cr=5; must never be 0
-    TEST_ASSERT_EQUAL_UINT8(5, testRadio->getCr());
-    TEST_ASSERT_EQUAL_UINT8(11, testRadio->getSf());
-    TEST_ASSERT_FLOAT_WITHIN(0.01f, 250.0f, testRadio->getBw());
-}
-
-// When coding_rate matches the preset exactly, should still use the preset value
-static void test_applyModemConfig_codingRateMatchesPreset()
-{
-    config.lora = meshtastic_Config_LoRaConfig_init_zero;
-    config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    config.lora.use_preset = true;
-    config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW;
-    config.lora.coding_rate = 8; // LONG_SLOW default is cr=8
-
-    testRadio->reconfigure();
-
-    TEST_ASSERT_EQUAL_UINT8(8, testRadio->getCr());
-}
-
-// Custom CR higher than preset should be used
-static void test_applyModemConfig_customCodingRateHigherThanPreset()
-{
-    config.lora = meshtastic_Config_LoRaConfig_init_zero;
-    config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    config.lora.use_preset = true;
-    config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_FAST;
-    config.lora.coding_rate = 7; // LONG_FAST preset has cr=5, 7 > 5
-
-    testRadio->reconfigure();
-
-    TEST_ASSERT_EQUAL_UINT8(7, testRadio->getCr());
-}
-
-// Custom CR lower than preset: preset wins (higher is more robust)
-static void test_applyModemConfig_customCodingRateLowerThanPreset()
-{
-    config.lora = meshtastic_Config_LoRaConfig_init_zero;
-    config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    config.lora.use_preset = true;
-    config.lora.modem_preset = meshtastic_Config_LoRaConfig_ModemPreset_LONG_SLOW;
-    config.lora.coding_rate = 5; // LONG_SLOW preset has cr=8, 5 < 8
-
-    testRadio->reconfigure();
-
-    TEST_ASSERT_EQUAL_UINT8(8, testRadio->getCr());
-}
-
-void setUp(void)
-{
-    mockMeshService = new MockMeshService();
-    service = mockMeshService;
-
-    // RadioInterface computes slotTimeMsec during construction and expects myRegion to be valid.
-    config.lora.region = meshtastic_Config_LoRaConfig_RegionCode_US;
-    initRegion();
-
-    testRadio = new TestableRadioInterface();
-}
-void tearDown(void)
-{
-    delete testRadio;
-    testRadio = nullptr;
-    service = nullptr;
-    delete mockMeshService;
-    mockMeshService = nullptr;
-}
+void setUp(void) {}
+void tearDown(void) {}
 
 void setup()
 {
@@ -213,16 +90,10 @@ void setup()
     UNITY_BEGIN();
     RUN_TEST(test_bwCodeToKHz_specialMappings);
     RUN_TEST(test_bwCodeToKHz_passthrough);
-    RUN_TEST(test_validateConfigLora_noopWhenUsePresetFalse);
-    RUN_TEST(test_validateConfigLora_validPreset_nonWideRegion);
-    RUN_TEST(test_validateConfigLora_validPreset_wideRegion);
-    RUN_TEST(test_validateConfigLora_rejectsInvalidPresetForRegion);
-    RUN_TEST(test_clampConfigLora_invalidPresetClampedToDefault);
-    RUN_TEST(test_clampConfigLora_validPresetUnchanged);
-    RUN_TEST(test_applyModemConfig_freshFlashCodingRateNotZero);
-    RUN_TEST(test_applyModemConfig_codingRateMatchesPreset);
-    RUN_TEST(test_applyModemConfig_customCodingRateHigherThanPreset);
-    RUN_TEST(test_applyModemConfig_customCodingRateLowerThanPreset);
+    RUN_TEST(test_bootstrapLoRaConfigFromPreset_noopWhenUsePresetFalse);
+    RUN_TEST(test_bootstrapLoRaConfigFromPreset_setsDerivedFields_nonWideRegion);
+    RUN_TEST(test_bootstrapLoRaConfigFromPreset_setsDerivedFields_wideRegion);
+    RUN_TEST(test_bootstrapLoRaConfigFromPreset_fallsBackIfBandwidthExceedsRegionSpan);
     exit(UNITY_END());
 }
 

variants/esp32/esp32-common.ini

@@ -39,6 +39,7 @@ build_flags =
   -Wall
   -Wextra
   -Isrc/platform/esp32
+  -include mbedtls/error.h
   -std=gnu++17
   -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG
   -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG

variants/esp32/heltec_wireless_bridge/platformio.ini

@@ -10,7 +10,6 @@ build_flags =
   -D BOARD_HAS_PSRAM
   -D RADIOLIB_EXCLUDE_LR11X0=1
   -D RADIOLIB_EXCLUDE_SX128X=1
-  -D RADIOLIB_EXCLUDE_LR2021=1
   -D MESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
   -D MESHTASTIC_EXCLUDE_DETECTIONSENSOR=1
   -D MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR=1

variants/esp32s3/heltec_v4/variant.h

@@ -29,14 +29,6 @@
 #define SX126X_DIO2_AS_RF_SWITCH
 #define SX126X_DIO3_TCXO_VOLTAGE 1.8
 
-// Enable Traffic Management Module for Heltec V4
-#ifndef HAS_TRAFFIC_MANAGEMENT
-#define HAS_TRAFFIC_MANAGEMENT 1
-#endif
-#ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 2048
-#endif
-
 // ---- GC1109 RF FRONT END CONFIGURATION ----
 // The Heltec V4.2 uses a GC1109 FEM chip with integrated PA and LNA
 // RF path: SX1262 -> Pi attenuator -> GC1109 PA -> Antenna
@@ -97,4 +89,4 @@
 // Seems to be missing on this new board
 #define GPS_TX_PIN (38) // This is for bits going TOWARDS the CPU
 #define GPS_RX_PIN (39) // This is for bits going TOWARDS the GPS
-#define GPS_THREAD_INTERVAL 50
+#define GPS_THREAD_INTERVAL 50

variants/esp32s3/link32_s3_v1/platformio.ini

@@ -11,4 +11,3 @@ build_flags =
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1
-  -DRADIOLIB_EXCLUDE_LR2021=1

variants/esp32s3/station-g2/variant.h

@@ -40,14 +40,6 @@ Board Information: https://wiki.uniteng.com/en/meshtastic/station-g2
 #define SX126X_MAX_POWER 19
 #endif
 
-// Enable Traffic Management Module for Station G2
-#ifndef HAS_TRAFFIC_MANAGEMENT
-#define HAS_TRAFFIC_MANAGEMENT 1
-#endif
-#ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 2048
-#endif
-
 /*
 #define BATTERY_PIN 4 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 #define ADC_CHANNEL ADC1_GPIO4_CHANNEL

variants/native/portduino/variant.h

@@ -8,11 +8,3 @@
 
 // RAK12002 RTC Module
 #define RV3028_RTC (uint8_t)0b1010010
-
-// Enable Traffic Management Module for native/portduino
-#ifndef HAS_TRAFFIC_MANAGEMENT
-#define HAS_TRAFFIC_MANAGEMENT 1
-#endif
-#ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 2048
-#endif

variants/nrf52840/diy/nrf52_promicro_diy_tcxo/rfswitch.h

@@ -12,15 +12,9 @@ static const uint32_t rfswitch_dio_pins[] = {RADIOLIB_LR11X0_DIO5, RADIOLIB_LR11
                                              RADIOLIB_NC};
 
 static const Module::RfSwitchMode_t rfswitch_table[] = {
-    // clang-format off
-    // mode            DIO5  DIO6  DIO7
-    {LR11x0::MODE_STBY, {LOW, LOW, LOW}},
-    {LR11x0::MODE_RX, {LOW, HIGH, LOW}},
-    {LR11x0::MODE_TX, {HIGH, HIGH, LOW}},
-    {LR11x0::MODE_TX_HP, {HIGH, LOW, LOW}},
-    {LR11x0::MODE_TX_HF, {LOW, LOW, LOW}},
-    {LR11x0::MODE_GNSS, {LOW, LOW, HIGH}},
-    {LR11x0::MODE_WIFI, {LOW, LOW, LOW}},
-    END_OF_MODE_TABLE,
-    // clang-format on
+    // mode                  DIO5  DIO6  DIO7
+    {LR11x0::MODE_STBY, {LOW, LOW, LOW}},  {LR11x0::MODE_RX, {LOW, HIGH, LOW}},
+    {LR11x0::MODE_TX, {HIGH, HIGH, LOW}},  {LR11x0::MODE_TX_HP, {HIGH, LOW, LOW}},
+    {LR11x0::MODE_TX_HF, {LOW, LOW, LOW}}, {LR11x0::MODE_GNSS, {LOW, LOW, HIGH}},
+    {LR11x0::MODE_WIFI, {LOW, LOW, LOW}},  END_OF_MODE_TABLE,
 };

variants/nrf52840/gat562_mesh_trial_tracker/platformio.ini

@@ -11,5 +11,4 @@ build_flags = ${nrf52840_base.build_flags}
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1
-  -DRADIOLIB_EXCLUDE_LR2021=1
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/gat562_mesh_trial_tracker>

variants/nrf52840/makerfabs_pucky/platformio.ini

@@ -0,0 +1,68 @@
+[env:makerfabs_pucky]
+custom_meshtastic_hw_model = 124
+custom_meshtastic_hw_model_slug = Hockey_Puck
+custom_meshtastic_architecture = nrf52840
+custom_meshtastic_actively_supported = true
+custom_meshtastic_support_level = 1
+custom_meshtastic_display_name = Makerfabs Hockey Puck
+custom_meshtastic_images = rak4631.svg, rak4631_case.svg
+custom_meshtastic_tags = Makerfabs
+
+extends = nrf52840_base
+board = makerfabs_pucky
+board_level = pr
+board_check = true
+build_type = release
+build_flags = ${nrf52840_base.build_flags}
+  -I variants/nrf52840/makerfabs_pucky
+  -D Hockey_Puck
+  -DMESHTASTIC_USE_EINK_UI=0
+  -DMESHTASTIC_HAS_SCREEN=0
+  -DMESHTASTIC_HAS_GPS=1
+  -DRADIOLIB_EXCLUDE_SX128X=1
+  -DRADIOLIB_EXCLUDE_SX127X=1
+  -DRADIOLIB_EXCLUDE_SX126X=1
+  -DRADIOLIB_EXCLUDE_LR11X0=0
+build_src_filter = ${nrf52_base.build_src_filter} \
+  +<../variants/nrf52840/makerfabs_pucky> \
+  +<mesh/api/> \
+  +<mqtt/> \
+lib_deps = 
+  ${nrf52840_base.lib_deps}
+  ${networking_base.lib_deps}
+  # TODO renovate
+  https://github.com/meshtastic/QMA6100P_Arduino_Library/archive/14c900b8b2e4feaac5007a7e41e0c1b7f0841136.zip
+
+; If not set we will default to uploading over serial (first it forces bootloader entry by talking 1200bps to cdcacm)
+; Note: as of 6/2013 the serial/bootloader based programming takes approximately 30 seconds
+;upload_protocol = jlink
+
+; Allows programming and debug via the RAK NanoDAP as the default debugger tool for the RAK4631 (it is only $10!)
+; programming time is about the same as the bootloader version.
+; For information on this see the meshtastic developers documentation for "Development on the NRF52"
+[env:makerfabs_pucky_dbg]
+extends = env:makerfabs_pucky
+board_level = extra
+
+; if the builtin version of openocd has a buggy version of semihosting, so use the external version
+; platform_packages = platformio/tool-openocd@3.1200.0
+
+build_flags =
+  ${env:makerfabs_pucky.build_flags}
+  -D USE_SEMIHOSTING
+
+lib_deps =
+  ${env:makerfabs_pucky.lib_deps}
+  # TODO renovate
+  https://github.com/geeksville/Armduino-Semihosting/archive/35b538fdf208c3530c1434cd099a08e486672ee4.zip
+
+; NOTE: the pyocd support for semihosting is buggy.  So I switched to using the builtin platformio support for the stlink adapter which worked much better.
+; However the built in openocd version in platformio has buggy support for TCP to semihosting. 
+;
+; So I'm now trying the external openocd - but the openocd scripts for nrf52.cfg assume you are using a DAP adapter not an STLINK adapter.
+; In theory I could change those scripts.  But for now I'm trying going back to a DAP adapter but with the external openocd.
+
+upload_protocol = stlink
+; eventually use platformio/tool-pyocd@2.3600.0 instad
+;upload_protocol = custom
+;upload_command = pyocd flash -t nrf52840 $UPLOADERFLAGS $SOURCE

variants/nrf52840/makerfabs_pucky/rfswitch.h

@@ -0,0 +1,18 @@
+#include "RadioLib.h"
+#include "nrf.h"
+
+static const uint32_t rfswitch_dio_pins[] = {
+    RADIOLIB_LR11X0_DIO5, RADIOLIB_LR11X0_DIO6, RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC // RADIOLIB_LR11X0_DIO7
+};
+
+static const Module::RfSwitchMode_t rfswitch_table[] = {
+    // mode                DIO5 DIO6 // DIO7
+    {LR11x0::MODE_STBY, {LOW, LOW}},   // { LR11x0::MODE_STBY, { LOW, LOW, LOW } },
+    {LR11x0::MODE_RX, {HIGH, LOW}},    //   { LR11x0::MODE_RX, { HIGH, LOW, LOW } },
+    {LR11x0::MODE_TX, {HIGH, HIGH}},   // { LR11x0::MODE_TX, { HIGH, HIGH, LOW } },
+    {LR11x0::MODE_TX_HP, {LOW, HIGH}}, // { LR11x0::MODE_TX_HP, { LOW, HIGH, HIGH } },
+    {LR11x0::MODE_TX_HF, {LOW, LOW}},  // { LR11x0::MODE_TX_HF, { LOW, LOW, HIGH } },
+    {LR11x0::MODE_GNSS, {LOW, LOW}},   // { LR11x0::MODE_GNSS, { LOW, LOW, LOW } },
+    {LR11x0::MODE_WIFI, {LOW, LOW}},   // { LR11x0::MODE_WIFI, { LOW, LOW, LOW } },
+    END_OF_MODE_TABLE,
+};

variants/nrf52840/makerfabs_pucky/variant.cpp

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

variants/nrf52840/makerfabs_pucky/variant.h

@@ -0,0 +1,177 @@
+
+/*
+  Copyright (c) 2014-2015 Arduino LLC.  All right reserved.
+  Copyright (c) 2016 Sandeep Mistry All right reserved.
+  Copyright (c) 2018, Adafruit Industries (adafruit.com)
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the GNU Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef _VARIANT_RAK4630_
+#define _VARIANT_RAK4630_
+
+// #define RAK4630
+
+/** Master clock frequency */
+#define VARIANT_MCK (64000000ul)
+
+#define USE_LFXO // Board uses 32khz crystal for LF
+
+/*----------------------------------------------------------------------------
+ *        Headers
+ *----------------------------------------------------------------------------*/
+
+#include "WVariant.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// Number of pins defined in PinDescription array
+#define PINS_COUNT (48)
+#define NUM_DIGITAL_PINS (48)
+#define NUM_ANALOG_INPUTS (6)
+#define NUM_ANALOG_OUTPUTS (0)
+
+// #define LED_PIN 16 // This is a LED_WS2812 not a standard LED
+#define HAS_NEOPIXEL                         // Enable the use of neopixels
+#define NEOPIXEL_COUNT 1                     // How many neopixels are connected
+#define NEOPIXEL_DATA 25                     // gpio pin used to send data to the neopixels
+#define NEOPIXEL_TYPE (NEO_GRB + NEO_KHZ800) // type of neopixels in use
+
+#define RGB_LED_POWER
+
+#define LED_STATE_ON 1
+
+/*
+ * Buttons
+ */
+
+#define BUTTON_PIN 5
+#define PIN_BUZZER 22
+/*
+ * Analog pins
+ */
+#define PIN_A0 (2)
+#define PIN_A1 (3)
+#define PIN_A2 (4)
+#define PIN_A3 (5)
+#define PIN_A4 (28)
+#define PIN_A5 (29)
+#define PIN_A6 (30)
+#define PIN_A7 (31)
+
+static const uint8_t A0 = PIN_A0;
+static const uint8_t A1 = PIN_A1;
+static const uint8_t A2 = PIN_A2;
+static const uint8_t A3 = PIN_A3;
+static const uint8_t A4 = PIN_A4;
+static const uint8_t A5 = PIN_A5;
+static const uint8_t A6 = PIN_A6;
+static const uint8_t A7 = PIN_A7;
+#define ADC_RESOLUTION 14
+
+// Other pins
+#define PIN_AREF (2)
+
+static const uint8_t AREF = PIN_AREF;
+
+/*
+ * Serial interfaces
+ */
+// GPS on Base Board
+#define PIN_SERIAL1_RX (8)
+#define PIN_SERIAL1_TX (6)
+
+// DEBUG on Base Board
+#define PIN_SERIAL2_RX (38)
+#define PIN_SERIAL2_TX (37)
+
+/*
+ * SPI Interfaces
+ */
+#define SPI_INTERFACES_COUNT 1
+#define PIN_SPI_MISO (47)
+#define PIN_SPI_MOSI (46)
+#define PIN_SPI_SCK (45)
+
+static const uint8_t SS = 44;
+static const uint8_t MOSI = PIN_SPI_MOSI;
+static const uint8_t MISO = PIN_SPI_MISO;
+static const uint8_t SCK = PIN_SPI_SCK;
+
+#define USE_LR1121
+#define LR11X0_POWER_EN (13)
+#define LR1121_IRQ_PIN 14
+#define LR1121_NRESET_PIN (42)
+#define LR1121_BUSY_PIN (43)
+#define LR1121_SPI_NSS_PIN SS
+#define LR1121_SPI_SCK_PIN PIN_SPI_SCK
+#define LR1121_SPI_MOSI_PIN PIN_SPI_MOSI
+#define LR1121_SPI_MISO_PIN PIN_SPI_MISO
+#define LR11X0_DIO3_TCXO_VOLTAGE 3.3
+#define LR11X0_DIO_AS_RF_SWITCH
+
+/*
+ * Wire Interfaces
+ */
+#define WIRE_INTERFACES_COUNT 1
+#define PIN_WIRE_SDA (26)
+#define PIN_WIRE_SCL (27)
+
+#define HAS_QMA6100P
+
+/*
+ * Power Switches
+ */
+#define POWER_ON_OFF (30) // P0.30 Power latch control, set high to keep power on, set low to turn off
+#define PIN_3V3_EN (16)
+
+#define HAS_GPS 1
+#define PIN_GPS_PPS (11) // Pulse per second input from the GPS
+#define GPS_RX_PIN PIN_SERIAL1_RX
+#define GPS_TX_PIN PIN_SERIAL1_TX
+
+// Battery
+#define EXT_CHRG_DETECT (32 + 7) // P1.07
+#define HAS_CW2015 1
+
+// RAK4630 AIN0 = nrf52840 AIN3 = Pin 5
+// #define BATTERY_LPCOMP_INPUT NRF_LPCOMP_INPUT_3
+
+// We have AIN3 with a VBAT divider so AIN3 = VBAT * (1.5/2.5)
+// We have the device going deep sleep under 3.1V, which is AIN3 = 1.86V
+// So we can wake up when VBAT>=VDD is restored to 3.3V, where AIN3 = 1.98V
+// 1.98/3.3 = 6/10, but that's close to the VBAT divider, so we
+// pick 6/8VDD, which means VBAT=4.1V.
+// Reference:
+// VDD=3.3V AIN3=5/8*VDD=2.06V VBAT=1.66*AIN3=3.41V
+// VDD=3.3V AIN3=11/16*VDD=2.26V VBAT=1.66*AIN3=3.76V
+// VDD=3.3V AIN3=6/8*VDD=2.47V VBAT=1.66*AIN3=4.1V
+// #define BATTERY_LPCOMP_THRESHOLD NRF_LPCOMP_REF_SUPPLY_11_16
+
+#define LNA_CTRL_PIN 4 // P0.04
+
+#define HOCKEY_PUCK 1
+#define NUM_PA_POINTS 22
+#define TX_GAIN_LORA 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 13, 13, 13, 12, 12, 11, 10, 9, 8, 7
+
+#ifdef __cplusplus
+}
+#endif
+
+/*----------------------------------------------------------------------------
+ *        Arduino objects - C++ only
+ *----------------------------------------------------------------------------*/
+
+#endif

variants/nrf52840/meshlink/platformio.ini

@@ -12,7 +12,6 @@ build_flags = ${nrf52840_base.build_flags}
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1
-  -DRADIOLIB_EXCLUDE_LR2021=1
   
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/meshlink>
 debug_tool = jlink
@@ -31,7 +30,6 @@ build_flags = ${nrf52840_base.build_flags}
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1
-  -DRADIOLIB_EXCLUDE_LR2021=1
   -D USE_EINK
   -D EINK_DISPLAY_MODEL=GxEPD2_213_B74
   -D EINK_WIDTH=250
@@ -53,4 +51,4 @@ lib_deps =
 debug_tool = jlink
 ; If not set we will default to uploading over serial (first it forces bootloader entry by talking 1200bps to cdcacm)
 ; Note: as of 6/2013 the serial/bootloader based programming takes approximately 30 seconds
-;upload_protocol = jlink
+;upload_protocol = jlink

variants/nrf52840/r1-neo/platformio.ini

@@ -18,7 +18,6 @@ build_flags = ${nrf52840_base.build_flags}
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1
-  -DRADIOLIB_EXCLUDE_LR2021=1
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/r1-neo> +<mesh/api/> +<mqtt/>
 lib_deps = 
   ${nrf52840_base.lib_deps}

variants/nrf52840/rak2560/platformio.ini

@@ -18,7 +18,6 @@ build_flags = ${nrf52840_base.build_flags}
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1
-  -DRADIOLIB_EXCLUDE_LR2021=1
   -DHAS_RAKPROT=1 ; Define if RAk OneWireSerial is used (disables GPS)
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/rak2560> +<mesh/api/> +<mqtt/> +<serialization/>
 lib_deps = 

variants/nrf52840/rak3401_1watt/platformio.ini

@@ -22,7 +22,6 @@ build_flags = ${nrf52840_base.build_flags}
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1
-  -DRADIOLIB_EXCLUDE_LR2021=1
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/rak3401_1watt> +<mesh/api/>
 lib_deps = 
   ${nrf52840_base.lib_deps}

variants/nrf52840/rak4631/platformio.ini

@@ -21,7 +21,6 @@ build_flags = ${nrf52840_base.build_flags}
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1
-  -DRADIOLIB_EXCLUDE_LR2021=1
 build_src_filter = ${nrf52_base.build_src_filter} \
   +<../variants/nrf52840/rak4631> \
   +<mesh/eth/> \

variants/nrf52840/rak4631_epaper/platformio.ini

@@ -11,7 +11,6 @@ build_flags = ${nrf52840_base.build_flags}
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1
-  -DRADIOLIB_EXCLUDE_LR2021=1
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/rak4631_epaper>
 lib_deps = 
   ${nrf52840_base.lib_deps}

variants/nrf52840/rak4631_epaper_onrxtx/platformio.ini

@@ -13,7 +13,6 @@ build_flags = ${nrf52840_base.build_flags}
   -D RADIOLIB_EXCLUDE_SX128X=1
   -D RADIOLIB_EXCLUDE_SX127X=1
   -D RADIOLIB_EXCLUDE_LR11X0=1
-  -D RADIOLIB_EXCLUDE_LR2021=1
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/rak4631_epaper_onrxtx>
 lib_deps = 
   ${nrf52840_base.lib_deps}

variants/nrf52840/rak4631_nomadstar_meteor_pro/platformio.ini

@@ -21,7 +21,6 @@ build_flags = ${nrf52840_base.build_flags}
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1
-  -DRADIOLIB_EXCLUDE_LR2021=1
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/rak4631_nomadstar_meteor_pro> +<mesh/api/> +<mqtt/>
 lib_deps =
   ${nrf52840_base.lib_deps}

variants/nrf52840/rak_wismeshtag/platformio.ini

@@ -19,6 +19,5 @@ build_flags = ${nrf52840_base.build_flags}
   -DRADIOLIB_EXCLUDE_SX128X=1
   -DRADIOLIB_EXCLUDE_SX127X=1
   -DRADIOLIB_EXCLUDE_LR11X0=1
-  -DRADIOLIB_EXCLUDE_LR2021=1
   -DMESHTASTIC_EXCLUDE_WIFI=1
 build_src_filter = ${nrf52_base.build_src_filter} +<../variants/nrf52840/rak_wismeshtag>

variants/nrf52840/tracker-t1000-e/variant.h

@@ -154,15 +154,6 @@ extern "C" {
 
 #define HAS_SCREEN 0
 
-// Enable Traffic Management Module for testing on T1000-E
-// NRF52840 has 256KB RAM - 1024 entries uses ~10KB
-#ifndef HAS_TRAFFIC_MANAGEMENT
-#define HAS_TRAFFIC_MANAGEMENT 1
-#endif
-#ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 1024
-#endif
-
 #ifdef __cplusplus
 }
 #endif