From 24691978b39c9b875d2dc1a64a42111ebdac7e16 Mon Sep 17 00:00:00 2001
From: Peter Buchegger <peter.buchegger7@gmail.com>
Date: Wed, 11 Mar 2026 21:07:19 +0100
Subject: [PATCH 01/11] feat: Implement channel management and discovery for
 ESP-NOW communication

- Added WiFi channel management to the WiFi class, allowing retrieval of the current channel.
- Updated esp_now.h to define functions for setting and getting the WiFi channel.
- Modified sim_espnow.cpp to bind UDP sockets to channels dynamically based on the current WiFi channel.
- Enhanced ReceiverApp and TransmitterApp to support channel discovery and migration, including callbacks for channel changes.
- Implemented channel scanning logic to find active transmitters and manage channel acquisition.
- Added unit tests for channel validation, discovery packet construction, and ChannelScanner functionality.
- Updated API endpoints to reflect changes in channel management.
---
 firmware/data/transmitter/index.html          |   6 -
 firmware/lib/odh-channel/Channel.h            |  83 +++++
 firmware/lib/odh-channel/ChannelScanner.cpp   |  97 ++++++
 firmware/lib/odh-channel/ChannelScanner.h     |  81 +++++
 firmware/lib/odh-channel/library.json         |   8 +
 firmware/lib/odh-config/Config.h              |   6 -
 firmware/lib/odh-protocol/FunctionMap.h       |  10 +-
 firmware/lib/odh-protocol/Protocol.h          | 151 +++++----
 firmware/lib/odh-radio/IRadioLink.h           |  17 +-
 firmware/lib/odh-radio/ReceiverRadioLink.cpp  | 112 +++++--
 firmware/lib/odh-radio/ReceiverRadioLink.h    | 105 +++----
 .../lib/odh-radio/TransmitterRadioLink.cpp    | 112 ++++++-
 firmware/lib/odh-radio/TransmitterRadioLink.h |  88 +++---
 firmware/sim/include/WiFi.h                   |   4 +
 firmware/sim/include/esp_now.h                |  20 +-
 firmware/sim/sim_build.py                     |   4 +
 firmware/sim/src/sim_espnow.cpp               |  85 +++--
 firmware/src/receiver/ReceiverApp.cpp         | 139 ++++++++-
 firmware/src/receiver/ReceiverApp.h           |  17 +
 firmware/src/receiver/web/ReceiverApi.cpp     |   2 +-
 firmware/src/transmitter/TransmitterApp.cpp   | 150 ++++++++-
 firmware/src/transmitter/TransmitterApp.h     |  14 +
 .../src/transmitter/web/TransmitterApi.cpp    |   8 +-
 firmware/test/test_native/test_channel.cpp    | 291 ++++++++++++++++++
 firmware/test/test_native/test_protocol.cpp   | 102 +++++-
 25 files changed, 1398 insertions(+), 314 deletions(-)
 create mode 100644 firmware/lib/odh-channel/Channel.h
 create mode 100644 firmware/lib/odh-channel/ChannelScanner.cpp
 create mode 100644 firmware/lib/odh-channel/ChannelScanner.h
 create mode 100644 firmware/lib/odh-channel/library.json
 create mode 100644 firmware/test/test_native/test_channel.cpp

diff --git a/firmware/data/transmitter/index.html b/firmware/data/transmitter/index.html
index 7f1d58a..26acc40 100644
--- a/firmware/data/transmitter/index.html
+++ b/firmware/data/transmitter/index.html
@@ -183,10 +183,6 @@ <h2>Device</h2>
   <label>Device Name</label>
   <input type="text" id="c-devname" maxlength="28">
 
-  <h2>Radio</h2>
-  <label>WiFi Channel (1–13)</label>
-  <input type="number" id="c-radioch" min="1" max="13">
-
   <h2>Battery</h2>
   <label>TX Cells</label>
   <select id="c-txcells">
@@ -266,7 +262,6 @@ <h2>Modules</h2>
         configData = await fetchJson('/api/config');
         const c = configData;
         document.getElementById('c-devname').value = c.device_name || '';
-        document.getElementById('c-radioch').value = c.radio_channel || 1;
         document.getElementById('c-txcells').value = c.tx_cells || 0;
         document.getElementById('c-rxcells').value = c.rx_cells || 0;
 
@@ -345,7 +340,6 @@ <h2>Modules</h2>
 
       const body = {
         device_name: document.getElementById('c-devname').value,
-        radio_channel: parseInt(document.getElementById('c-radioch').value),
         model_type: parseInt(document.getElementById('c-model').value),
         tx_cells: parseInt(document.getElementById('c-txcells').value),
         rx_cells: parseInt(document.getElementById('c-rxcells').value),
diff --git a/firmware/lib/odh-channel/Channel.h b/firmware/lib/odh-channel/Channel.h
new file mode 100644
index 0000000..4d2ff39
--- /dev/null
+++ b/firmware/lib/odh-channel/Channel.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#pragma once
+
+#include <cstdint>
+
+namespace odh {
+namespace channel {
+
+/// The three non-overlapping 2.4 GHz WiFi channels used for discovery.
+inline constexpr uint8_t kCandidateChannels[]   = {1, 6, 11};
+inline constexpr uint8_t kCandidateChannelCount = 3;
+
+/// Returns true only for channels 1, 6, or 11.
+inline constexpr bool isValidChannel(uint8_t ch) {
+    return ch == 1 || ch == 6 || ch == 11;
+}
+
+/// Fallback channel when NVS is empty or contains an invalid value.
+inline constexpr uint8_t kDefaultChannel = 1;
+
+// -- Discovery timing constants --
+
+/// Wait after switching WiFi channel before sending (ms).
+inline constexpr uint32_t kChannelSettleMs = 10;
+
+/// Wait for a discovery response after sending a request (ms).
+inline constexpr uint32_t kDiscoveryWaitMs = 25;
+
+/// Number of discovery requests per channel scan attempt.
+inline constexpr uint8_t kDiscoveryRetries = 2;
+
+/// Approximate wall-clock time for one full scan of all 3 channels (ms).
+inline constexpr uint32_t kScanRoundMs = 180;
+
+/// Minimum random backoff before a receiver claims a channel (ms).
+inline constexpr uint32_t kFoundingBackoffMinMs = 200;
+
+/// Maximum random backoff before a receiver claims a channel (ms).
+inline constexpr uint32_t kFoundingBackoffMaxMs = 700;
+
+/// Interval at which a receiver broadcasts its presence (ms).
+inline constexpr uint32_t kPresenceIntervalMs = 500;
+
+/// Receiver re-enters discovery if it hears no transmitter for this long (ms).
+inline constexpr uint32_t kTransmitterLossTimeoutMs = 3000;
+
+/// Transmitter prunes receivers not seen for this long (ms).
+inline constexpr uint32_t kPresenceStaleTimeoutMs = 5000;
+
+/// Maps a WiFi channel number to a UDP simulation port.
+/// ch 1 → 7001, ch 6 → 7006, ch 11 → 7011, anything else → 7001.
+inline constexpr uint16_t channelToSimPort(uint8_t ch) {
+    if (ch == 1)
+        return 7001;
+    if (ch == 6)
+        return 7006;
+    if (ch == 11)
+        return 7011;
+    return 7001;
+}
+
+} // namespace channel
+} // namespace odh
diff --git a/firmware/lib/odh-channel/ChannelScanner.cpp b/firmware/lib/odh-channel/ChannelScanner.cpp
new file mode 100644
index 0000000..14d36cb
--- /dev/null
+++ b/firmware/lib/odh-channel/ChannelScanner.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include "ChannelScanner.h"
+
+#include <cstdlib>
+
+namespace odh {
+
+ChannelScanner::ChannelScanner(SetChannelFn setChannel, SendDiscoveryFn sendDiscovery, DelayFn delayMs)
+    : _setChannel(std::move(setChannel)),
+      _sendDiscovery(std::move(sendDiscovery)),
+      _delay(std::move(delayMs)) {}
+
+ScanResult ChannelScanner::scanChannel(uint8_t channel) {
+    ScanResult result;
+    result.channel = channel;
+
+    // Switch to channel and wait for it to settle
+    _setChannel(channel);
+    _delay(channel::kChannelSettleMs);
+
+    // Reset response flag
+    _responseReceived    = false;
+    _responseRssi        = -127;
+    _responseDeviceCount = 0;
+
+    // Send discovery requests with retries
+    for (uint8_t attempt = 0; attempt < channel::kDiscoveryRetries; ++attempt) {
+        _sendDiscovery(channel);
+        _delay(channel::kDiscoveryWaitMs);
+
+        if (_responseReceived) {
+            result.foundTransmitter = true;
+            result.rssi             = _responseRssi;
+            result.deviceCount      = _responseDeviceCount;
+            return result;
+        }
+    }
+
+    return result;
+}
+
+void ChannelScanner::scanAllChannels(ScanResult results[channel::kCandidateChannelCount]) {
+    for (uint8_t i = 0; i < channel::kCandidateChannelCount; ++i) {
+        results[i] = scanChannel(channel::kCandidateChannels[i]);
+    }
+}
+
+uint8_t ChannelScanner::bestChannel(const ScanResult results[channel::kCandidateChannelCount]) {
+    // First: prefer channels with an active transmitter (best RSSI)
+    int8_t bestRssi = -128;
+    uint8_t bestCh  = channel::kCandidateChannels[0];
+    bool foundAny   = false;
+
+    for (uint8_t i = 0; i < channel::kCandidateChannelCount; ++i) {
+        if (results[i].foundTransmitter && results[i].rssi > bestRssi) {
+            bestRssi = results[i].rssi;
+            bestCh   = results[i].channel;
+            foundAny = true;
+        }
+    }
+
+    if (foundAny) {
+        return bestCh;
+    }
+
+    // No transmitter found: return first candidate (channel selection for
+    // founding a new cluster – caller may do channel quality evaluation)
+    return channel::kCandidateChannels[0];
+}
+
+void ChannelScanner::onDiscoveryResponse(uint8_t /*channel*/, int8_t rssi, uint8_t deviceCount) {
+    _responseRssi        = rssi;
+    _responseDeviceCount = deviceCount;
+    _responseReceived    = true;
+}
+
+} // namespace odh
diff --git a/firmware/lib/odh-channel/ChannelScanner.h b/firmware/lib/odh-channel/ChannelScanner.h
new file mode 100644
index 0000000..186c1dc
--- /dev/null
+++ b/firmware/lib/odh-channel/ChannelScanner.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#pragma once
+
+#include "Channel.h"
+
+#include <Protocol.h>
+#include <cstdint>
+#include <functional>
+
+namespace odh {
+
+/// Result of scanning a single WiFi channel for transmitter activity.
+struct ScanResult {
+    uint8_t channel       = 0;
+    bool foundTransmitter = false;
+    int8_t rssi           = -127;
+    uint8_t deviceCount   = 0; ///< From DiscoveryResponse
+};
+
+/// Callback types for platform-abstracted channel operations.
+using SetChannelFn    = std::function<bool(uint8_t channel)>;
+using SendDiscoveryFn = std::function<bool(uint8_t channel)>;
+using DelayFn         = std::function<void(uint32_t ms)>;
+
+/**
+ * Shared channel scanner used by both transmitter and receiver.
+ *
+ * Platform-agnostic: uses callbacks for channel switching, packet
+ * sending, and delays so it works on both ESP32 and the simulator.
+ */
+class ChannelScanner {
+public:
+    ChannelScanner(SetChannelFn setChannel, SendDiscoveryFn sendDiscovery, DelayFn delayMs);
+
+    /// Scan a single channel: switch, send discovery request(s), wait for response.
+    ScanResult scanChannel(uint8_t channel);
+
+    /// Scan all candidate channels (1, 6, 11). Returns results for each.
+    void scanAllChannels(ScanResult results[channel::kCandidateChannelCount]);
+
+    /// Pick the best channel from scan results.
+    /// Prefers channels with an active transmitter. Among those, picks best RSSI.
+    /// If none have a transmitter, returns the channel that appears quietest.
+    static uint8_t bestChannel(const ScanResult results[channel::kCandidateChannelCount]);
+
+    /// Called by the radio layer when a DiscoveryResponse is received.
+    /// Thread-safe: sets internal flag for the current scan wait.
+    void onDiscoveryResponse(uint8_t channel, int8_t rssi, uint8_t deviceCount);
+
+private:
+    SetChannelFn _setChannel;
+    SendDiscoveryFn _sendDiscovery;
+    DelayFn _delay;
+
+    // Volatile scan state (set by onDiscoveryResponse, read by scanChannel)
+    volatile bool _responseReceived       = false;
+    volatile int8_t _responseRssi         = -127;
+    volatile uint8_t _responseDeviceCount = 0;
+};
+
+} // namespace odh
diff --git a/firmware/lib/odh-channel/library.json b/firmware/lib/odh-channel/library.json
new file mode 100644
index 0000000..b1c6de2
--- /dev/null
+++ b/firmware/lib/odh-channel/library.json
@@ -0,0 +1,8 @@
+{
+    "name": "odh-channel",
+    "version": "1.0.0",
+    "description": "OpenDriveHub shared channel model and discovery scanner",
+    "dependencies": [
+        {"name": "odh-protocol"}
+    ]
+}
diff --git a/firmware/lib/odh-config/Config.h b/firmware/lib/odh-config/Config.h
index fd70604..2587b6a 100644
--- a/firmware/lib/odh-config/Config.h
+++ b/firmware/lib/odh-config/Config.h
@@ -38,9 +38,6 @@ namespace odh::config {
 
 // ── Shared settings ─────────────────────────────────────────────────────
 
-/// ESP-NOW WiFi channel (1-13). Must match on TX and RX.
-inline constexpr uint8_t kRadioWifiChannel = 1;
-
 /// Failsafe timeout (ms) – if no control packet arrives within this window,
 /// the receiver applies failsafe values.
 inline constexpr uint32_t kRadioFailsafeTimeoutMs = 500;
@@ -75,9 +72,6 @@ inline constexpr uint8_t kChannelCount = 8;
 /// Default vehicle name for broadcast announcements.
 inline constexpr const char *kVehicleName = "Vehicle";
 
-/// Announce broadcast interval (ms).
-inline constexpr uint32_t kAnnounceIntervalMs = 500;
-
 /// Telemetry send interval (ms).
 inline constexpr uint32_t kTelemetrySendIntervalMs = 100;
 
diff --git a/firmware/lib/odh-protocol/FunctionMap.h b/firmware/lib/odh-protocol/FunctionMap.h
index eeb5cd4..ff0c9b9 100644
--- a/firmware/lib/odh-protocol/FunctionMap.h
+++ b/firmware/lib/odh-protocol/FunctionMap.h
@@ -259,13 +259,13 @@ inline const char *odh_model_name(uint8_t model) {
 #endif
 }
 
-inline uint8_t odh_default_function_map(uint8_t model, OdhFunctionMapEntry_t *entries) {
+inline uint8_t odh_default_function_map(uint8_t model, FunctionMapEntry *entries) {
     auto map = odh::defaultFunctionMap(model);
-    std::memcpy(entries, map.entries.data(), sizeof(OdhFunctionMapEntry_t) * map.count);
+    std::memcpy(entries, map.entries.data(), sizeof(FunctionMapEntry) * map.count);
     return map.count;
 }
 
-inline uint8_t odh_function_to_channel(const OdhFunctionMapEntry_t *entries, uint8_t count, uint8_t function) {
+inline uint8_t odh_function_to_channel(const FunctionMapEntry *entries, uint8_t count, uint8_t function) {
     for (uint8_t i = 0; i < count; i++) {
         if (entries[i].function == function) {
             return entries[i].channel;
@@ -274,13 +274,13 @@ inline uint8_t odh_function_to_channel(const OdhFunctionMapEntry_t *entries, uin
     return 0xFF;
 }
 
-inline uint8_t odh_channel_to_function(const OdhFunctionMapEntry_t *entries, uint8_t count, uint8_t channel) {
+inline uint8_t odh_channel_to_function(const FunctionMapEntry *entries, uint8_t count, uint8_t channel) {
     for (uint8_t i = 0; i < count; i++) {
         if (entries[i].channel == channel) {
             return entries[i].function;
         }
     }
-    return ODH_FUNC_NONE;
+    return static_cast<uint8_t>(Function::None);
 }
 
 } // namespace odh
diff --git a/firmware/lib/odh-protocol/Protocol.h b/firmware/lib/odh-protocol/Protocol.h
index f4b08a3..0d62724 100644
--- a/firmware/lib/odh-protocol/Protocol.h
+++ b/firmware/lib/odh-protocol/Protocol.h
@@ -65,12 +65,21 @@ inline constexpr uint8_t kVehicleNameMax = 16;
 // ── Packet types ────────────────────────────────────────────────────────
 
 enum class PacketType : uint8_t {
-    Control    = 0x01, ///< TX → RX: function values + trims
-    Telemetry  = 0x02, ///< RX → TX: battery, RSSI, sensor data
-    Bind       = 0x10, ///< Binding handshake (connect request / reply)
-    Ack        = 0x20, ///< Generic acknowledgement
-    Announce   = 0x30, ///< RX → broadcast: vehicle presence announcement
-    Disconnect = 0x40, ///< TX → RX: disconnect / release link
+    Control           = 0x01, ///< TX → RX: function values + trims
+    Telemetry         = 0x02, ///< RX → TX: battery, RSSI, sensor data
+    Bind              = 0x10, ///< Binding handshake (connect request / reply)
+    Disconnect        = 0x40, ///< TX → RX: disconnect / release link
+    DiscoveryRequest  = 0x50, ///< Sent by any device searching for a transmitter
+    DiscoveryResponse = 0x51, ///< TX → broadcast: confirms active transmitter
+    ReceiverPresence  = 0x52, ///< RX → broadcast: periodic presence announcement
+    ChannelMigration  = 0x53, ///< TX → broadcast: notifies channel change
+};
+
+// ── Device roles ────────────────────────────────────────────────────────
+
+enum class DeviceRole : uint8_t {
+    Transmitter = 0x01,
+    Receiver    = 0x02,
 };
 
 // ── Vehicle model types ─────────────────────────────────────────────────
@@ -158,19 +167,51 @@ struct __attribute__((packed)) BindPacket {
     uint8_t checksum;
 };
 
-struct __attribute__((packed)) AnnouncePacket {
+struct __attribute__((packed)) FunctionMapEntry {
+    uint8_t function; ///< odh::Function
+    uint8_t channel;  ///< Output channel index (0-based)
+};
+
+/// Discovery request – sent by any device searching for an active transmitter.
+struct __attribute__((packed)) DiscoveryRequestPacket {
+    uint8_t magic[2];
+    uint8_t version;
+    uint8_t type;   ///< PacketType::DiscoveryRequest
+    uint8_t mac[6]; ///< Sender's MAC address
+    uint8_t role;   ///< DeviceRole of the sender
+    uint8_t checksum;
+};
+
+/// Discovery response – sent by an active transmitter answering a request.
+struct __attribute__((packed)) DiscoveryResponsePacket {
+    uint8_t magic[2];
+    uint8_t version;
+    uint8_t type;         ///< PacketType::DiscoveryResponse
+    uint8_t mac[6];       ///< Transmitter's MAC address
+    uint8_t channel;      ///< Current WiFi channel (1, 6, or 11)
+    uint8_t device_count; ///< Number of known receivers on this channel
+    uint8_t checksum;
+};
+
+/// Receiver presence – periodic broadcast by a receiver on the active channel.
+struct __attribute__((packed)) ReceiverPresencePacket {
     uint8_t magic[2];
     uint8_t version;
-    uint8_t type;       ///< PacketType::Announce
+    uint8_t type;       ///< PacketType::ReceiverPresence
     uint8_t mac[6];
     uint8_t model_type; ///< ModelType
     char name[kVehicleNameMax];
     uint8_t checksum;
 };
 
-struct __attribute__((packed)) FunctionMapEntry {
-    uint8_t function; ///< odh::Function
-    uint8_t channel;  ///< Output channel index (0-based)
+/// Channel migration – sent by a transmitter before switching channels.
+struct __attribute__((packed)) ChannelMigrationPacket {
+    uint8_t magic[2];
+    uint8_t version;
+    uint8_t type;        ///< PacketType::ChannelMigration
+    uint8_t mac[6];      ///< Transmitter's MAC address
+    uint8_t new_channel; ///< Target WiFi channel (1, 6, or 11)
+    uint8_t checksum;
 };
 
 // ── Compile-time packet size verification ───────────────────────────────
@@ -178,7 +219,10 @@ struct __attribute__((packed)) FunctionMapEntry {
 static_assert(sizeof(ControlPacket) <= 250, "Control packet exceeds ESP-NOW limit");
 static_assert(sizeof(TelemetryPacket) <= 250, "Telemetry packet exceeds ESP-NOW limit");
 static_assert(sizeof(BindPacket) <= 250, "Bind packet exceeds ESP-NOW limit");
-static_assert(sizeof(AnnouncePacket) <= 250, "Announce packet exceeds ESP-NOW limit");
+static_assert(sizeof(DiscoveryRequestPacket) <= 250, "DiscoveryRequest packet exceeds ESP-NOW limit");
+static_assert(sizeof(DiscoveryResponsePacket) <= 250, "DiscoveryResponse packet exceeds ESP-NOW limit");
+static_assert(sizeof(ReceiverPresencePacket) <= 250, "ReceiverPresence packet exceeds ESP-NOW limit");
+static_assert(sizeof(ChannelMigrationPacket) <= 250, "ChannelMigration packet exceeds ESP-NOW limit");
 
 // ── Utility: XOR checksum ───────────────────────────────────────────────
 
@@ -222,74 +266,17 @@ inline bool verifyPacket(const uint8_t *data, int len) {
     return data[len - 1] == expected;
 }
 
-} // namespace odh
+// ── Discovery helper types ──────────────────────────────────────────────
+
+/// A vehicle discovered via presence broadcasts (transmitter side).
+struct DiscoveredVehicle {
+    uint8_t mac[6]{};
+    uint8_t modelType = 0;
+    char name[kVehicleNameMax]{};
+    uint32_t lastSeenMs = 0; ///< millis() timestamp of last presence
+    int8_t rssi         = 0; ///< RSSI of last presence packet (dBm)
+    uint8_t channel     = 0; ///< WiFi channel where this vehicle was seen
+    bool valid          = false;
+};
 
-// ── Legacy compatibility aliases (for gradual migration) ────────────────
-// These allow existing code to compile while transitioning to odh:: namespace.
-
-using OdhFunctionValue_t    = odh::FunctionValue;
-using OdhControlPacket_t    = odh::ControlPacket;
-using OdhTelemetryPacket_t  = odh::TelemetryPacket;
-using OdhBindPacket_t       = odh::BindPacket;
-using OdhAnnouncePacket_t   = odh::AnnouncePacket;
-using OdhFunctionMapEntry_t = odh::FunctionMapEntry;
-
-// Legacy enum values as constexpr
-inline constexpr uint8_t ODH_MAGIC_0          = odh::kMagic0;
-inline constexpr uint8_t ODH_MAGIC_1          = odh::kMagic1;
-inline constexpr uint8_t ODH_PROTOCOL_VERSION = odh::kProtocolVersion;
-inline constexpr uint8_t ODH_MAX_CHANNELS     = odh::kMaxChannels;
-inline constexpr uint16_t ODH_CHANNEL_MIN     = odh::kChannelMin;
-inline constexpr uint16_t ODH_CHANNEL_MID     = odh::kChannelMid;
-inline constexpr uint16_t ODH_CHANNEL_MAX     = odh::kChannelMax;
-inline constexpr uint8_t ODH_MAX_SENSORS      = odh::kMaxSensors;
-inline constexpr uint8_t ODH_MAX_FUNCTIONS    = odh::kMaxFunctions;
-inline constexpr uint8_t ODH_MAX_DISCOVERED   = odh::kMaxDiscovered;
-inline constexpr uint8_t ODH_VEHICLE_NAME_MAX = odh::kVehicleNameMax;
-
-// Legacy packet type values
-inline constexpr uint8_t ODH_PKT_CONTROL    = static_cast<uint8_t>(odh::PacketType::Control);
-inline constexpr uint8_t ODH_PKT_TELEMETRY  = static_cast<uint8_t>(odh::PacketType::Telemetry);
-inline constexpr uint8_t ODH_PKT_BIND       = static_cast<uint8_t>(odh::PacketType::Bind);
-inline constexpr uint8_t ODH_PKT_ACK        = static_cast<uint8_t>(odh::PacketType::Ack);
-inline constexpr uint8_t ODH_PKT_ANNOUNCE   = static_cast<uint8_t>(odh::PacketType::Announce);
-inline constexpr uint8_t ODH_PKT_DISCONNECT = static_cast<uint8_t>(odh::PacketType::Disconnect);
-
-// Legacy model type values
-inline constexpr uint8_t ODH_MODEL_GENERIC    = static_cast<uint8_t>(odh::ModelType::Generic);
-inline constexpr uint8_t ODH_MODEL_DUMP_TRUCK = static_cast<uint8_t>(odh::ModelType::DumpTruck);
-inline constexpr uint8_t ODH_MODEL_EXCAVATOR  = static_cast<uint8_t>(odh::ModelType::Excavator);
-inline constexpr uint8_t ODH_MODEL_TRACTOR    = static_cast<uint8_t>(odh::ModelType::Tractor);
-inline constexpr uint8_t ODH_MODEL_CRANE      = static_cast<uint8_t>(odh::ModelType::Crane);
-inline constexpr uint8_t ODH_MODEL_COUNT      = static_cast<uint8_t>(odh::ModelType::Count);
-
-// Legacy function values
-inline constexpr uint8_t ODH_FUNC_DRIVE    = static_cast<uint8_t>(odh::Function::Drive);
-inline constexpr uint8_t ODH_FUNC_STEERING = static_cast<uint8_t>(odh::Function::Steering);
-inline constexpr uint8_t ODH_FUNC_AUX1     = static_cast<uint8_t>(odh::Function::Aux1);
-inline constexpr uint8_t ODH_FUNC_AUX2     = static_cast<uint8_t>(odh::Function::Aux2);
-inline constexpr uint8_t ODH_FUNC_AUX3     = static_cast<uint8_t>(odh::Function::Aux3);
-inline constexpr uint8_t ODH_FUNC_AUX4     = static_cast<uint8_t>(odh::Function::Aux4);
-inline constexpr uint8_t ODH_FUNC_BOOM_UD  = static_cast<uint8_t>(odh::Function::BoomUD);
-inline constexpr uint8_t ODH_FUNC_BOOM_LR  = static_cast<uint8_t>(odh::Function::BoomLR);
-inline constexpr uint8_t ODH_FUNC_BUCKET   = static_cast<uint8_t>(odh::Function::Bucket);
-inline constexpr uint8_t ODH_FUNC_SWING    = static_cast<uint8_t>(odh::Function::Swing);
-inline constexpr uint8_t ODH_FUNC_DUMP_BED = static_cast<uint8_t>(odh::Function::DumpBed);
-inline constexpr uint8_t ODH_FUNC_PTO      = static_cast<uint8_t>(odh::Function::Pto);
-inline constexpr uint8_t ODH_FUNC_HITCH    = static_cast<uint8_t>(odh::Function::Hitch);
-inline constexpr uint8_t ODH_FUNC_WINCH    = static_cast<uint8_t>(odh::Function::Winch);
-inline constexpr uint8_t ODH_FUNC_TRACK_L  = static_cast<uint8_t>(odh::Function::TrackL);
-inline constexpr uint8_t ODH_FUNC_TRACK_R  = static_cast<uint8_t>(odh::Function::TrackR);
-inline constexpr uint8_t ODH_FUNC_NONE     = static_cast<uint8_t>(odh::Function::None);
-
-// Legacy link state values
-inline constexpr uint8_t ODH_LINK_DISCONNECTED = static_cast<uint8_t>(odh::LinkState::Disconnected);
-inline constexpr uint8_t ODH_LINK_BINDING      = static_cast<uint8_t>(odh::LinkState::Binding);
-inline constexpr uint8_t ODH_LINK_CONNECTED    = static_cast<uint8_t>(odh::LinkState::Connected);
-inline constexpr uint8_t ODH_LINK_FAILSAFE     = static_cast<uint8_t>(odh::LinkState::Failsafe);
-inline constexpr uint8_t ODH_LINK_SCANNING     = static_cast<uint8_t>(odh::LinkState::Scanning);
-
-// Legacy checksum function
-inline uint8_t odh_checksum(const uint8_t *data, uint16_t len) {
-    return odh::checksum(data, len);
-}
+} // namespace odh
diff --git a/firmware/lib/odh-radio/IRadioLink.h b/firmware/lib/odh-radio/IRadioLink.h
index 75bf8aa..44ffa61 100644
--- a/firmware/lib/odh-radio/IRadioLink.h
+++ b/firmware/lib/odh-radio/IRadioLink.h
@@ -42,14 +42,13 @@ using ControlCallback = std::function<void(const ControlPacket &pkt)>;
 /// Callback type for received telemetry packets (transmitter side).
 using TelemetryCallback = std::function<void(const TelemetryPacket &pkt)>;
 
-/// A vehicle discovered via announce broadcasts (transmitter side).
-struct DiscoveredVehicle {
-    uint8_t mac[6]{};
-    uint8_t modelType = 0;
-    char name[kVehicleNameMax]{};
-    uint32_t lastSeenMs = 0; ///< millis() timestamp of last announce
-    int8_t rssi         = 0; ///< RSSI of last announce packet (dBm)
-    bool valid          = false;
-};
+/// Callback when a DiscoveryResponse is received.
+using DiscoveryResponseCallback = std::function<void(uint8_t channel, int8_t rssi, uint8_t deviceCount)>;
+
+/// Callback when a ChannelMigration is received.
+using ChannelMigrationCallback = std::function<void(uint8_t newChannel)>;
+
+/// Callback when a DiscoveryRequest is received (transmitter answers these).
+using DiscoveryRequestCallback = std::function<void(const uint8_t *mac, DeviceRole role)>;
 
 } // namespace odh
diff --git a/firmware/lib/odh-radio/ReceiverRadioLink.cpp b/firmware/lib/odh-radio/ReceiverRadioLink.cpp
index 84da2e8..8672f32 100644
--- a/firmware/lib/odh-radio/ReceiverRadioLink.cpp
+++ b/firmware/lib/odh-radio/ReceiverRadioLink.cpp
@@ -54,8 +54,7 @@ ReceiverRadioLink::ReceiverRadioLink() = default;
 
 // ── Initialisation ──────────────────────────────────────────────────────
 
-bool ReceiverRadioLink::begin(uint8_t wifiChannel, ControlCallback callback) {
-    _wifiChannel     = wifiChannel;
+bool ReceiverRadioLink::begin(ControlCallback callback) {
     _controlCallback = std::move(callback);
     sInstance        = this;
 
@@ -78,35 +77,49 @@ bool ReceiverRadioLink::begin(uint8_t wifiChannel, ControlCallback callback) {
     return true;
 }
 
-// ── Announcing ──────────────────────────────────────────────────────────
+// ── Channel management ──────────────────────────────────────────────────
 
-void ReceiverRadioLink::beginAnnouncing(const char *name, uint8_t modelType) {
-    if (!_ready)
-        return;
+bool ReceiverRadioLink::setChannel(uint8_t channel) {
+    _wifiChannel = channel;
+#ifdef NATIVE_SIM
+    sim_set_wifi_channel(channel);
+#else
+    esp_wifi_set_channel(channel, WIFI_SECOND_CHAN_NONE);
+#endif
+    return true;
+}
 
+// ── Presence (replaces announcing) ──────────────────────────────────────
+
+void ReceiverRadioLink::configurePresence(const char *name, uint8_t modelType) {
     _modelType = modelType;
     std::memset(_vehicleName, 0, sizeof(_vehicleName));
     std::strncpy(_vehicleName, name, kVehicleNameMax - 1);
+}
+
+void ReceiverRadioLink::beginPresence() {
+    if (!_ready)
+        return;
 
     addPeer(kBroadcastMac);
-    _announcing     = true;
-    _lastAnnounceMs = 0;
+    _presencing     = true;
+    _lastPresenceMs = 0;
 }
 
-void ReceiverRadioLink::tickAnnounce(uint32_t intervalMs) {
-    if (!_announcing)
+void ReceiverRadioLink::tickPresence(uint32_t intervalMs) {
+    if (!_presencing)
         return;
 
     const uint32_t now = millis();
-    if ((now - _lastAnnounceMs) >= intervalMs) {
-        sendAnnounce();
-        _lastAnnounceMs = now;
+    if ((now - _lastPresenceMs) >= intervalMs) {
+        sendPresencePacket();
+        _lastPresenceMs = now;
     }
 }
 
-void ReceiverRadioLink::sendAnnounce() {
-    AnnouncePacket pkt{};
-    fillHeader(pkt, PacketType::Announce);
+void ReceiverRadioLink::sendPresencePacket() {
+    ReceiverPresencePacket pkt{};
+    fillHeader(pkt, PacketType::ReceiverPresence);
     pkt.model_type = _modelType;
     esp_read_mac(pkt.mac, ESP_MAC_WIFI_STA);
     std::strncpy(pkt.name, _vehicleName, kVehicleNameMax - 1);
@@ -116,15 +129,41 @@ void ReceiverRadioLink::sendAnnounce() {
     esp_now_send(kBroadcastMac, reinterpret_cast<uint8_t *>(&pkt), sizeof(pkt));
 }
 
-void ReceiverRadioLink::stopAnnouncing() {
-    _announcing = false;
+void ReceiverRadioLink::stopPresence() {
+    _presencing = false;
     delPeer(kBroadcastMac);
 }
 
-void ReceiverRadioLink::resumeAnnouncing() {
+void ReceiverRadioLink::resumePresence() {
     addPeer(kBroadcastMac);
-    _announcing     = true;
-    _lastAnnounceMs = 0;
+    _presencing     = true;
+    _lastPresenceMs = 0;
+}
+
+// ── Discovery ───────────────────────────────────────────────────────────
+
+bool ReceiverRadioLink::sendDiscoveryRequest() {
+    if (!_ready)
+        return false;
+
+    addPeer(kBroadcastMac);
+
+    DiscoveryRequestPacket pkt{};
+    fillHeader(pkt, PacketType::DiscoveryRequest);
+    esp_read_mac(pkt.mac, ESP_MAC_WIFI_STA);
+    pkt.role = static_cast<uint8_t>(DeviceRole::Receiver);
+    setChecksum(pkt);
+
+    auto rc = esp_now_send(kBroadcastMac, reinterpret_cast<uint8_t *>(&pkt), sizeof(pkt));
+    return rc == ESP_OK;
+}
+
+void ReceiverRadioLink::onDiscoveryResponse(DiscoveryResponseCallback cb) {
+    _discoveryResponseCallback = std::move(cb);
+}
+
+void ReceiverRadioLink::onChannelMigration(ChannelMigrationCallback cb) {
+    _channelMigrationCallback = std::move(cb);
 }
 
 // ── Telemetry ───────────────────────────────────────────────────────────
@@ -168,7 +207,7 @@ bool ReceiverRadioLink::checkLinkTimeout(uint32_t timeoutMs) {
         std::memset(_txMac, 0, sizeof(_txMac));
         _bound         = false;
         _lastControlMs = 0;
-        resumeAnnouncing();
+        resumePresence();
         return true;
     }
     return false;
@@ -195,7 +234,7 @@ void ReceiverRadioLink::handleReceive(const uint8_t * /*mac*/, const uint8_t *da
 
     const auto type = static_cast<PacketType>(data[3]);
 
-    // ── Bind request from transmitter (while announcing) ────────────
+    // ── Bind request from transmitter (while presencing) ────────────
     if (type == PacketType::Bind && !_bound) {
         if (len < static_cast<int>(sizeof(BindPacket)))
             return;
@@ -213,7 +252,7 @@ void ReceiverRadioLink::handleReceive(const uint8_t * /*mac*/, const uint8_t *da
         esp_now_send(_txMac, reinterpret_cast<uint8_t *>(&reply), sizeof(reply));
 
         _bound = true;
-        stopAnnouncing();
+        stopPresence();
         return;
     }
 
@@ -226,7 +265,7 @@ void ReceiverRadioLink::handleReceive(const uint8_t * /*mac*/, const uint8_t *da
         std::memset(_txMac, 0, sizeof(_txMac));
         _bound         = false;
         _lastControlMs = 0;
-        resumeAnnouncing();
+        resumePresence();
         return;
     }
 
@@ -243,6 +282,29 @@ void ReceiverRadioLink::handleReceive(const uint8_t * /*mac*/, const uint8_t *da
         if (_controlCallback) {
             _controlCallback(*cp);
         }
+        return;
+    }
+
+    // ── DiscoveryResponse (during channel scanning) ────────────
+    if (type == PacketType::DiscoveryResponse) {
+        if (len < static_cast<int>(sizeof(DiscoveryResponsePacket)))
+            return;
+        const auto *dp = reinterpret_cast<const DiscoveryResponsePacket *>(data);
+        if (_discoveryResponseCallback) {
+            _discoveryResponseCallback(dp->channel, sPromiscRssi, dp->device_count);
+        }
+        return;
+    }
+
+    // ── ChannelMigration (transmitter is switching channels) ───
+    if (type == PacketType::ChannelMigration) {
+        if (len < static_cast<int>(sizeof(ChannelMigrationPacket)))
+            return;
+        const auto *mp = reinterpret_cast<const ChannelMigrationPacket *>(data);
+        if (_channelMigrationCallback) {
+            _channelMigrationCallback(mp->new_channel);
+        }
+        return;
     }
 }
 
diff --git a/firmware/lib/odh-radio/ReceiverRadioLink.h b/firmware/lib/odh-radio/ReceiverRadioLink.h
index 31a5f1b..248b803 100644
--- a/firmware/lib/odh-radio/ReceiverRadioLink.h
+++ b/firmware/lib/odh-radio/ReceiverRadioLink.h
@@ -23,7 +23,7 @@
  * ReceiverRadioLink – ESP-NOW radio link for the receiver side.
  *
  * Discovery-based connection model (receiver side):
- *   1. Receiver broadcasts AnnouncePacket periodically.
+ *   1. Receiver broadcasts ReceiverPresencePacket periodically.
  *   2. Transmitter selects this receiver and sends BindPacket.
  *   3. Receiver replies with its own BindPacket and stops announcing.
  *   4. Subsequent communication is directed (TX MAC <-> RX MAC).
@@ -44,92 +44,87 @@ namespace odh {
 class ReceiverRadioLink {
 public:
     ReceiverRadioLink();
-    ~ReceiverRadioLink() = default;
-
-    // Non-copyable, non-movable.
+    ~ReceiverRadioLink()                                    = default;
     ReceiverRadioLink(const ReceiverRadioLink &)            = delete;
     ReceiverRadioLink &operator=(const ReceiverRadioLink &) = delete;
 
-    /**
-     * Initialise WiFi in STA mode and start ESP-NOW.
-     *
-     * @param wifiChannel  WiFi channel to listen on (must match the transmitter).
-     * @param callback     Called when a valid control packet arrives.
-     * @return true on success.
-     */
-    bool begin(uint8_t wifiChannel, ControlCallback callback);
-
-    /**
-     * Begin periodic announce broadcasts.
-     *
-     * @param name       Vehicle name (max kVehicleNameMax chars).
-     * @param modelType  ModelType identifying this vehicle.
-     */
-    void beginAnnouncing(const char *name, uint8_t modelType);
-
-    /**
-     * Send one announce broadcast if enough time has elapsed.
-     * Call periodically from a FreeRTOS task.
-     */
-    void tickAnnounce(uint32_t intervalMs);
-
-    /// True if the receiver is currently announcing.
-    bool isAnnouncing() const {
-        return _announcing;
+    /// Initialize WiFi and ESP-NOW. Does NOT set channel yet.
+    bool begin(ControlCallback controlCallback);
+
+    /// Switch to a different WiFi channel at runtime.
+    bool setChannel(uint8_t channel);
+
+    /// Get the current WiFi channel.
+    uint8_t currentChannel() const {
+        return _wifiChannel;
     }
 
-    /**
-     * Send a telemetry packet to the bound transmitter.
-     */
-    bool sendTelemetry(uint16_t batteryMv, int8_t rssi, uint8_t linkState, uint8_t modelType, uint8_t modelFlags, const uint16_t *sensors, uint8_t sensorCount);
+    // ── Presence mode (replaces old announcing) ──────────────────
+
+    /// Configure presence parameters (call before beginPresence).
+    void configurePresence(const char *name, uint8_t modelType);
+
+    /// Start periodic presence broadcasts on the current channel.
+    void beginPresence();
+
+    /// Send one presence broadcast if enough time has elapsed.
+    void tickPresence(uint32_t intervalMs);
+
+    /// True if currently broadcasting presence.
+    bool isPresencing() const {
+        return _presencing;
+    }
+
+    // ── Discovery ───────────────────────────────────────────────
+
+    /// Send a DiscoveryRequest broadcast on the current channel.
+    bool sendDiscoveryRequest();
 
-    /// True if a transmitter is currently connected.
+    /// Register callback for DiscoveryResponse packets.
+    void onDiscoveryResponse(DiscoveryResponseCallback cb);
+
+    /// Register callback for ChannelMigration packets.
+    void onChannelMigration(ChannelMigrationCallback cb);
+
+    // ── Telemetry & link state ──────────────────────────────────
+
+    bool sendTelemetry(uint16_t batteryMv, int8_t rssi, uint8_t linkState, uint8_t modelType, uint8_t modelFlags, const uint16_t *sensors, uint8_t sensorCount);
     bool isBound() const {
         return _bound;
     }
-
-    /// Milliseconds since the last control packet was received.
     uint32_t msSinceLastControl() const;
-
-    /// RSSI (dBm) of the last received control packet.
     int8_t lastRssi() const {
         return _lastRssi;
     }
-
-    /**
-     * Check link timeout.  If no control packet for @p timeoutMs,
-     * automatically disconnects and resumes announcing.
-     *
-     * @return true if the link was dropped.
-     */
     bool checkLinkTimeout(uint32_t timeoutMs);
 
 private:
     bool _ready                        = false;
     bool _bound                        = false;
-    bool _announcing                   = false;
+    bool _presencing                   = false;
     uint8_t _txMac[6]                  = {};
     uint16_t _txSequence               = 0;
     uint32_t _lastControlMs            = 0;
-    uint32_t _lastAnnounceMs           = 0;
-    uint8_t _wifiChannel               = 1;
+    uint32_t _lastPresenceMs           = 0;
+    uint8_t _wifiChannel               = 0;
     uint8_t _modelType                 = 0;
     char _vehicleName[kVehicleNameMax] = {};
+
     ControlCallback _controlCallback;
+    DiscoveryResponseCallback _discoveryResponseCallback;
+    ChannelMigrationCallback _channelMigrationCallback;
     volatile int8_t _lastRssi = 0;
 
-    // ESP-NOW static callbacks
     static void onReceive(const uint8_t *mac, const uint8_t *data, int len);
     static void onSent(const uint8_t *mac, esp_now_send_status_t status);
-
     void handleReceive(const uint8_t *mac, const uint8_t *data, int len);
+
     bool addPeer(const uint8_t mac[6]);
     void delPeer(const uint8_t mac[6]);
-    void sendAnnounce();
-    void stopAnnouncing();
-    void resumeAnnouncing();
+    void sendPresencePacket();
+    void stopPresence();
+    void resumePresence();
 
-    // Active instance for static callback forwarding.
     static ReceiverRadioLink *sInstance;
 };
 
diff --git a/firmware/lib/odh-radio/TransmitterRadioLink.cpp b/firmware/lib/odh-radio/TransmitterRadioLink.cpp
index 4f4b19f..4adea84 100644
--- a/firmware/lib/odh-radio/TransmitterRadioLink.cpp
+++ b/firmware/lib/odh-radio/TransmitterRadioLink.cpp
@@ -27,6 +27,10 @@
 #include <algorithm>
 #include <cstring>
 
+#ifndef NATIVE_SIM
+#include <esp_wifi.h>
+#endif
+
 namespace odh {
 
 TransmitterRadioLink *TransmitterRadioLink::sInstance = nullptr;
@@ -39,8 +43,7 @@ TransmitterRadioLink::TransmitterRadioLink() = default;
 
 // ── Initialisation ──────────────────────────────────────────────────────
 
-bool TransmitterRadioLink::begin(uint8_t wifiChannel, TelemetryCallback callback) {
-    _wifiChannel       = wifiChannel;
+bool TransmitterRadioLink::begin(TelemetryCallback callback) {
     _telemetryCallback = std::move(callback);
     sInstance          = this;
 
@@ -58,6 +61,77 @@ bool TransmitterRadioLink::begin(uint8_t wifiChannel, TelemetryCallback callback
     return true;
 }
 
+// ── Channel management ──────────────────────────────────────────────────
+
+bool TransmitterRadioLink::setChannel(uint8_t channel) {
+    _wifiChannel = channel;
+#ifdef NATIVE_SIM
+    sim_set_wifi_channel(channel);
+#else
+    esp_wifi_set_channel(channel, WIFI_SECOND_CHAN_NONE);
+#endif
+    return true;
+}
+
+// ── Discovery ───────────────────────────────────────────────────────────
+
+bool TransmitterRadioLink::sendDiscoveryRequest() {
+    if (!_ready)
+        return false;
+
+    addPeer(kBroadcastMac);
+
+    DiscoveryRequestPacket pkt{};
+    fillHeader(pkt, PacketType::DiscoveryRequest);
+    esp_read_mac(pkt.mac, ESP_MAC_WIFI_STA);
+    pkt.role = static_cast<uint8_t>(DeviceRole::Transmitter);
+    setChecksum(pkt);
+
+    auto rc = esp_now_send(kBroadcastMac, reinterpret_cast<uint8_t *>(&pkt), sizeof(pkt));
+    return rc == ESP_OK;
+}
+
+bool TransmitterRadioLink::sendDiscoveryResponse(uint8_t channel) {
+    if (!_ready)
+        return false;
+
+    addPeer(kBroadcastMac);
+
+    DiscoveryResponsePacket pkt{};
+    fillHeader(pkt, PacketType::DiscoveryResponse);
+    esp_read_mac(pkt.mac, ESP_MAC_WIFI_STA);
+    pkt.channel      = channel;
+    pkt.device_count = _discoveredCount;
+    setChecksum(pkt);
+
+    auto rc = esp_now_send(kBroadcastMac, reinterpret_cast<uint8_t *>(&pkt), sizeof(pkt));
+    return rc == ESP_OK;
+}
+
+bool TransmitterRadioLink::sendChannelMigration(uint8_t newChannel) {
+    if (!_ready)
+        return false;
+
+    addPeer(kBroadcastMac);
+
+    ChannelMigrationPacket pkt{};
+    fillHeader(pkt, PacketType::ChannelMigration);
+    esp_read_mac(pkt.mac, ESP_MAC_WIFI_STA);
+    pkt.new_channel = newChannel;
+    setChecksum(pkt);
+
+    auto rc = esp_now_send(kBroadcastMac, reinterpret_cast<uint8_t *>(&pkt), sizeof(pkt));
+    return rc == ESP_OK;
+}
+
+void TransmitterRadioLink::onDiscoveryResponse(DiscoveryResponseCallback cb) {
+    _discoveryResponseCallback = std::move(cb);
+}
+
+void TransmitterRadioLink::onDiscoveryRequest(DiscoveryRequestCallback cb) {
+    _discoveryRequestCallback = std::move(cb);
+}
+
 // ── Scanning ────────────────────────────────────────────────────────────
 
 void TransmitterRadioLink::startScanning() {
@@ -190,12 +264,36 @@ void TransmitterRadioLink::handleReceive(const uint8_t * /*mac*/, const uint8_t
 
     const auto type = static_cast<PacketType>(data[3]);
 
-    // ── Announce packets (while scanning) ───────────────────────────
-    if (type == PacketType::Announce && _scanning) {
-        if (len < static_cast<int>(sizeof(AnnouncePacket)))
+    // ── DiscoveryRequest (answer if we're an active transmitter) ─
+    if (type == PacketType::DiscoveryRequest) {
+        if (len < static_cast<int>(sizeof(DiscoveryRequestPacket)))
+            return;
+        const auto *rp = reinterpret_cast<const DiscoveryRequestPacket *>(data);
+        if (_discoveryRequestCallback) {
+            _discoveryRequestCallback(rp->mac, static_cast<DeviceRole>(rp->role));
+        }
+        // Auto-reply with DiscoveryResponse
+        sendDiscoveryResponse(_wifiChannel);
+        return;
+    }
+
+    // ── DiscoveryResponse (from another transmitter during scan) ─
+    if (type == PacketType::DiscoveryResponse) {
+        if (len < static_cast<int>(sizeof(DiscoveryResponsePacket)))
+            return;
+        const auto *dp = reinterpret_cast<const DiscoveryResponsePacket *>(data);
+        if (_discoveryResponseCallback) {
+            _discoveryResponseCallback(dp->channel, _lastRssi, dp->device_count);
+        }
+        return;
+    }
+
+    // ── Presence packets (while not bound) ────────────────────────
+    if (type == PacketType::ReceiverPresence && !_bound) {
+        if (len < static_cast<int>(sizeof(ReceiverPresencePacket)))
             return;
 
-        const auto *ap = reinterpret_cast<const AnnouncePacket *>(data);
+        const auto *ap = reinterpret_cast<const ReceiverPresencePacket *>(data);
 
         // Update existing entry or add new one.
         for (uint8_t i = 0; i < _discoveredCount; i++) {
@@ -203,6 +301,7 @@ void TransmitterRadioLink::handleReceive(const uint8_t * /*mac*/, const uint8_t
                 _discovered[i].modelType  = ap->model_type;
                 _discovered[i].lastSeenMs = millis();
                 _discovered[i].rssi       = _lastRssi;
+                _discovered[i].channel    = _wifiChannel;
                 std::memset(_discovered[i].name, 0, kVehicleNameMax);
                 std::strncpy(_discovered[i].name, ap->name, kVehicleNameMax - 1);
                 return;
@@ -215,6 +314,7 @@ void TransmitterRadioLink::handleReceive(const uint8_t * /*mac*/, const uint8_t
             v.modelType  = ap->model_type;
             v.lastSeenMs = millis();
             v.rssi       = _lastRssi;
+            v.channel    = _wifiChannel;
             v.valid      = true;
             std::memset(v.name, 0, kVehicleNameMax);
             std::strncpy(v.name, ap->name, kVehicleNameMax - 1);
diff --git a/firmware/lib/odh-radio/TransmitterRadioLink.h b/firmware/lib/odh-radio/TransmitterRadioLink.h
index 7038770..18130eb 100644
--- a/firmware/lib/odh-radio/TransmitterRadioLink.h
+++ b/firmware/lib/odh-radio/TransmitterRadioLink.h
@@ -40,84 +40,70 @@ namespace odh {
 class TransmitterRadioLink {
 public:
     TransmitterRadioLink();
-    ~TransmitterRadioLink() = default;
-
-    // Non-copyable, non-movable.
+    ~TransmitterRadioLink()                                       = default;
     TransmitterRadioLink(const TransmitterRadioLink &)            = delete;
     TransmitterRadioLink &operator=(const TransmitterRadioLink &) = delete;
 
-    /**
-     * Initialise WiFi in STA mode and start ESP-NOW.
-     *
-     * @param wifiChannel  WiFi channel to use (1-13).
-     * @param callback     Called when a telemetry packet arrives.
-     * @return true on success.
-     */
-    bool begin(uint8_t wifiChannel, TelemetryCallback callback);
+    /// Initialize WiFi and ESP-NOW. Does NOT set channel yet.
+    bool begin(TelemetryCallback callback);
 
-    /// Enter scanning mode – listen for receiver announces.
-    void startScanning();
+    /// Switch to a different WiFi channel at runtime.
+    bool setChannel(uint8_t channel);
+
+    /// Get the current WiFi channel.
+    uint8_t currentChannel() const {
+        return _wifiChannel;
+    }
+
+    // ── Discovery ───────────────────────────────────────────────
+
+    /// Send a DiscoveryRequest broadcast (for finding other transmitters).
+    bool sendDiscoveryRequest();
+
+    /// Send a DiscoveryResponse (called when a DiscoveryRequest is received).
+    bool sendDiscoveryResponse(uint8_t channel);
 
-    /// True if currently scanning.
+    /// Send ChannelMigration notification before switching channels.
+    bool sendChannelMigration(uint8_t newChannel);
+
+    /// Register callback for DiscoveryResponse packets (from other TXs).
+    void onDiscoveryResponse(DiscoveryResponseCallback cb);
+
+    /// Register callback for DiscoveryRequest packets (auto-reply).
+    void onDiscoveryRequest(DiscoveryRequestCallback cb);
+
+    // ── Scanning (listen for receiver presence) ─────────────────
+
+    void startScanning();
     bool isScanning() const {
         return _scanning;
     }
 
-    /**
-     * Connect to a discovered vehicle by index.
-     * Sends a bind packet and waits up to @p timeoutMs for a reply.
-     *
-     * @return true if the connection was established.
-     */
-    bool connectTo(uint8_t index, uint32_t timeoutMs = 5000);
+    // ── Connect / Disconnect ────────────────────────────────────
 
-    /// Disconnect from the current receiver and resume scanning.
+    bool connectTo(uint8_t index, uint32_t timeoutMs = 5000);
     void disconnect();
-
-    /**
-     * Send a control packet to the connected receiver.
-     *
-     * @param functions  Array of function-value pairs.
-     * @param count      Number of entries (≤ kMaxFunctions).
-     * @param flags      Packet flags.
-     * @return true if ESP-NOW accepted the packet.
-     */
     bool sendControl(const FunctionValue *functions, uint8_t count, uint8_t flags = 0);
-
-    /// True if a receiver is currently connected.
     bool isBound() const {
         return _bound;
     }
-
-    /// True if the last sendControl() was acknowledged.
     bool lastSendOk() const {
         return _lastSendOk;
     }
-
-    /// RSSI of the last received packet (dBm).
     int8_t lastRssi() const {
         return _lastRssi;
     }
-
-    /// Copy the bound receiver's MAC address into @p out.
     void boundMac(uint8_t out[6]) const;
-
-    /// Sequence counter for the next outgoing control packet.
     uint16_t txSequence() const {
         return _txSequence;
     }
 
-    // ── Discovered vehicle list ─────────────────────────────────────
+    // ── Discovered vehicle list ─────────────────────────────────
 
-    /// Number of currently discovered vehicles.
     uint8_t discoveredCount() const {
         return _discoveredCount;
     }
-
-    /// Access a discovered vehicle by index (nullptr if out of range).
     const DiscoveredVehicle *discoveredVehicle(uint8_t index) const;
-
-    /// Remove stale vehicles not seen for @p timeoutMs.
     void pruneStaleVehicles(uint32_t timeoutMs);
 
 private:
@@ -128,19 +114,19 @@ class TransmitterRadioLink {
     int8_t _lastRssi     = 0;
     uint8_t _peerMac[6]  = {};
     uint16_t _txSequence = 0;
+    uint8_t _wifiChannel = 0;
+
     TelemetryCallback _telemetryCallback;
-    uint8_t _wifiChannel = 1;
+    DiscoveryResponseCallback _discoveryResponseCallback;
+    DiscoveryRequestCallback _discoveryRequestCallback;
 
     DiscoveredVehicle _discovered[kMaxDiscovered] = {};
     uint8_t _discoveredCount                      = 0;
 
-    // ESP-NOW static callbacks
     static void onReceive(const uint8_t *mac, const uint8_t *data, int len);
     static void onSent(const uint8_t *mac, esp_now_send_status_t status);
-
     void handleReceive(const uint8_t *mac, const uint8_t *data, int len);
     void handleSent(esp_now_send_status_t status);
-
     bool addPeer(const uint8_t mac[6]);
     void delPeer(const uint8_t mac[6]);
 
diff --git a/firmware/sim/include/WiFi.h b/firmware/sim/include/WiFi.h
index 6ff84b6..a7b8536 100644
--- a/firmware/sim/include/WiFi.h
+++ b/firmware/sim/include/WiFi.h
@@ -27,6 +27,7 @@
 #define SIM_WIFI_H
 
 #include "Arduino.h"
+#include "esp_now.h"
 
 #include <cstdint>
 
@@ -60,6 +61,9 @@ class WiFiClass {
     IPAddress softAPIP() {
         return IPAddress();
     }
+    uint8_t channel() {
+        return sim_get_wifi_channel();
+    }
 };
 
 extern WiFiClass WiFi;
diff --git a/firmware/sim/include/esp_now.h b/firmware/sim/include/esp_now.h
index 1a79e2d..a8863ca 100644
--- a/firmware/sim/include/esp_now.h
+++ b/firmware/sim/include/esp_now.h
@@ -22,11 +22,9 @@
 /**
  * esp_now.h – Simulation shim using UDP sockets.
  *
- * ESP-NOW packets are sent/received over localhost UDP:
- *   - Transmitter listens on port 6001, sends to port 6002
- *   - Receiver   listens on port 6002, sends to port 6001
- *
- * Compile with -DSIM_TX for the transmitter role or -DSIM_RX for receiver.
+ * Each WiFi channel maps to a shared UDP port (port = 7000 + channel).
+ * All devices on the same channel listen and send on the same port.
+ * Self-packets are filtered by comparing the source MAC.
  */
 
 #ifndef SIM_ESP_NOW_H
@@ -66,12 +64,10 @@ bool esp_now_is_peer_exist(const uint8_t *peer_addr);
 
 /* ── Simulation control ─────────────────────────────────────────────────── */
 
-#ifdef SIM_TX
-#define SIM_LISTEN_PORT 6001
-#define SIM_SEND_PORT 6002
-#else
-#define SIM_LISTEN_PORT 6002
-#define SIM_SEND_PORT 6001
-#endif
+/// Set the simulated WiFi channel. Switches the underlying UDP port.
+void sim_set_wifi_channel(uint8_t channel);
+
+/// Get the current simulated WiFi channel.
+uint8_t sim_get_wifi_channel();
 
 #endif /* SIM_ESP_NOW_H */
diff --git a/firmware/sim/sim_build.py b/firmware/sim/sim_build.py
index ed3bf84..fb80bfd 100644
--- a/firmware/sim/sim_build.py
+++ b/firmware/sim/sim_build.py
@@ -29,10 +29,14 @@
 import os
 
 sim_dir = os.path.abspath(os.path.join(env.subst("$PROJECT_DIR"), "sim"))
+lib_dir = os.path.abspath(os.path.join(env.subst("$PROJECT_DIR"), "lib"))
 
 # Add shim headers to the include path (highest priority).
 env.Prepend(CPPPATH=[os.path.join(sim_dir, "include")])
 
+# Add shared library headers needed by shim sources.
+env.Append(CPPPATH=[os.path.join(lib_dir, "odh-channel")])
+
 # Compile the shim source files as part of the build.
 env.BuildSources(
     os.path.join(env.subst("$BUILD_DIR"), "sim_shim"),
diff --git a/firmware/sim/src/sim_espnow.cpp b/firmware/sim/src/sim_espnow.cpp
index 11777d7..4c6c289 100644
--- a/firmware/sim/src/sim_espnow.cpp
+++ b/firmware/sim/src/sim_espnow.cpp
@@ -22,13 +22,15 @@
 /**
  * sim_espnow.cpp – ESP-NOW over UDP sockets.
  *
- * Each simulated device listens on its own port (TX=6001, RX=6002) and
- * sends to the other's port.  Packets include a 6-byte source MAC header
- * prepended to the original payload so the receive callback gets the
- * sender's address.
+ * Each WiFi channel maps to a shared UDP port (port = 7000 + channel).
+ * All devices on the same channel listen and send on the same port.
+ * Packets include a 6-byte source MAC header prepended to the original
+ * payload so the receive callback gets the sender's address.
+ * Self-packets are filtered by comparing the source MAC.
  */
 
 #include "Arduino.h"
+#include "Channel.h"
 #include "esp_now.h"
 
 #include <arpa/inet.h>
@@ -56,57 +58,75 @@ struct PeerEntry {
 static std::vector<PeerEntry> s_peers;
 static std::mutex s_peerMutex;
 
-static uint8_t s_localMac[6] = {};
+static uint8_t s_localMac[6]    = {};
+static uint8_t s_currentChannel = 1;
 
-/* ── Listener thread ────────────────────────────────────────────────────── */
+/* ── Socket helper ──────────────────────────────────────────────────────── */
 
-static void *recvLoop(void *) {
-    uint8_t buf[6 + ESP_NOW_MAX_DATA_LEN]; /* [mac(6)] [payload] */
-    while (s_running) {
-        ssize_t n = recvfrom(s_sock, buf, sizeof(buf), 0, nullptr, nullptr);
-        if (n > 6 && s_recvCb) {
-            s_recvCb(buf, buf + 6, static_cast<int>(n - 6));
-        }
+static void rebindSocket() {
+    if (s_sock >= 0) {
+        close(s_sock);
+        s_sock = -1;
     }
-    return nullptr;
-}
-
-/* ── ESP-NOW API ────────────────────────────────────────────────────────── */
 
-int esp_now_init() {
-    /* Create a UDP socket bound to the listen port. */
     s_sock = socket(AF_INET, SOCK_DGRAM, 0);
     if (s_sock < 0) {
         perror("[SIM] socket");
-        return ESP_FAIL;
+        return;
     }
 
     int opt = 1;
     setsockopt(s_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+    setsockopt(s_sock, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
+
+    uint16_t port = odh::channel::channelToSimPort(s_currentChannel);
 
     struct sockaddr_in addr{};
     addr.sin_family      = AF_INET;
-    addr.sin_port        = htons(SIM_LISTEN_PORT);
+    addr.sin_port        = htons(port);
     addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 
     if (bind(s_sock, reinterpret_cast<sockaddr *>(&addr), sizeof(addr)) < 0) {
         perror("[SIM] bind");
         close(s_sock);
         s_sock = -1;
-        return ESP_FAIL;
+        return;
     }
 
-    /* Set a receive timeout so the thread can check s_running. */
-    struct timeval tv{.tv_sec = 0, .tv_usec = 100000}; /* 100 ms */
+    struct timeval tv{.tv_sec = 0, .tv_usec = 100000};
     setsockopt(s_sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 
+    printf("[SIM] Channel %u → UDP port %u\n", s_currentChannel, port);
+}
+
+/* ── Listener thread ────────────────────────────────────────────────────── */
+
+static void *recvLoop(void *) {
+    uint8_t buf[6 + ESP_NOW_MAX_DATA_LEN]; /* [mac(6)] [payload] */
+    while (s_running) {
+        ssize_t n = recvfrom(s_sock, buf, sizeof(buf), 0, nullptr, nullptr);
+        if (n > 6 && s_recvCb) {
+            if (memcmp(buf, s_localMac, 6) == 0)
+                continue;
+            s_recvCb(buf, buf + 6, static_cast<int>(n - 6));
+        }
+    }
+    return nullptr;
+}
+
+/* ── ESP-NOW API ────────────────────────────────────────────────────────── */
+
+int esp_now_init() {
     esp_read_mac(s_localMac, ESP_MAC_WIFI_STA);
 
+    rebindSocket();
+    if (s_sock < 0)
+        return ESP_FAIL;
+
     /* Start the listener thread. */
     s_running = true;
     pthread_create(&s_recvThread, nullptr, recvLoop, nullptr);
 
-    printf("[SIM] ESP-NOW init OK – listening on port %d, sending to port %d\n", SIM_LISTEN_PORT, SIM_SEND_PORT);
     return ESP_OK;
 }
 
@@ -142,7 +162,7 @@ int esp_now_send(const uint8_t *peer_addr, const uint8_t *data, int len) {
 
     struct sockaddr_in dest{};
     dest.sin_family      = AF_INET;
-    dest.sin_port        = htons(SIM_SEND_PORT);
+    dest.sin_port        = htons(odh::channel::channelToSimPort(s_currentChannel));
     dest.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
 
     ssize_t sent = sendto(s_sock, buf, 6 + copyLen, 0, reinterpret_cast<sockaddr *>(&dest), sizeof(dest));
@@ -191,3 +211,16 @@ bool esp_now_is_peer_exist(const uint8_t *peer_addr) {
     }
     return false;
 }
+
+/* ── Channel switching ──────────────────────────────────────────────────── */
+
+void sim_set_wifi_channel(uint8_t channel) {
+    s_currentChannel = channel;
+    if (s_running) {
+        rebindSocket();
+    }
+}
+
+uint8_t sim_get_wifi_channel() {
+    return s_currentChannel;
+}
diff --git a/firmware/src/receiver/ReceiverApp.cpp b/firmware/src/receiver/ReceiverApp.cpp
index a230106..a573310 100644
--- a/firmware/src/receiver/ReceiverApp.cpp
+++ b/firmware/src/receiver/ReceiverApp.cpp
@@ -23,6 +23,8 @@
 
 #include <Arduino.h>
 
+#include <Channel.h>
+#include <ChannelScanner.h>
 #include <cstring>
 
 #ifndef NATIVE_SIM
@@ -89,20 +91,31 @@ void ReceiverApp::begin() {
     _channelsMux = xSemaphoreCreateMutex();
 
     // ── Radio ───────────────────────────────────────────────────────
-    {
-        NvsStore store("odh", true);
-        const uint8_t wifiCh = store.getU8("radio_ch", config::kRadioWifiChannel);
-
-        if (!_radio.begin(wifiCh, [this](const ControlPacket &pkt) { onControlReceived(pkt); })) {
-            Serial.println(F("[ODH-RX] Radio init failed – halting"));
-            while (true)
-                delay(1000);
-        }
+    if (!_radio.begin([this](const ControlPacket &pkt) { onControlReceived(pkt); })) {
+        Serial.println(F("[ODH-RX] Radio init failed – halting"));
+        while (true)
+            delay(1000);
     }
     Serial.println(F("[ODH-RX] Radio (ESP-NOW) OK"));
 
-    _radio.beginAnnouncing(_vehicleName, static_cast<uint8_t>(_output.modelType()));
-    Serial.print(F("[ODH-RX] Announcing vehicle: "));
+    // Register channel migration callback
+    _radio.onChannelMigration([this](uint8_t newChannel) { onChannelMigration(newChannel); });
+
+    // Configure presence parameters (but don't start yet)
+    _radio.configurePresence(_vehicleName, static_cast<uint8_t>(_output.modelType()));
+
+    // Run channel discovery to find an active transmitter
+    runChannelDiscovery();
+
+    // Re-register DiscoveryResponse callback for ongoing TX activity tracking
+    _radio.onDiscoveryResponse([this](uint8_t /*ch*/, int8_t /*rssi*/, uint8_t /*devCount*/) {
+        _lastTransmitterActivityMs = millis();
+        _discoveryComplete         = true;
+    });
+
+    Serial.print(F("[ODH-RX] Active on channel "));
+    Serial.println(_currentChannel);
+    Serial.print(F("[ODH-RX] Presence broadcast: "));
     Serial.println(_vehicleName);
 
     // ── Web server + API ────────────────────────────────────────────
@@ -175,7 +188,7 @@ void ReceiverApp::runTelemetryLoop() {
     for (;;) {
         if (_radio.isBound()) {
             if (_radio.checkLinkTimeout(config::kRadioLinkTimeoutMs)) {
-                Serial.println(F("[ODH-RX] Link timeout – resuming announce"));
+                Serial.println(F("[ODH-RX] Link timeout – resuming presence"));
             }
 
             _battery.sample();
@@ -184,7 +197,8 @@ void ReceiverApp::runTelemetryLoop() {
 
             _radio.sendTelemetry(_battery.voltageMv(), _radio.lastRssi(), linkState, static_cast<uint8_t>(_output.modelType()), 0, nullptr, 0);
         } else {
-            _radio.tickAnnounce(config::rx::kAnnounceIntervalMs);
+            _radio.tickPresence(channel::kPresenceIntervalMs);
+            checkTransmitterLoss();
         }
 
         vTaskDelay(pdMS_TO_TICKS(config::rx::kTelemetrySendIntervalMs));
@@ -201,6 +215,105 @@ void ReceiverApp::runWebLoop() {
     }
 }
 
+// ── Channel discovery ───────────────────────────────────────────────────
+
+void ReceiverApp::runChannelDiscovery() {
+    // Wire up the ChannelScanner callbacks to our radio layer
+    ChannelScanner scanner([this](uint8_t ch) -> bool { return _radio.setChannel(ch); }, [this](uint8_t /*ch*/) -> bool { return _radio.sendDiscoveryRequest(); }, [](uint32_t ms) { delay(ms); });
+
+    // Forward DiscoveryResponse to the scanner
+    _radio.onDiscoveryResponse([&scanner](uint8_t ch, int8_t rssi, uint8_t devCount) { scanner.onDiscoveryResponse(ch, rssi, devCount); });
+
+    // Step 1: Try last known channel from NVS
+    uint8_t lastCh = loadChannel();
+    if (channel::isValidChannel(lastCh)) {
+        Serial.printf("[ODH-RX] Trying last known channel %u...\n", lastCh);
+        ScanResult result = scanner.scanChannel(lastCh);
+        if (result.foundTransmitter) {
+            _currentChannel = lastCh;
+            _radio.setChannel(lastCh);
+            _lastTransmitterActivityMs = millis();
+            _radio.beginPresence();
+            _discoveryComplete = true;
+            Serial.printf("[ODH-RX] Transmitter found on saved channel %u\n", lastCh);
+            return;
+        }
+    }
+
+    // Step 2: Scan all candidate channels
+    Serial.println(F("[ODH-RX] Scanning channels 1, 6, 11..."));
+    ScanResult results[channel::kCandidateChannelCount];
+    scanner.scanAllChannels(results);
+
+    for (uint8_t i = 0; i < channel::kCandidateChannelCount; ++i) {
+        if (results[i].foundTransmitter) {
+            _currentChannel = results[i].channel;
+            _radio.setChannel(results[i].channel);
+            saveChannel(results[i].channel);
+            _lastTransmitterActivityMs = millis();
+            _radio.beginPresence();
+            _discoveryComplete = true;
+            Serial.printf("[ODH-RX] Transmitter found on channel %u\n", results[i].channel);
+            return;
+        }
+    }
+
+    // Step 3: No transmitter found – stay on default channel and keep trying
+    _currentChannel = channel::kDefaultChannel;
+    _radio.setChannel(channel::kDefaultChannel);
+    _radio.beginPresence();
+    _discoveryComplete = false;
+    Serial.println(F("[ODH-RX] No transmitter found – will retry"));
+}
+
+uint8_t ReceiverApp::loadChannel() {
+    NvsStore store("odh", true);
+    uint8_t ch = store.getU8("radio_ch", 0);
+    if (channel::isValidChannel(ch))
+        return ch;
+    return channel::kDefaultChannel;
+}
+
+void ReceiverApp::saveChannel(uint8_t ch) {
+    if (!channel::isValidChannel(ch))
+        return;
+    NvsStore store("odh", false);
+    store.putU8("radio_ch", ch);
+}
+
+// ── Channel migration callback ─────────────────────────────────────────
+
+void ReceiverApp::onChannelMigration(uint8_t newChannel) {
+    if (!channel::isValidChannel(newChannel))
+        return;
+    Serial.printf("[ODH-RX] Channel migration → %u\n", newChannel);
+    _radio.setChannel(newChannel);
+    _currentChannel = newChannel;
+    saveChannel(newChannel);
+    _lastTransmitterActivityMs = millis();
+}
+
+// ── Transmitter loss detection ──────────────────────────────────────────
+
+void ReceiverApp::checkTransmitterLoss() {
+    // Only check if we've completed initial discovery and are not bound
+    if (_radio.isBound()) {
+        _lastTransmitterActivityMs = millis();
+        return;
+    }
+
+    // If we haven't heard from any transmitter in a while, re-enter discovery
+    if (_discoveryComplete && (millis() - _lastTransmitterActivityMs) > channel::kTransmitterLossTimeoutMs) {
+        Serial.println(F("[ODH-RX] Transmitter lost – re-entering discovery"));
+        _discoveryComplete = false;
+    }
+
+    // If not discovery complete, periodically retry discovery
+    if (!_discoveryComplete) {
+        runChannelDiscovery();
+    }
+}
+
 // ── NVS helpers ─────────────────────────────────────────────────────────
 
 void ReceiverApp::loadVehicleName() {
diff --git a/firmware/src/receiver/ReceiverApp.h b/firmware/src/receiver/ReceiverApp.h
index 5b06342..fe3317a 100644
--- a/firmware/src/receiver/ReceiverApp.h
+++ b/firmware/src/receiver/ReceiverApp.h
@@ -43,6 +43,7 @@
 #include "ReceiverRadioLink.h"
 #include "web/ReceiverApi.h"
 
+#include <ChannelScanner.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>
 #include <freertos/task.h>
@@ -68,6 +69,11 @@ class ReceiverApp {
     bool _failsafeActive           = false;
     bool _webConfigMode            = false;
 
+    // Channel discovery state.
+    uint8_t _currentChannel             = 0;
+    bool _discoveryComplete             = false;
+    uint32_t _lastTransmitterActivityMs = 0;
+
     // Vehicle config (loaded from NVS).
     char _vehicleName[kVehicleNameMax] = {};
 
@@ -83,6 +89,17 @@ class ReceiverApp {
     void runTelemetryLoop();
     void runWebLoop();
 
+    // Channel discovery methods.
+    void runChannelDiscovery();
+    void saveChannel(uint8_t channel);
+    uint8_t loadChannel();
+
+    // Transmitter loss detection + rediscovery.
+    void checkTransmitterLoss();
+
+    // Callback for channel migration notification.
+    void onChannelMigration(uint8_t newChannel);
+
     /// Load vehicle name from NVS.
     void loadVehicleName();
     void saveVehicleName();
diff --git a/firmware/src/receiver/web/ReceiverApi.cpp b/firmware/src/receiver/web/ReceiverApi.cpp
index 922e03d..2f7ce25 100644
--- a/firmware/src/receiver/web/ReceiverApi.cpp
+++ b/firmware/src/receiver/web/ReceiverApi.cpp
@@ -66,7 +66,7 @@ void ReceiverApi::handleGetStatus(AsyncWebServerRequest *request) {
     const char *state = "disconnected";
     if (_radio.isBound())
         state = "connected";
-    else if (_radio.isAnnouncing())
+    else if (_radio.isPresencing())
         state = "announcing";
     doc["link"]["state"] = state;
     doc["link"]["rssi"]  = _radio.lastRssi();
diff --git a/firmware/src/transmitter/TransmitterApp.cpp b/firmware/src/transmitter/TransmitterApp.cpp
index e32a4b0..2198b04 100644
--- a/firmware/src/transmitter/TransmitterApp.cpp
+++ b/firmware/src/transmitter/TransmitterApp.cpp
@@ -29,10 +29,13 @@
 #include <Preferences.h>
 #include <Wire.h>
 
+#include <Channel.h>
+#include <ChannelScanner.h>
 #include <Config.h>
 #include <FunctionMap.h>
 #include <NvsStore.h>
 #include <Protocol.h>
+#include <cstdlib>
 
 #ifdef NATIVE_SIM
 #include <WiFi.h>
@@ -147,8 +150,13 @@ void TransmitterApp::begin() {
 
     // Radio
     auto telCb = [this](const TelemetryPacket &pkt) { _telemetry.onPacketReceived(pkt); };
-    if (_radio.begin(config::kRadioWifiChannel, telCb)) {
+    if (_radio.begin(telCb)) {
         Serial.println(F("[ODH] Radio (ESP-NOW) OK"));
+
+        // Run channel acquisition (find or found a channel)
+        runChannelAcquisition();
+
+        Serial.printf("[ODH] Active on channel %u\n", _currentChannel);
         _radio.startScanning();
         Serial.println(F("[ODH] Scanning for vehicles..."));
     } else {
@@ -179,6 +187,146 @@ void TransmitterApp::begin() {
     Serial.println(F("[ODH] Setup complete"));
 }
 
+/* ── NVS channel helpers ──────────────────────────────────────────────────── */
+
+uint8_t TransmitterApp::loadChannel() {
+    NvsStore nvs("odh", true);
+    uint8_t ch = nvs.getU8("radio_ch", 0);
+    if (channel::isValidChannel(ch))
+        return ch;
+    return channel::kDefaultChannel;
+}
+
+void TransmitterApp::saveChannel(uint8_t ch) {
+    if (!channel::isValidChannel(ch))
+        return;
+    NvsStore nvs("odh", false);
+    nvs.putU8("radio_ch", ch);
+}
+
+/* ── Channel acquisition ─────────────────────────────────────────────────── */
+
+void TransmitterApp::runChannelAcquisition() {
+    // Wire up the ChannelScanner callbacks
+    ChannelScanner scanner([this](uint8_t ch) -> bool { return _radio.setChannel(ch); }, [this](uint8_t /*ch*/) -> bool { return _radio.sendDiscoveryRequest(); }, [](uint32_t ms) { delay(ms); });
+
+    // Forward DiscoveryResponse to the scanner
+    _radio.onDiscoveryResponse([&scanner](uint8_t ch, int8_t rssi, uint8_t devCount) { scanner.onDiscoveryResponse(ch, rssi, devCount); });
+
+    // Step 1: Try last known good channel from NVS
+    uint8_t lastCh = loadChannel();
+    ScanResult results[channel::kCandidateChannelCount];
+
+    if (channel::isValidChannel(lastCh)) {
+        Serial.printf("[ODH] Trying last known channel %u...\n", lastCh);
+        ScanResult result = scanner.scanChannel(lastCh);
+        if (result.foundTransmitter) {
+            _currentChannel = lastCh;
+            _radio.setChannel(lastCh);
+            _channelActive = true;
+            Serial.printf("[ODH] Joined existing transmitter on channel %u\n", lastCh);
+            setupActiveTransmitter();
+            return;
+        }
+    }
+
+    // Step 2: Scan all candidate channels
+    Serial.println(F("[ODH] Scanning channels 1, 6, 11..."));
+    scanner.scanAllChannels(results);
+
+    // Check if any channel has an active transmitter
+    for (uint8_t i = 0; i < channel::kCandidateChannelCount; ++i) {
+        if (results[i].foundTransmitter) {
+            _currentChannel = results[i].channel;
+            _radio.setChannel(results[i].channel);
+            saveChannel(results[i].channel);
+            _channelActive = true;
+            Serial.printf("[ODH] Joined existing transmitter on channel %u\n", results[i].channel);
+            setupActiveTransmitter();
+            return;
+        }
+    }
+
+    // Step 3: No other transmitter found – found a channel
+    uint8_t bestCh = ChannelScanner::bestChannel(results);
+
+    // Random backoff before claiming
+    uint32_t backoff = channel::kFoundingBackoffMinMs + (std::rand() % (channel::kFoundingBackoffMaxMs - channel::kFoundingBackoffMinMs));
+    Serial.printf("[ODH] No TX found – backing off %lu ms before claiming channel %u\n", static_cast<unsigned long>(backoff), bestCh);
+    delay(backoff);
+
+    // One final discovery pass after backoff
+    ScanResult finalCheck = scanner.scanChannel(bestCh);
+    if (finalCheck.foundTransmitter) {
+        _currentChannel = bestCh;
+        _radio.setChannel(bestCh);
+        saveChannel(bestCh);
+        _channelActive = true;
+        Serial.printf("[ODH] Late discovery – joined transmitter on channel %u\n", bestCh);
+        setupActiveTransmitter();
+        return;
+    }
+
+    // Claim the channel
+    _currentChannel = bestCh;
+    _radio.setChannel(bestCh);
+    saveChannel(bestCh);
+    _channelActive = true;
+    Serial.printf("[ODH] Founded channel %u\n", bestCh);
+    setupActiveTransmitter();
+}
+
+void TransmitterApp::setupActiveTransmitter() {
+    // Register DiscoveryRequest callback – auto-reply is handled by radio layer
+    _radio.onDiscoveryRequest([](const uint8_t * /*mac*/, DeviceRole /*role*/) { Serial.println(F("[ODH] Answered DiscoveryRequest")); });
+
+    // Register DiscoveryResponse callback for ongoing awareness
+    _radio.onDiscoveryResponse([](uint8_t /*ch*/, int8_t /*rssi*/, uint8_t /*devCount*/) {});
+}
+
+/* ── rescan() ────────────────────────────────────────────────────────────── */
+
+void TransmitterApp::rescan() {
+    if (_radio.isBound()) {
+        Serial.println(F("[ODH] Cannot rescan while bound"));
+        return;
+    }
+
+    Serial.println(F("[ODH] Rescanning channels..."));
+
+    ChannelScanner scanner([this](uint8_t ch) -> bool { return _radio.setChannel(ch); }, [this](uint8_t /*ch*/) -> bool { return _radio.sendDiscoveryRequest(); }, [](uint32_t ms) { delay(ms); });
+
+    _radio.onDiscoveryResponse([&scanner](uint8_t ch, int8_t rssi, uint8_t devCount) { scanner.onDiscoveryResponse(ch, rssi, devCount); });
+
+    ScanResult results[channel::kCandidateChannelCount];
+    scanner.scanAllChannels(results);
+
+    for (uint8_t i = 0; i < channel::kCandidateChannelCount; ++i) {
+        if (results[i].foundTransmitter) {
+            uint8_t oldCh   = _currentChannel;
+            _currentChannel = results[i].channel;
+
+            if (oldCh != results[i].channel) {
+                // Send migration notification on old channel before switching
+                _radio.setChannel(oldCh);
+                _radio.sendChannelMigration(results[i].channel);
+                delay(10);
+            }
+
+            _radio.setChannel(results[i].channel);
+            saveChannel(results[i].channel);
+            Serial.printf("[ODH] Switched to channel %u (found other TX)\n", results[i].channel);
+            setupActiveTransmitter();
+            return;
+        }
+    }
+
+    // No other TX found – stay on current channel
+    _radio.setChannel(_currentChannel);
+    Serial.println(F("[ODH] No other TX found – staying on current channel"));
+    setupActiveTransmitter();
+}
+
 /* ── taskControl – 50 Hz ─────────────────────────────────────────────────── */
 
 void TransmitterApp::taskControl(void *param) {
diff --git a/firmware/src/transmitter/TransmitterApp.h b/firmware/src/transmitter/TransmitterApp.h
index baaf31c..c57cbde 100644
--- a/firmware/src/transmitter/TransmitterApp.h
+++ b/firmware/src/transmitter/TransmitterApp.h
@@ -40,6 +40,7 @@
 #include "web/TransmitterApi.h"
 
 #include <BatteryMonitor.h>
+#include <ChannelScanner.h>
 #include <Config.h>
 #include <OdhWebServer.h>
 #include <TelemetryData.h>
@@ -53,6 +54,9 @@ class TransmitterApp {
 public:
     void begin();
 
+    /// Rescan channels for other transmitters. Only callable when not bound.
+    void rescan();
+
 private:
     // Subsystems
     Backplane _backplane{config::tx::kI2cMuxAddr, config::tx::kModuleSlotCount};
@@ -75,9 +79,19 @@ class TransmitterApp {
     SemaphoreHandle_t _i2cMutex = nullptr;
     SemaphoreHandle_t _funcMux  = nullptr;
 
+    // Channel state
+    uint8_t _currentChannel = 0;
+    bool _channelActive     = false;
+
     // NVS helpers
     void loadInputMap(uint8_t model);
 
+    // Channel discovery
+    void runChannelAcquisition();
+    void setupActiveTransmitter();
+    void saveChannel(uint8_t channel);
+    uint8_t loadChannel();
+
     // FreeRTOS task bodies
     static void taskControl(void *param);
     static void taskDisplay(void *param);
diff --git a/firmware/src/transmitter/web/TransmitterApi.cpp b/firmware/src/transmitter/web/TransmitterApi.cpp
index b4854ab..dd47480 100644
--- a/firmware/src/transmitter/web/TransmitterApi.cpp
+++ b/firmware/src/transmitter/web/TransmitterApi.cpp
@@ -108,8 +108,7 @@ void TransmitterApi::handleGetConfig(AsyncWebServerRequest *req) {
     NvsStore nvs("odh", true);
     JsonDocument doc;
 
-    doc["device_name"]   = nvs.getString("dev_name", "TX");
-    doc["radio_channel"] = nvs.getU8("radio_ch", 1);
+    doc["device_name"] = nvs.getString("dev_name", "TX");
 
     uint8_t model          = nvs.getU8("model_type", static_cast<uint8_t>(ModelType::Generic));
     doc["model_type"]      = model;
@@ -193,11 +192,6 @@ void TransmitterApi::handlePostConfig(AsyncWebServerRequest *req, const uint8_t
     if (doc["device_name"].is<const char *>()) {
         nvs.putString("dev_name", doc["device_name"].as<const char *>());
     }
-    if (doc["radio_channel"].is<uint8_t>()) {
-        uint8_t ch = doc["radio_channel"].as<uint8_t>();
-        if (ch >= 1 && ch <= 13)
-            nvs.putU8("radio_ch", ch);
-    }
     if (doc["model_type"].is<uint8_t>()) {
         uint8_t m = doc["model_type"].as<uint8_t>();
         if (m < static_cast<uint8_t>(ModelType::Count))
diff --git a/firmware/test/test_native/test_channel.cpp b/firmware/test/test_native/test_channel.cpp
new file mode 100644
index 0000000..abbb6cb
--- /dev/null
+++ b/firmware/test/test_native/test_channel.cpp
@@ -0,0 +1,291 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * Native unit tests for the ODH channel / discovery module.
+ *
+ * Covers channel validation, timing constants, discovery packet
+ * construction, and the ChannelScanner logic.
+ */
+
+#include <Channel.h>
+#include <ChannelScanner.h>
+#include <Protocol.h>
+#include <cstdint>
+#include <cstring>
+#include <unity.h>
+
+using namespace odh;
+
+/* ── Channel validation ─────────────────────────────────────────────────── */
+
+void test_channel_valid_1(void) {
+    TEST_ASSERT_TRUE(channel::isValidChannel(1));
+}
+
+void test_channel_valid_6(void) {
+    TEST_ASSERT_TRUE(channel::isValidChannel(6));
+}
+
+void test_channel_valid_11(void) {
+    TEST_ASSERT_TRUE(channel::isValidChannel(11));
+}
+
+void test_channel_invalid_0(void) {
+    TEST_ASSERT_FALSE(channel::isValidChannel(0));
+}
+
+void test_channel_invalid_2(void) {
+    TEST_ASSERT_FALSE(channel::isValidChannel(2));
+}
+
+void test_channel_invalid_5(void) {
+    TEST_ASSERT_FALSE(channel::isValidChannel(5));
+}
+
+void test_channel_invalid_7(void) {
+    TEST_ASSERT_FALSE(channel::isValidChannel(7));
+}
+
+void test_channel_invalid_12(void) {
+    TEST_ASSERT_FALSE(channel::isValidChannel(12));
+}
+
+void test_channel_invalid_13(void) {
+    TEST_ASSERT_FALSE(channel::isValidChannel(13));
+}
+
+void test_channel_invalid_255(void) {
+    TEST_ASSERT_FALSE(channel::isValidChannel(255));
+}
+
+/* ── Channel constants ──────────────────────────────────────────────────── */
+
+void test_candidate_channel_count(void) {
+    TEST_ASSERT_EQUAL_UINT8(3, channel::kCandidateChannelCount);
+}
+
+void test_candidate_channel_0_is_1(void) {
+    TEST_ASSERT_EQUAL_UINT8(1, channel::kCandidateChannels[0]);
+}
+
+void test_candidate_channel_1_is_6(void) {
+    TEST_ASSERT_EQUAL_UINT8(6, channel::kCandidateChannels[1]);
+}
+
+void test_candidate_channel_2_is_11(void) {
+    TEST_ASSERT_EQUAL_UINT8(11, channel::kCandidateChannels[2]);
+}
+
+void test_default_channel(void) {
+    TEST_ASSERT_EQUAL_UINT8(1, channel::kDefaultChannel);
+}
+
+/* ── Sim port mapping ───────────────────────────────────────────────────── */
+
+void test_sim_port_channel_1(void) {
+    TEST_ASSERT_EQUAL_UINT16(7001, channel::channelToSimPort(1));
+}
+
+void test_sim_port_channel_6(void) {
+    TEST_ASSERT_EQUAL_UINT16(7006, channel::channelToSimPort(6));
+}
+
+void test_sim_port_channel_11(void) {
+    TEST_ASSERT_EQUAL_UINT16(7011, channel::channelToSimPort(11));
+}
+
+void test_sim_port_invalid_fallback(void) {
+    TEST_ASSERT_EQUAL_UINT16(7001, channel::channelToSimPort(3));
+}
+
+/* ── Timing constants sanity checks ─────────────────────────────────────── */
+
+void test_channel_settle_positive(void) {
+    TEST_ASSERT_GREATER_THAN(0u, channel::kChannelSettleMs);
+}
+
+void test_discovery_wait_positive(void) {
+    TEST_ASSERT_GREATER_THAN(0u, channel::kDiscoveryWaitMs);
+}
+
+void test_discovery_retries_at_least_one(void) {
+    TEST_ASSERT_GREATER_OR_EQUAL(1, channel::kDiscoveryRetries);
+}
+
+void test_presence_interval_positive(void) {
+    TEST_ASSERT_GREATER_THAN(0u, channel::kPresenceIntervalMs);
+}
+
+void test_transmitter_loss_exceeds_presence(void) {
+    TEST_ASSERT_GREATER_THAN(channel::kPresenceIntervalMs, channel::kTransmitterLossTimeoutMs);
+}
+
+void test_founding_backoff_max_exceeds_min(void) {
+    TEST_ASSERT_GREATER_THAN(channel::kFoundingBackoffMinMs, channel::kFoundingBackoffMaxMs);
+}
+
+/* ── Discovery packet sizes ─────────────────────────────────────────────── */
+
+void test_discovery_request_packet_size(void) {
+    TEST_ASSERT_LESS_OR_EQUAL(250, static_cast<int>(sizeof(DiscoveryRequestPacket)));
+}
+
+void test_discovery_response_packet_size(void) {
+    TEST_ASSERT_LESS_OR_EQUAL(250, static_cast<int>(sizeof(DiscoveryResponsePacket)));
+}
+
+void test_receiver_presence_packet_size(void) {
+    TEST_ASSERT_LESS_OR_EQUAL(250, static_cast<int>(sizeof(ReceiverPresencePacket)));
+}
+
+void test_channel_migration_packet_size(void) {
+    TEST_ASSERT_LESS_OR_EQUAL(250, static_cast<int>(sizeof(ChannelMigrationPacket)));
+}
+
+/* ── Discovery packet construction & checksum ───────────────────────────── */
+
+void test_discovery_request_checksum(void) {
+    DiscoveryRequestPacket pkt{};
+    fillHeader(pkt, PacketType::DiscoveryRequest);
+    pkt.mac[0] = 0xAA;
+    pkt.mac[5] = 0xBB;
+    pkt.role   = static_cast<uint8_t>(DeviceRole::Receiver);
+    setChecksum(pkt);
+
+    auto *raw      = reinterpret_cast<uint8_t *>(&pkt);
+    uint8_t recomp = checksum(raw, sizeof(pkt) - 1);
+    TEST_ASSERT_EQUAL_UINT8(pkt.checksum, recomp);
+}
+
+void test_discovery_response_checksum(void) {
+    DiscoveryResponsePacket pkt{};
+    fillHeader(pkt, PacketType::DiscoveryResponse);
+    pkt.mac[0]       = 0x11;
+    pkt.mac[5]       = 0x22;
+    pkt.channel      = 6;
+    pkt.device_count = 3;
+    setChecksum(pkt);
+
+    auto *raw      = reinterpret_cast<uint8_t *>(&pkt);
+    uint8_t recomp = checksum(raw, sizeof(pkt) - 1);
+    TEST_ASSERT_EQUAL_UINT8(pkt.checksum, recomp);
+}
+
+void test_receiver_presence_checksum(void) {
+    ReceiverPresencePacket pkt{};
+    fillHeader(pkt, PacketType::ReceiverPresence);
+    pkt.mac[0]     = 0xCC;
+    pkt.model_type = static_cast<uint8_t>(ModelType::DumpTruck);
+    std::strncpy(pkt.name, "TestRx", kVehicleNameMax - 1);
+    setChecksum(pkt);
+
+    auto *raw      = reinterpret_cast<uint8_t *>(&pkt);
+    uint8_t recomp = checksum(raw, sizeof(pkt) - 1);
+    TEST_ASSERT_EQUAL_UINT8(pkt.checksum, recomp);
+}
+
+void test_channel_migration_checksum(void) {
+    ChannelMigrationPacket pkt{};
+    fillHeader(pkt, PacketType::ChannelMigration);
+    pkt.mac[0]      = 0xDD;
+    pkt.mac[5]      = 0xEE;
+    pkt.new_channel = 11;
+    setChecksum(pkt);
+
+    auto *raw      = reinterpret_cast<uint8_t *>(&pkt);
+    uint8_t recomp = checksum(raw, sizeof(pkt) - 1);
+    TEST_ASSERT_EQUAL_UINT8(pkt.checksum, recomp);
+}
+
+/* ── ChannelScanner basic tests ─────────────────────────────────────────── */
+
+void test_scanner_no_response(void) {
+    // Mock callbacks: setChannel and sendDiscovery succeed, delay is a no-op
+    auto setChannel    = [](uint8_t) { return true; };
+    auto sendDiscovery = [](uint8_t) { return true; };
+    auto delayMs       = [](uint32_t) {};
+
+    ChannelScanner scanner(setChannel, sendDiscovery, delayMs);
+    ScanResult result = scanner.scanChannel(1);
+
+    TEST_ASSERT_EQUAL_UINT8(1, result.channel);
+    TEST_ASSERT_FALSE(result.foundTransmitter);
+}
+
+void test_scanner_with_response(void) {
+    ChannelScanner *scannerPtr = nullptr;
+
+    auto setChannel    = [](uint8_t) { return true; };
+    auto sendDiscovery = [&scannerPtr](uint8_t ch) {
+        // Simulate receiving a discovery response during the scan
+        if (scannerPtr) {
+            scannerPtr->onDiscoveryResponse(ch, -45, 2);
+        }
+        return true;
+    };
+    auto delayMs = [](uint32_t) {};
+
+    ChannelScanner scanner(setChannel, sendDiscovery, delayMs);
+    scannerPtr = &scanner;
+
+    ScanResult result = scanner.scanChannel(6);
+
+    TEST_ASSERT_EQUAL_UINT8(6, result.channel);
+    TEST_ASSERT_TRUE(result.foundTransmitter);
+    TEST_ASSERT_EQUAL_INT8(-45, result.rssi);
+    TEST_ASSERT_EQUAL_UINT8(2, result.deviceCount);
+}
+
+void test_scanner_best_channel_with_transmitter(void) {
+    ScanResult results[channel::kCandidateChannelCount];
+
+    results[0].channel          = 1;
+    results[0].foundTransmitter = false;
+    results[0].rssi             = -127;
+
+    results[1].channel          = 6;
+    results[1].foundTransmitter = true;
+    results[1].rssi             = -50;
+
+    results[2].channel          = 11;
+    results[2].foundTransmitter = true;
+    results[2].rssi             = -30;
+
+    // Should pick channel 11 (best RSSI among transmitter channels)
+    TEST_ASSERT_EQUAL_UINT8(11, ChannelScanner::bestChannel(results));
+}
+
+void test_scanner_best_channel_no_transmitter(void) {
+    ScanResult results[channel::kCandidateChannelCount];
+
+    results[0].channel          = 1;
+    results[0].foundTransmitter = false;
+
+    results[1].channel          = 6;
+    results[1].foundTransmitter = false;
+
+    results[2].channel          = 11;
+    results[2].foundTransmitter = false;
+
+    // No transmitter → returns first candidate channel
+    TEST_ASSERT_EQUAL_UINT8(1, ChannelScanner::bestChannel(results));
+}
diff --git a/firmware/test/test_native/test_protocol.cpp b/firmware/test/test_native/test_protocol.cpp
index 4653194..a97adbd 100644
--- a/firmware/test/test_native/test_protocol.cpp
+++ b/firmware/test/test_native/test_protocol.cpp
@@ -118,28 +118,28 @@ void test_bind_packet_size(void) {
 }
 
 void test_announce_packet_size(void) {
-    TEST_ASSERT_LESS_OR_EQUAL(250, static_cast<int>(sizeof(AnnouncePacket)));
+    TEST_ASSERT_LESS_OR_EQUAL(250, static_cast<int>(sizeof(ReceiverPresencePacket)));
 }
 
-/* ── Announce packet ─────────────────────────────────────────────────────── */
+/* ── ReceiverPresence packet ─────────────────────────────────────────────── */
 
 void test_announce_packet_fields(void) {
-    AnnouncePacket pkt{};
-    fillHeader(pkt, PacketType::Announce);
+    ReceiverPresencePacket pkt{};
+    fillHeader(pkt, PacketType::ReceiverPresence);
     pkt.model_type = static_cast<uint8_t>(ModelType::Excavator);
 
     const char *name = "TestVehicle";
     std::memcpy(pkt.name, name, std::strlen(name) + 1);
 
     TEST_ASSERT_EQUAL_UINT8(kMagic0, pkt.magic[0]);
-    TEST_ASSERT_EQUAL_UINT8(static_cast<uint8_t>(PacketType::Announce), pkt.type);
+    TEST_ASSERT_EQUAL_UINT8(static_cast<uint8_t>(PacketType::ReceiverPresence), pkt.type);
     TEST_ASSERT_EQUAL_UINT8(static_cast<uint8_t>(ModelType::Excavator), pkt.model_type);
     TEST_ASSERT_EQUAL_STRING("TestVehicle", pkt.name);
 }
 
 void test_announce_packet_checksum(void) {
-    AnnouncePacket pkt{};
-    fillHeader(pkt, PacketType::Announce);
+    ReceiverPresencePacket pkt{};
+    fillHeader(pkt, PacketType::ReceiverPresence);
     pkt.model_type = static_cast<uint8_t>(ModelType::Crane);
     std::strncpy(pkt.name, "MyCrane", kVehicleNameMax - 1);
     pkt.mac[0] = 0xAA;
@@ -152,8 +152,8 @@ void test_announce_packet_checksum(void) {
 }
 
 void test_announce_packet_checksum_detects_corruption(void) {
-    AnnouncePacket pkt{};
-    fillHeader(pkt, PacketType::Announce);
+    ReceiverPresencePacket pkt{};
+    fillHeader(pkt, PacketType::ReceiverPresence);
     pkt.model_type = static_cast<uint8_t>(ModelType::Generic);
     setChecksum(pkt);
 
@@ -330,6 +330,45 @@ extern void test_model_name_excavator(void);
 extern void test_model_name_unknown(void);
 extern void test_channel_assignments_unique(void);
 
+/* Forward-declarations – channel / discovery tests (test_channel.cpp). */
+extern void test_channel_valid_1(void);
+extern void test_channel_valid_6(void);
+extern void test_channel_valid_11(void);
+extern void test_channel_invalid_0(void);
+extern void test_channel_invalid_2(void);
+extern void test_channel_invalid_5(void);
+extern void test_channel_invalid_7(void);
+extern void test_channel_invalid_12(void);
+extern void test_channel_invalid_13(void);
+extern void test_channel_invalid_255(void);
+extern void test_candidate_channel_count(void);
+extern void test_candidate_channel_0_is_1(void);
+extern void test_candidate_channel_1_is_6(void);
+extern void test_candidate_channel_2_is_11(void);
+extern void test_default_channel(void);
+extern void test_sim_port_channel_1(void);
+extern void test_sim_port_channel_6(void);
+extern void test_sim_port_channel_11(void);
+extern void test_sim_port_invalid_fallback(void);
+extern void test_channel_settle_positive(void);
+extern void test_discovery_wait_positive(void);
+extern void test_discovery_retries_at_least_one(void);
+extern void test_presence_interval_positive(void);
+extern void test_transmitter_loss_exceeds_presence(void);
+extern void test_founding_backoff_max_exceeds_min(void);
+extern void test_discovery_request_packet_size(void);
+extern void test_discovery_response_packet_size(void);
+extern void test_receiver_presence_packet_size(void);
+extern void test_channel_migration_packet_size(void);
+extern void test_discovery_request_checksum(void);
+extern void test_discovery_response_checksum(void);
+extern void test_receiver_presence_checksum(void);
+extern void test_channel_migration_checksum(void);
+extern void test_scanner_no_response(void);
+extern void test_scanner_with_response(void);
+extern void test_scanner_best_channel_with_transmitter(void);
+extern void test_scanner_best_channel_no_transmitter(void);
+
 int main(int argc, char **argv) {
     (void)argc;
     (void)argv;
@@ -445,5 +484,50 @@ int main(int argc, char **argv) {
     RUN_TEST(test_model_name_unknown);
     RUN_TEST(test_channel_assignments_unique);
 
+    /* Channel / discovery tests */
+    RUN_TEST(test_channel_valid_1);
+    RUN_TEST(test_channel_valid_6);
+    RUN_TEST(test_channel_valid_11);
+    RUN_TEST(test_channel_invalid_0);
+    RUN_TEST(test_channel_invalid_2);
+    RUN_TEST(test_channel_invalid_5);
+    RUN_TEST(test_channel_invalid_7);
+    RUN_TEST(test_channel_invalid_12);
+    RUN_TEST(test_channel_invalid_13);
+    RUN_TEST(test_channel_invalid_255);
+
+    RUN_TEST(test_candidate_channel_count);
+    RUN_TEST(test_candidate_channel_0_is_1);
+    RUN_TEST(test_candidate_channel_1_is_6);
+    RUN_TEST(test_candidate_channel_2_is_11);
+    RUN_TEST(test_default_channel);
+
+    RUN_TEST(test_sim_port_channel_1);
+    RUN_TEST(test_sim_port_channel_6);
+    RUN_TEST(test_sim_port_channel_11);
+    RUN_TEST(test_sim_port_invalid_fallback);
+
+    RUN_TEST(test_channel_settle_positive);
+    RUN_TEST(test_discovery_wait_positive);
+    RUN_TEST(test_discovery_retries_at_least_one);
+    RUN_TEST(test_presence_interval_positive);
+    RUN_TEST(test_transmitter_loss_exceeds_presence);
+    RUN_TEST(test_founding_backoff_max_exceeds_min);
+
+    RUN_TEST(test_discovery_request_packet_size);
+    RUN_TEST(test_discovery_response_packet_size);
+    RUN_TEST(test_receiver_presence_packet_size);
+    RUN_TEST(test_channel_migration_packet_size);
+
+    RUN_TEST(test_discovery_request_checksum);
+    RUN_TEST(test_discovery_response_checksum);
+    RUN_TEST(test_receiver_presence_checksum);
+    RUN_TEST(test_channel_migration_checksum);
+
+    RUN_TEST(test_scanner_no_response);
+    RUN_TEST(test_scanner_with_response);
+    RUN_TEST(test_scanner_best_channel_with_transmitter);
+    RUN_TEST(test_scanner_best_channel_no_transmitter);
+
     return UNITY_END();
 }

From fc270aed22f45c7fd6b98c2741257aa9aa714f17 Mon Sep 17 00:00:00 2001
From: Peter Buchegger <peter.buchegger7@gmail.com>
Date: Wed, 11 Mar 2026 22:30:47 +0100
Subject: [PATCH 02/11] Refactor receiver and transmitter commands for improved
 functionality and clarity

- Updated NVS store initialization in ReceiverApi to use a more generic namespace.
- Modified TransmitterShellCommands to enhance command help descriptions and add new commands for input and rescan functionalities.
- Changed command syntax from "list" to "get" for channel and trim commands to align with new command structure.
- Added new tests for config help, config reset, and model setting to ensure proper command functionality.
- Implemented additional tests for mapping and failsafe commands to verify expected behavior.
- Enhanced help command tests to include new commands and ensure comprehensive coverage.
---
 .../receiver/shell/ReceiverShellCommands.cpp  | 241 ++++++++++++++--
 firmware/src/receiver/web/ReceiverApi.cpp     |   4 +-
 firmware/src/transmitter/TransmitterApp.cpp   |   2 +-
 .../shell/TransmitterShellCommands.cpp        | 271 +++++++++++++++---
 .../test/test_console/test_commands_common.py | 122 +++++++-
 .../test/test_console/test_commands_rx.py     | 113 ++++++++
 .../test/test_console/test_commands_tx.py     | 105 ++++++-
 firmware/test/test_console/test_help.py       |  36 +++
 8 files changed, 814 insertions(+), 80 deletions(-)

diff --git a/firmware/src/receiver/shell/ReceiverShellCommands.cpp b/firmware/src/receiver/shell/ReceiverShellCommands.cpp
index 220cc6f..422127f 100644
--- a/firmware/src/receiver/shell/ReceiverShellCommands.cpp
+++ b/firmware/src/receiver/shell/ReceiverShellCommands.cpp
@@ -23,15 +23,77 @@
 
 #include "../ReceiverApp.h"
 
+#include <Channel.h>
 #include <Config.h>
 #include <FunctionMap.h>
 #include <NvsStore.h>
+#include <Protocol.h>
 #include <Shell.h>
 #include <cstdlib>
 #include <cstring>
 
 namespace odh {
 
+// ── Helper: print a NameView via shell ──────────────────────────────────
+
+static void printName(Shell &shell, const char *prefix, NameView name) {
+#ifdef ODH_HAS_STRING_VIEW
+    shell.println("%s%.*s", prefix, static_cast<int>(name.size()), name.data());
+#else
+    shell.println("%s%s", prefix, name);
+#endif
+}
+
+// ── Helper: parse model name to ModelType ───────────────────────────────
+
+static bool parseModel(const char *str, ModelType &out) {
+    for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
+        auto mn = modelName(static_cast<ModelType>(m));
+#ifdef ODH_HAS_STRING_VIEW
+        // Case-insensitive compare
+        if (mn.size() > 0) {
+            bool match    = true;
+            const char *s = str;
+            for (size_t i = 0; i < mn.size(); ++i) {
+                if (*s == '\0' || (*s | 0x20) != (mn[i] | 0x20)) {
+                    match = false;
+                    break;
+                }
+                ++s;
+            }
+            if (match && *s == '\0') {
+                out = static_cast<ModelType>(m);
+                return true;
+            }
+        }
+#else
+        if (strcasecmp(str, mn) == 0) {
+            out = static_cast<ModelType>(m);
+            return true;
+        }
+#endif
+    }
+    return false;
+}
+
+// ── Helper: list available model names ──────────────────────────────────
+
+static void listModels(Shell &shell) {
+    shell.println("Available models:");
+    for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
+        printName(shell, "  ", modelName(static_cast<ModelType>(m)));
+    }
+}
+
+// ── Helper: list available function names ───────────────────────────────
+
+static void listFunctions(Shell &shell) {
+    shell.println("Available functions:");
+    for (uint8_t f = 0; f <= static_cast<uint8_t>(Function::TrackR); ++f) {
+        printName(shell, "  ", functionName(f));
+    }
+}
+
 // ── status ──────────────────────────────────────────────────────────────
 
 static int cmdStatus(Shell &shell, int, const char *const *, void *ctx) {
@@ -47,12 +109,7 @@ static int cmdStatus(Shell &shell, int, const char *const *, void *ctx) {
 
     shell.println("Battery:  %u mV (%uS)", app.battery().voltageMv(), app.battery().cells());
 
-    auto mn = modelName(app.output().modelType());
-#ifdef ODH_HAS_STRING_VIEW
-    shell.println("Model:    %.*s", static_cast<int>(mn.size()), mn.data());
-#else
-    shell.println("Model:    %s", mn);
-#endif
+    printName(shell, "Model:    ", modelName(app.output().modelType()));
 
     shell.println("Vehicle:  %s", app.vehicleName());
     return 0;
@@ -64,11 +121,11 @@ static int cmdChannel(Shell &shell, int argc, const char *const *argv, void *ctx
     auto &app = *static_cast<ReceiverApp *>(ctx);
 
     if (argc < 2) {
-        shell.println("Usage: channel <list|set>");
+        shell.println("Usage: channel <get|set>");
         return 1;
     }
 
-    if (strcmp(argv[1], "list") == 0) {
+    if (strcmp(argv[1], "get") == 0) {
         const auto &vals = app.output().channelValues();
         for (uint8_t i = 0; i < config::rx::kChannelCount; ++i) {
             shell.println("  CH%u: %u us", i, vals[i]);
@@ -106,37 +163,55 @@ static int cmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx)
     auto &app = *static_cast<ReceiverApp *>(ctx);
 
     if (argc < 2) {
-        shell.println("Usage: config <get|set>");
+        shell.println("Usage: config <get|set|help|reset>");
         return 1;
     }
 
+    // ── config get ──
     if (strcmp(argv[1], "get") == 0) {
         NvsStore store("odh", true);
-        shell.println("  radio_ch:  %u", store.getU8("radio_ch", config::kRadioWifiChannel));
+        shell.println("  radio_ch:  %u", store.getU8("radio_ch", channel::kDefaultChannel));
 
-        auto mn = modelName(app.output().modelType());
-#ifdef ODH_HAS_STRING_VIEW
-        shell.println("  model:     %.*s", static_cast<int>(mn.size()), mn.data());
-#else
-        shell.println("  model:     %s", mn);
-#endif
+        printName(shell, "  model:     ", modelName(app.output().modelType()));
 
         shell.println("  vehicle:   %s", app.vehicleName());
         shell.println("  batt_cell: %u", app.battery().cells());
         return 0;
     }
 
+    // ── config help ──
+    if (strcmp(argv[1], "help") == 0) {
+        shell.println("Available config keys:");
+        shell.println("  radio_ch   WiFi channel (1, 6, 11)");
+        shell.println("  batt_cell  Battery cells (0-6, 0=auto)");
+        shell.println("  model      Model type:");
+        for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
+            printName(shell, "               ", modelName(static_cast<ModelType>(m)));
+        }
+        shell.println("  vehicle    Vehicle name (max %u chars)", kVehicleNameMax - 1);
+        return 0;
+    }
+
+    // ── config reset ──
+    if (strcmp(argv[1], "reset") == 0) {
+        app.output().setModelType(app.output().modelType());
+        app.output().saveToNvs();
+        shell.println("Config reset to defaults");
+        return 0;
+    }
+
+    // ── config set ──
     if (strcmp(argv[1], "set") == 0) {
         if (argc < 4) {
             shell.println("Usage: config set <key> <value>");
-            shell.println("  Keys: radio_ch, model, batt_cell");
+            shell.println("  Use 'config help' to see available keys");
             return 1;
         }
 
         if (strcmp(argv[2], "radio_ch") == 0) {
             int ch = atoi(argv[3]);
-            if (ch < 1 || ch > 13) {
-                shell.println("Channel must be 1-13");
+            if (!channel::isValidChannel(static_cast<uint8_t>(ch))) {
+                shell.println("Invalid channel (valid: 1, 6, 11)");
                 return 1;
             }
             NvsStore store("odh", false);
@@ -157,7 +232,27 @@ static int cmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx)
             return 0;
         }
 
+        if (strcmp(argv[2], "model") == 0) {
+            ModelType model;
+            if (!parseModel(argv[3], model)) {
+                shell.println("Unknown model: %s", argv[3]);
+                listModels(shell);
+                return 1;
+            }
+            app.output().setModelType(model);
+            app.output().saveToNvs();
+            printName(shell, "model = ", modelName(model));
+            return 0;
+        }
+
+        if (strcmp(argv[2], "vehicle") == 0) {
+            app.setVehicleName(argv[3]);
+            shell.println("vehicle = %s", app.vehicleName());
+            return 0;
+        }
+
         shell.println("Unknown key: %s", argv[2]);
+        shell.println("  Use 'config help' to see available keys");
         return 1;
     }
 
@@ -180,13 +275,117 @@ static int cmdVehicle(Shell &shell, int argc, const char *const *argv, void *ctx
     return 0;
 }
 
+// ── mapping ─────────────────────────────────────────────────────────────
+
+static int cmdMapping(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<ReceiverApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Usage: mapping <get|help|reset>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "get") == 0) {
+        const auto &map = app.output().functionMap();
+        for (uint8_t ch = 0; ch < config::rx::kChannelCount; ++ch) {
+            auto func = channelToFunction(map, ch);
+            if (func.has_value()) {
+                auto fn = functionName(*func);
+#ifdef ODH_HAS_STRING_VIEW
+                shell.println("  CH%u: %.*s", ch, static_cast<int>(fn.size()), fn.data());
+#else
+                shell.println("  CH%u: %s", ch, fn);
+#endif
+            } else {
+                shell.println("  CH%u: (unmapped)", ch);
+            }
+        }
+        return 0;
+    }
+
+    if (strcmp(argv[1], "help") == 0) {
+        listFunctions(shell);
+        return 0;
+    }
+
+    if (strcmp(argv[1], "reset") == 0) {
+        app.output().setModelType(app.output().modelType());
+        app.output().saveToNvs();
+        shell.println("Function map reset to defaults");
+        return 0;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+// ── failsafe ────────────────────────────────────────────────────────────
+
+static int cmdFailsafe(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<ReceiverApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Usage: failsafe <get|set <ch> <us>>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "get") == 0) {
+        for (uint8_t i = 0; i < config::rx::kChannelCount; ++i) {
+            shell.println("  CH%u: %u us", i, app.output().failsafeValue(i));
+        }
+        return 0;
+    }
+
+    if (strcmp(argv[1], "set") == 0) {
+        if (argc < 4) {
+            shell.println("Usage: failsafe set <ch> <us>");
+            return 1;
+        }
+        int ch = atoi(argv[2]);
+        int us = atoi(argv[3]);
+        if (ch < 0 || ch >= config::rx::kChannelCount) {
+            shell.println("Channel %d out of range (0-%d)", ch, config::rx::kChannelCount - 1);
+            return 1;
+        }
+        if (us < kChannelMin || us > kChannelMax) {
+            shell.println("Value %d out of range (%d-%d)", us, kChannelMin, kChannelMax);
+            return 1;
+        }
+        app.output().setFailsafeValue(static_cast<uint8_t>(ch), static_cast<uint16_t>(us));
+        app.output().saveToNvs();
+        shell.println("Failsafe CH%d = %d us", ch, us);
+        return 0;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+// ── reboot ──────────────────────────────────────────────────────────────
+
+// cppcheck-suppress constParameterCallback
+static int cmdReboot(Shell &shell, int, const char *const *, void *) {
+#ifdef NATIVE_SIM
+    shell.println("Reboot not available in simulation");
+    return 1;
+#else
+    shell.println("Rebooting...");
+    delay(100);
+    ESP.restart();
+    return 0; // unreachable
+#endif
+}
+
 // ── Registration ────────────────────────────────────────────────────────
 
 void registerReceiverShellCommands(Shell &shell, ReceiverApp &app) {
     shell.registerCommand("status", "Show link, battery and vehicle info", cmdStatus, &app);
-    shell.registerCommand("channel", "Channel ops: list, set <ch> <us>", cmdChannel, &app);
-    shell.registerCommand("config", "Config ops: get, set <key> <val>", cmdConfig, &app);
+    shell.registerCommand("channel", "Channel ops: get, set <ch> <us>", cmdChannel, &app);
+    shell.registerCommand("config", "Config ops: get, set, help, reset", cmdConfig, &app);
     shell.registerCommand("vehicle", "Get/set vehicle name", cmdVehicle, &app);
+    shell.registerCommand("mapping", "Function map: get, help, reset", cmdMapping, &app);
+    shell.registerCommand("failsafe", "Failsafe: get, set <ch> <us>", cmdFailsafe, &app);
+    shell.registerCommand("reboot", "Restart the device", cmdReboot, nullptr);
 }
 
 } // namespace odh
diff --git a/firmware/src/receiver/web/ReceiverApi.cpp b/firmware/src/receiver/web/ReceiverApi.cpp
index 2f7ce25..172ece9 100644
--- a/firmware/src/receiver/web/ReceiverApi.cpp
+++ b/firmware/src/receiver/web/ReceiverApi.cpp
@@ -97,7 +97,7 @@ void ReceiverApi::handleGetStatus(AsyncWebServerRequest *request) {
 }
 
 void ReceiverApi::handleGetConfig(AsyncWebServerRequest *request) {
-    NvsStore nvs("odh_rx", true);
+    NvsStore nvs("odh", true);
     JsonDocument doc;
 
     doc["vehicle_name"] = nvs.getString("veh_name", "Receiver");
@@ -143,7 +143,7 @@ void ReceiverApi::handlePostConfig(AsyncWebServerRequest *request, const uint8_t
         return;
     }
 
-    NvsStore nvs("odh_rx", false);
+    NvsStore nvs("odh", false);
 
     // Update vehicle name if provided.
     if (doc["vehicle_name"].is<const char *>()) {
diff --git a/firmware/src/transmitter/TransmitterApp.cpp b/firmware/src/transmitter/TransmitterApp.cpp
index 9acd35e..08c3c95 100644
--- a/firmware/src/transmitter/TransmitterApp.cpp
+++ b/firmware/src/transmitter/TransmitterApp.cpp
@@ -35,8 +35,8 @@
 #include <FunctionMap.h>
 #include <NvsStore.h>
 #include <Protocol.h>
-#include <cstdlib>
 #include <Shell.h>
+#include <cstdlib>
 
 #ifdef NATIVE_SIM
 #include <WiFi.h>
diff --git a/firmware/src/transmitter/shell/TransmitterShellCommands.cpp b/firmware/src/transmitter/shell/TransmitterShellCommands.cpp
index c05a479..96f35ee 100644
--- a/firmware/src/transmitter/shell/TransmitterShellCommands.cpp
+++ b/firmware/src/transmitter/shell/TransmitterShellCommands.cpp
@@ -23,6 +23,7 @@
 
 #include "../TransmitterApp.h"
 
+#include <Channel.h>
 #include <Config.h>
 #include <FunctionMap.h>
 #include <NvsStore.h>
@@ -38,6 +39,63 @@
 
 namespace odh {
 
+// ── Helper: print a NameView via shell ──────────────────────────────────
+
+static void printName(Shell &shell, const char *prefix, NameView name) {
+#ifdef ODH_HAS_STRING_VIEW
+    shell.println("%s%.*s", prefix, static_cast<int>(name.size()), name.data());
+#else
+    shell.println("%s%s", prefix, name);
+#endif
+}
+
+// ── Helper: parse model name to ModelType ───────────────────────────────
+
+static bool parseModel(const char *str, ModelType &out) {
+    for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
+        auto mn = modelName(static_cast<ModelType>(m));
+#ifdef ODH_HAS_STRING_VIEW
+        bool match    = true;
+        const char *s = str;
+        for (size_t i = 0; i < mn.size(); ++i) {
+            if (*s == '\0' || (*s | 0x20) != (mn[i] | 0x20)) {
+                match = false;
+                break;
+            }
+            ++s;
+        }
+        if (match && *s == '\0') {
+            out = static_cast<ModelType>(m);
+            return true;
+        }
+#else
+        if (strcasecmp(str, mn) == 0) {
+            out = static_cast<ModelType>(m);
+            return true;
+        }
+#endif
+    }
+    return false;
+}
+
+// ── Helper: list available model names ──────────────────────────────────
+
+static void listModels(Shell &shell) {
+    shell.println("Available models:");
+    for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
+        printName(shell, "  ", modelName(static_cast<ModelType>(m)));
+    }
+}
+
+// ── Helper: list available function names ───────────────────────────────
+
+static void listFunctions(Shell &shell) {
+    shell.println("Available functions:");
+    for (uint8_t f = 0; f <= static_cast<uint8_t>(Function::TrackR); ++f) {
+        printName(shell, "  ", functionName(f));
+    }
+}
+
 // ── status ──────────────────────────────────────────────────────────────
 
 static int cmdStatus(Shell &shell, int, const char *const *, void *ctx) {
@@ -68,10 +126,18 @@ static int cmdBind(Shell &shell, int argc, const char *const *argv, void *ctx) {
     auto &app = *static_cast<TransmitterApp *>(ctx);
 
     if (argc < 2) {
-        shell.println("Usage: bind <scan|list|connect <n>>");
+        shell.println("Usage: bind <scan|list|connect <n>|help>");
         return 1;
     }
 
+    if (strcmp(argv[1], "help") == 0) {
+        shell.println("bind sub-commands:");
+        shell.println("  scan        Start scanning for vehicles");
+        shell.println("  list        List discovered vehicles");
+        shell.println("  connect <n> Connect to vehicle by index");
+        return 0;
+    }
+
     if (strcmp(argv[1], "scan") == 0) {
         if (app.radio().isBound()) {
             shell.println("Already connected – disconnect first");
@@ -148,11 +214,11 @@ static int cmdChannel(Shell &shell, int argc, const char *const *argv, void *ctx
     auto &app = *static_cast<TransmitterApp *>(ctx);
 
     if (argc < 2) {
-        shell.println("Usage: channel <list|set <idx> <us>>");
+        shell.println("Usage: channel <get|set <idx> <us>>");
         return 1;
     }
 
-    if (strcmp(argv[1], "list") == 0) {
+    if (strcmp(argv[1], "get") == 0) {
         auto snap = app.snapshotFuncValues();
         for (uint8_t i = 0; i < snap.second; ++i) {
             auto fn = functionName(snap.first[i].function);
@@ -203,11 +269,11 @@ static int cmdTrim(Shell &shell, int argc, const char *const *argv, void *ctx) {
     auto &app = *static_cast<TransmitterApp *>(ctx);
 
     if (argc < 2) {
-        shell.println("Usage: trim <list|set <idx> <val>>");
+        shell.println("Usage: trim <get|set <idx> <val>>");
         return 1;
     }
 
-    if (strcmp(argv[1], "list") == 0) {
+    if (strcmp(argv[1], "get") == 0) {
         auto snap = app.snapshotFuncValues();
         for (uint8_t i = 0; i < snap.second; ++i) {
             auto fn = functionName(snap.first[i].function);
@@ -246,46 +312,101 @@ static int cmdTrim(Shell &shell, int argc, const char *const *argv, void *ctx) {
 // ── module ──────────────────────────────────────────────────────────────
 
 // cppcheck-suppress constParameterCallback
-static int cmdModule(Shell &shell, int, const char *const *, void *ctx) {
-    const auto &app = *static_cast<const TransmitterApp *>(ctx);
-
-    for (uint8_t s = 0; s < app.modules().slotCount(); ++s) {
-        const char *typeStr = "empty";
-        switch (app.modules().typeAt(s)) {
-        case ModuleType::Switch:
-            typeStr = "Switch";
-            break;
-        case ModuleType::Button:
-            typeStr = "Button";
-            break;
-        case ModuleType::Potentiometer:
-            typeStr = "Pot";
-            break;
-        case ModuleType::Encoder:
-            typeStr = "Encoder";
-            break;
-        default:
-            break;
+static int cmdModule(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    if (argc < 2) {
+        shell.println("Usage: module <list>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "list") == 0) {
+        const auto &app = *static_cast<const TransmitterApp *>(ctx);
+        for (uint8_t s = 0; s < app.modules().slotCount(); ++s) {
+            const char *typeStr = "empty";
+            switch (app.modules().typeAt(s)) {
+            case ModuleType::Switch:
+                typeStr = "Switch";
+                break;
+            case ModuleType::Button:
+                typeStr = "Button";
+                break;
+            case ModuleType::Potentiometer:
+                typeStr = "Pot";
+                break;
+            case ModuleType::Encoder:
+                typeStr = "Encoder";
+                break;
+            default:
+                break;
+            }
+            shell.println("  Slot %u: %s (%u inputs)", s, typeStr, app.modules().inputCount(s));
         }
-        shell.println("  Slot %u: %s (%u inputs)", s, typeStr, app.modules().inputCount(s));
+        return 0;
     }
-    return 0;
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+// ── input ───────────────────────────────────────────────────────────────
+
+static int cmdInput(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<TransmitterApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Usage: input <get|help|reset>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "get") == 0) {
+        auto snap = app.snapshotFuncValues();
+        if (snap.second == 0) {
+            shell.println("No input map configured");
+            return 0;
+        }
+        for (uint8_t i = 0; i < snap.second; ++i) {
+            auto fn = functionName(snap.first[i].function);
+#ifdef ODH_HAS_STRING_VIEW
+            shell.println("  [%u] %.*s  value %u us  trim %+d", i, static_cast<int>(fn.size()), fn.data(), snap.first[i].value, snap.first[i].trim);
+#else
+            shell.println("  [%u] %s  value %u us  trim %+d", i, fn, snap.first[i].value, snap.first[i].trim);
+#endif
+        }
+        return 0;
+    }
+
+    if (strcmp(argv[1], "help") == 0) {
+        listFunctions(shell);
+        return 0;
+    }
+
+    if (strcmp(argv[1], "reset") == 0) {
+        NvsStore nvs("odh", true);
+        uint8_t model = nvs.getU8("model_type", static_cast<uint8_t>(ModelType::Generic));
+        app.loadInputMapForModel(model);
+        shell.println("Input map reset to defaults");
+        return 0;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
 }
 
 // ── config ──────────────────────────────────────────────────────────────
 
 static int cmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    (void)ctx;
-
     if (argc < 2) {
-        shell.println("Usage: config <get|set>");
+        shell.println("Usage: config <get|set|help|reset>");
         return 1;
     }
 
+    // ── config get ──
     if (strcmp(argv[1], "get") == 0) {
         NvsStore nvs("odh", true);
-        shell.println("  radio_ch:  %u", nvs.getU8("radio_ch", config::kRadioWifiChannel));
-        shell.println("  model:     %u", nvs.getU8("model_type", static_cast<uint8_t>(ModelType::Generic)));
+        shell.println("  radio_ch:  %u", nvs.getU8("radio_ch", channel::kDefaultChannel));
+
+        uint8_t modelRaw = nvs.getU8("model_type", static_cast<uint8_t>(ModelType::Generic));
+        printName(shell, "  model:     ", modelName(modelRaw));
+
         shell.println("  tx_cells:  %u", nvs.getU8("tx_cells", 0));
         shell.println("  rx_cells:  %u", nvs.getU8("rx_cells", 0));
         String dn = nvs.getString("dev_name", "TX");
@@ -293,10 +414,33 @@ static int cmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx)
         return 0;
     }
 
+    // ── config help ──
+    if (strcmp(argv[1], "help") == 0) {
+        shell.println("Available config keys:");
+        shell.println("  radio_ch   WiFi channel (1, 6, 11)");
+        shell.println("  model      Model type:");
+        for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
+            printName(shell, "               ", modelName(static_cast<ModelType>(m)));
+        }
+        shell.println("  tx_cells   TX battery cells (0-6, 0=auto)");
+        shell.println("  rx_cells   RX battery cells (0-6, 0=auto)");
+        shell.println("  dev_name   Device name (max %u chars)", kVehicleNameMax - 1);
+        return 0;
+    }
+
+    // ── config reset ──
+    if (strcmp(argv[1], "reset") == 0) {
+        NvsStore nvs("odh", false);
+        nvs.raw().clear();
+        shell.println("Config reset – restart required");
+        return 0;
+    }
+
+    // ── config set ──
     if (strcmp(argv[1], "set") == 0) {
         if (argc < 4) {
             shell.println("Usage: config set <key> <value>");
-            shell.println("  Keys: radio_ch, tx_cells, rx_cells, dev_name");
+            shell.println("  Use 'config help' to see available keys");
             return 1;
         }
 
@@ -304,8 +448,8 @@ static int cmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx)
 
         if (strcmp(argv[2], "radio_ch") == 0) {
             int ch = atoi(argv[3]);
-            if (ch < 1 || ch > 13) {
-                shell.println("Channel must be 1-13");
+            if (!channel::isValidChannel(static_cast<uint8_t>(ch))) {
+                shell.println("Invalid channel (valid: 1, 6, 11)");
                 return 1;
             }
             nvs.putU8("radio_ch", static_cast<uint8_t>(ch));
@@ -313,6 +457,20 @@ static int cmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx)
             return 0;
         }
 
+        if (strcmp(argv[2], "model") == 0) {
+            ModelType model;
+            if (!parseModel(argv[3], model)) {
+                shell.println("Unknown model: %s", argv[3]);
+                listModels(shell);
+                return 1;
+            }
+            nvs.putU8("model_type", static_cast<uint8_t>(model));
+            auto &app = *static_cast<TransmitterApp *>(ctx);
+            app.loadInputMapForModel(static_cast<uint8_t>(model));
+            printName(shell, "model = ", modelName(model));
+            return 0;
+        }
+
         if (strcmp(argv[2], "tx_cells") == 0) {
             int c = atoi(argv[3]);
             if (c < 0 || c > 6) {
@@ -342,6 +500,7 @@ static int cmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx)
         }
 
         shell.println("Unknown key: %s", argv[2]);
+        shell.println("  Use 'config help' to see available keys");
         return 1;
     }
 
@@ -349,16 +508,48 @@ static int cmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx)
     return 1;
 }
 
+// ── rescan ──────────────────────────────────────────────────────────────
+
+// cppcheck-suppress constParameterCallback
+static int cmdRescan(Shell &shell, int, const char *const *, void *ctx) {
+    auto &app = *static_cast<TransmitterApp *>(ctx);
+    if (app.radio().isBound()) {
+        shell.println("Cannot rescan while connected – disconnect first");
+        return 1;
+    }
+    app.rescan();
+    shell.println("Channel rescan initiated");
+    return 0;
+}
+
+// ── reboot ──────────────────────────────────────────────────────────────
+
+// cppcheck-suppress constParameterCallback
+static int cmdReboot(Shell &shell, int, const char *const *, void *) {
+#ifdef NATIVE_SIM
+    shell.println("Reboot not available in simulation");
+    return 1;
+#else
+    shell.println("Rebooting...");
+    delay(100);
+    ESP.restart();
+    return 0; // unreachable
+#endif
+}
+
 // ── Registration ────────────────────────────────────────────────────────
 
 void registerTransmitterShellCommands(Shell &shell, TransmitterApp &app) {
     shell.registerCommand("status", "Show link, battery and telemetry", cmdStatus, &app);
-    shell.registerCommand("bind", "Bind ops: scan, list, connect <n>", cmdBind, &app);
+    shell.registerCommand("bind", "Bind: scan, list, connect <n>, help", cmdBind, &app);
     shell.registerCommand("disconnect", "Disconnect from vehicle", cmdDisconnect, &app);
-    shell.registerCommand("channel", "Channel ops: list, set <idx> <us>", cmdChannel, &app);
-    shell.registerCommand("trim", "Trim ops: list, set <idx> <val>", cmdTrim, &app);
-    shell.registerCommand("module", "List detected input modules", cmdModule, &app);
-    shell.registerCommand("config", "Config ops: get, set <key> <val>", cmdConfig, &app);
+    shell.registerCommand("channel", "Channel: get, set <idx> <us>", cmdChannel, &app);
+    shell.registerCommand("trim", "Trim: get, set <idx> <val>", cmdTrim, &app);
+    shell.registerCommand("module", "Module: list", cmdModule, &app);
+    shell.registerCommand("input", "Input map: get, help, reset", cmdInput, &app);
+    shell.registerCommand("config", "Config: get, set, help, reset", cmdConfig, &app);
+    shell.registerCommand("rescan", "Rescan WiFi channels", cmdRescan, &app);
+    shell.registerCommand("reboot", "Restart the device", cmdReboot, nullptr);
 }
 
 } // namespace odh
diff --git a/firmware/test/test_console/test_commands_common.py b/firmware/test/test_console/test_commands_common.py
index dc6ae8f..d3b2108 100644
--- a/firmware/test/test_console/test_commands_common.py
+++ b/firmware/test/test_console/test_commands_common.py
@@ -135,12 +135,12 @@ def test_config_set_get_tx_cells(self, console: Console) -> None:
         console.send_command("config set tx_cells 0")
 
 
-class TestChannelList:
-    """Verify ``channel list`` shows channel information."""
+class TestChannelGet:
+    """Verify ``channel get`` shows channel information."""
 
-    def test_channel_list_returns_output(self, console: Console) -> None:
-        output = console.send_command("channel list")
-        assert len(output.strip()) > 0, "channel list returned empty output"
+    def test_channel_get_returns_output(self, console: Console) -> None:
+        output = console.send_command("channel get")
+        assert len(output.strip()) > 0, "channel get returned empty output"
 
 
 class TestMultipleCommands:
@@ -148,7 +148,7 @@ class TestMultipleCommands:
 
     def test_sequential_commands(self, console: Console) -> None:
         """Run 5 different commands and ensure all return valid output."""
-        commands = ["help", "status", "config get", "channel list", "help"]
+        commands = ["help", "status", "config get", "channel get", "help"]
         for cmd in commands:
             output = console.send_command(cmd)
             assert len(output.strip()) > 0, (
@@ -157,3 +157,113 @@ def test_sequential_commands(self, console: Console) -> None:
             assert "error" not in output.lower() or cmd == "config set", (
                 f"Command {cmd!r} produced error:\n{output}"
             )
+
+
+class TestConfigHelp:
+    """Verify ``config help`` lists available keys with value ranges."""
+
+    def test_config_help_returns_output(self, console: Console) -> None:
+        output = console.send_command("config help")
+        assert len(output.strip()) > 0, "config help returned empty output"
+
+    def test_config_help_lists_radio_ch(self, console: Console) -> None:
+        output = console.send_command("config help")
+        assert "radio_ch" in output, (
+            f"config help missing radio_ch:\n{output}"
+        )
+
+    def test_config_help_lists_model(self, console: Console) -> None:
+        output = console.send_command("config help")
+        assert "model" in output.lower(), (
+            f"config help missing model:\n{output}"
+        )
+
+    def test_config_help_shows_valid_channels(self, console: Console) -> None:
+        """``config help`` must mention valid WiFi channels."""
+        output = console.send_command("config help")
+        assert "1" in output and "6" in output and "11" in output, (
+            f"config help missing valid channel values:\n{output}"
+        )
+
+
+class TestConfigReset:
+    """Verify ``config reset`` works without error."""
+
+    def test_config_reset(self, console: Console) -> None:
+        output = console.send_command("config reset")
+        out_lower = output.lower()
+        assert "error" not in out_lower and "unknown" not in out_lower, (
+            f"config reset failed:\n{output}"
+        )
+
+
+class TestConfigSetRadioCh:
+    """Verify ``config set radio_ch`` validates channels."""
+
+    def test_config_set_radio_ch_invalid(self, console: Console) -> None:
+        """Setting radio_ch to 3 (not 1/6/11) must fail."""
+        output = console.send_command("config set radio_ch 3")
+        out_lower = output.lower()
+        assert "invalid" in out_lower or "error" in out_lower, (
+            f"Expected error for invalid channel 3:\n{output}"
+        )
+
+    def test_config_set_radio_ch_valid(self, console: Console) -> None:
+        """Setting radio_ch to 6 must succeed."""
+        output = console.send_command("config set radio_ch 6")
+        out_lower = output.lower()
+        assert "error" not in out_lower and "invalid" not in out_lower, (
+            f"Valid channel 6 was rejected:\n{output}"
+        )
+        result = console.send_command("config get")
+        assert "6" in result, (
+            f"radio_ch not set to 6:\n{result}"
+        )
+        # Reset to default
+        console.send_command("config set radio_ch 1")
+
+
+class TestConfigSetModel:
+    """Verify ``config set model`` works."""
+
+    def test_config_set_model_valid(self, console: Console) -> None:
+        """Setting model to a valid type must succeed."""
+        output = console.send_command("config set model Generic")
+        out_lower = output.lower()
+        assert "error" not in out_lower and "unknown" not in out_lower, (
+            f"Valid model was rejected:\n{output}"
+        )
+
+    def test_config_set_model_invalid(self, console: Console) -> None:
+        """Setting an invalid model must fail and list available models."""
+        output = console.send_command("config set model spaceship")
+        out_lower = output.lower()
+        assert "unknown" in out_lower or "invalid" in out_lower or "error" in out_lower, (
+            f"Expected error for invalid model:\n{output}"
+        )
+        assert "generic" in out_lower, (
+            f"Expected available models to be listed:\n{output}"
+        )
+
+
+class TestChannelGetNotList:
+    """Verify old ``channel list`` syntax is rejected."""
+
+    def test_channel_list_rejected(self, console: Console) -> None:
+        output = console.send_command("channel list")
+        out_lower = output.lower()
+        assert "unknown" in out_lower or "usage" in out_lower or "error" in out_lower, (
+            f"Expected error for old 'channel list' syntax:\n{output}"
+        )
+
+
+class TestReboot:
+    """Verify ``reboot`` in simulation."""
+
+    @pytest.mark.sim_only
+    def test_reboot_not_available_in_sim(self, console: Console) -> None:
+        output = console.send_command("reboot")
+        out_lower = output.lower()
+        assert "not available" in out_lower or "simulation" in out_lower, (
+            f"Expected 'not available in simulation':\n{output}"
+        )
diff --git a/firmware/test/test_console/test_commands_rx.py b/firmware/test/test_console/test_commands_rx.py
index e800ddb..e1117a8 100644
--- a/firmware/test/test_console/test_commands_rx.py
+++ b/firmware/test/test_console/test_commands_rx.py
@@ -78,3 +78,116 @@ def test_channel_set_invalid_value(self, console: Console) -> None:
         assert "error" in out_lower or "invalid" in out_lower or "range" in out_lower or "must be" in out_lower, (
             f"Expected error for invalid PWM value:\n{output}"
         )
+
+
+class TestMapping:
+    """Verify the ``mapping`` command for function-to-channel mapping."""
+
+    def test_mapping_get(self, console: Console) -> None:
+        """``mapping get`` must show channel-to-function assignments."""
+        output = console.send_command("mapping get")
+        assert len(output.strip()) > 0, "mapping get returned empty output"
+        assert "ch" in output.lower(), (
+            f"mapping get missing channel info:\n{output}"
+        )
+
+    def test_mapping_help(self, console: Console) -> None:
+        """``mapping help`` must list available function names."""
+        output = console.send_command("mapping help")
+        out_lower = output.lower()
+        assert "drive" in out_lower, (
+            f"mapping help missing 'Drive' function:\n{output}"
+        )
+        assert "steering" in out_lower, (
+            f"mapping help missing 'Steering' function:\n{output}"
+        )
+
+    def test_mapping_reset(self, console: Console) -> None:
+        """``mapping reset`` must succeed without error."""
+        output = console.send_command("mapping reset")
+        out_lower = output.lower()
+        assert "error" not in out_lower and "unknown" not in out_lower, (
+            f"mapping reset failed:\n{output}"
+        )
+
+    def test_mapping_no_subcommand(self, console: Console) -> None:
+        """``mapping`` without subcommand must show usage."""
+        output = console.send_command("mapping")
+        out_lower = output.lower()
+        assert "usage" in out_lower or "get" in out_lower, (
+            f"Expected usage hint:\n{output}"
+        )
+
+    def test_mapping_reset_roundtrip(self, console: Console) -> None:
+        """Set model to Excavator, reset mapping, verify defaults."""
+        console.send_command("config set model Excavator")
+        console.send_command("mapping reset")
+        output = console.send_command("mapping get")
+        out_lower = output.lower()
+        # Excavator defaults include BoomUD, Bucket, Swing
+        assert "boom" in out_lower or "bucket" in out_lower or "track" in out_lower, (
+            f"Excavator mapping not applied:\n{output}"
+        )
+        # Reset back to Generic
+        console.send_command("config set model Generic")
+        console.send_command("mapping reset")
+
+
+class TestFailsafe:
+    """Verify the ``failsafe`` command."""
+
+    def test_failsafe_get(self, console: Console) -> None:
+        """``failsafe get`` must show failsafe values per channel."""
+        output = console.send_command("failsafe get")
+        assert len(output.strip()) > 0, "failsafe get returned empty output"
+        assert "ch" in output.lower(), (
+            f"failsafe get missing channel info:\n{output}"
+        )
+
+    def test_failsafe_set(self, console: Console) -> None:
+        """Set failsafe value and verify it sticks."""
+        console.send_command("failsafe set 0 1200")
+        output = console.send_command("failsafe get")
+        assert "1200" in output, (
+            f"Failsafe value 1200 not found:\n{output}"
+        )
+        # Reset to default
+        console.send_command("failsafe set 0 1500")
+
+    def test_failsafe_set_invalid_channel(self, console: Console) -> None:
+        """Setting failsafe on invalid channel must fail."""
+        output = console.send_command("failsafe set 99 1500")
+        out_lower = output.lower()
+        assert "error" in out_lower or "range" in out_lower or "invalid" in out_lower, (
+            f"Expected error for invalid channel:\n{output}"
+        )
+
+    def test_failsafe_set_invalid_value(self, console: Console) -> None:
+        """Setting failsafe to out-of-range value must fail."""
+        output = console.send_command("failsafe set 0 500")
+        out_lower = output.lower()
+        assert "error" in out_lower or "range" in out_lower or "invalid" in out_lower, (
+            f"Expected error for invalid value:\n{output}"
+        )
+
+    def test_failsafe_no_subcommand(self, console: Console) -> None:
+        """``failsafe`` without subcommand must show usage."""
+        output = console.send_command("failsafe")
+        out_lower = output.lower()
+        assert "usage" in out_lower or "get" in out_lower, (
+            f"Expected usage hint:\n{output}"
+        )
+
+
+class TestConfigSetVehicle:
+    """Verify ``config set vehicle`` on the receiver."""
+
+    def test_config_set_vehicle(self, console: Console) -> None:
+        """Setting vehicle via config set must update vehicle name."""
+        console.send_command('config set vehicle "TestTruck"')
+        output = console.send_command("vehicle")
+        assert "TestTruck" in output, (
+            f"Vehicle not set to TestTruck:\n{output}"
+        )
+        # Restore
+        console.send_command('config set vehicle "RX"')
diff --git a/firmware/test/test_console/test_commands_tx.py b/firmware/test/test_console/test_commands_tx.py
index 193dc09..8bae405 100644
--- a/firmware/test/test_console/test_commands_tx.py
+++ b/firmware/test/test_console/test_commands_tx.py
@@ -63,17 +63,17 @@ def test_disconnect_when_idle(self, console: Console) -> None:
 class TestTrim:
     """Verify ``trim`` subcommands."""
 
-    def test_trim_list(self, console: Console) -> None:
-        """``trim list`` must return formatted output."""
-        output = console.send_command("trim list")
-        assert len(output.strip()) > 0, "trim list returned empty output"
+    def test_trim_get(self, console: Console) -> None:
+        """``trim get`` must return formatted output."""
+        output = console.send_command("trim get")
+        assert len(output.strip()) > 0, "trim get returned empty output"
 
     def test_trim_set_get_roundtrip(self, console: Console) -> None:
-        """Set trim, verify it appears in ``trim list``."""
+        """Set trim, verify it appears in ``trim get``."""
         console.send_command("trim set 0 50")
-        output = console.send_command("trim list")
+        output = console.send_command("trim get")
         assert "50" in output, (
-            f"trim value 50 not found in trim list:\n{output}"
+            f"trim value 50 not found in trim get:\n{output}"
         )
         # Reset trim
         console.send_command("trim set 0 0")
@@ -88,11 +88,96 @@ def test_trim_set_invalid_range(self, console: Console) -> None:
 
 
 class TestModule:
-    """Verify ``module`` command."""
+    """Verify ``module list`` command."""
 
     def test_module_list(self, console: Console) -> None:
-        """``module`` must return output (may report no modules in sim)."""
+        """``module list`` must return output (may report no modules in sim)."""
+        output = console.send_command("module list")
+        assert "error" not in output.lower(), (
+            f"module list returned error:\n{output}"
+        )
+
+    def test_module_no_subcommand(self, console: Console) -> None:
+        """``module`` without subcommand must show usage."""
         output = console.send_command("module")
+        out_lower = output.lower()
+        assert "usage" in out_lower or "list" in out_lower, (
+            f"Expected usage hint for module without subcommand:\n{output}"
+        )
+
+
+class TestInput:
+    """Verify ``input`` command for input map management."""
+
+    def test_input_get(self, console: Console) -> None:
+        """``input get`` must not crash (may be empty if no map)."""
+        output = console.send_command("input get")
         assert "error" not in output.lower(), (
-            f"module returned error:\n{output}"
+            f"input get returned error:\n{output}"
+        )
+
+    def test_input_help(self, console: Console) -> None:
+        """``input help`` must list available functions."""
+        output = console.send_command("input help")
+        out_lower = output.lower()
+        assert "drive" in out_lower, (
+            f"input help missing 'Drive' function:\n{output}"
+        )
+        assert "steering" in out_lower, (
+            f"input help missing 'Steering' function:\n{output}"
+        )
+
+    def test_input_reset(self, console: Console) -> None:
+        """``input reset`` must succeed without error."""
+        output = console.send_command("input reset")
+        out_lower = output.lower()
+        assert "error" not in out_lower and "unknown" not in out_lower, (
+            f"input reset failed:\n{output}"
+        )
+
+    def test_input_no_subcommand(self, console: Console) -> None:
+        """``input`` without subcommand must show usage."""
+        output = console.send_command("input")
+        out_lower = output.lower()
+        assert "usage" in out_lower or "get" in out_lower, (
+            f"Expected usage hint:\n{output}"
+        )
+
+
+class TestRescan:
+    """Verify ``rescan`` command."""
+
+    def test_rescan(self, console: Console) -> None:
+        """``rescan`` must not crash."""
+        output = console.send_command("rescan")
+        assert "error" not in output.lower(), (
+            f"rescan returned error:\n{output}"
+        )
+
+
+class TestTrimGetNotList:
+    """Verify old ``trim list`` syntax is rejected."""
+
+    def test_trim_list_rejected(self, console: Console) -> None:
+        output = console.send_command("trim list")
+        out_lower = output.lower()
+        assert "unknown" in out_lower or "usage" in out_lower or "error" in out_lower, (
+            f"Expected error for old 'trim list' syntax:\n{output}"
+        )
+
+
+class TestBindHelp:
+    """Verify ``bind help`` shows sub-commands."""
+
+    def test_bind_help(self, console: Console) -> None:
+        output = console.send_command("bind help")
+        out_lower = output.lower()
+        assert "scan" in out_lower, (
+            f"bind help missing 'scan':\n{output}"
+        )
+        assert "list" in out_lower, (
+            f"bind help missing 'list':\n{output}"
+        )
+        assert "connect" in out_lower, (
+            f"bind help missing 'connect':\n{output}"
         )
diff --git a/firmware/test/test_console/test_help.py b/firmware/test/test_console/test_help.py
index 190dd47..d562020 100644
--- a/firmware/test/test_console/test_help.py
+++ b/firmware/test/test_console/test_help.py
@@ -56,6 +56,24 @@ def test_help_lists_vehicle(self, console: Console) -> None:
         output = console.send_command("help")
         assert "vehicle" in output.lower()
 
+    @pytest.mark.rx
+    def test_help_lists_mapping(self, console: Console) -> None:
+        """RX ``help`` must list the ``mapping`` command."""
+        output = console.send_command("help")
+        assert "mapping" in output.lower()
+
+    @pytest.mark.rx
+    def test_help_lists_failsafe(self, console: Console) -> None:
+        """RX ``help`` must list the ``failsafe`` command."""
+        output = console.send_command("help")
+        assert "failsafe" in output.lower()
+
+    @pytest.mark.rx
+    def test_help_lists_reboot_rx(self, console: Console) -> None:
+        """RX ``help`` must list the ``reboot`` command."""
+        output = console.send_command("help")
+        assert "reboot" in output.lower()
+
     @pytest.mark.tx
     def test_help_lists_bind(self, console: Console) -> None:
         """TX ``help`` must list the ``bind`` command."""
@@ -79,3 +97,21 @@ def test_help_lists_disconnect(self, console: Console) -> None:
         """TX ``help`` must list the ``disconnect`` command."""
         output = console.send_command("help")
         assert "disconnect" in output.lower()
+
+    @pytest.mark.tx
+    def test_help_lists_input(self, console: Console) -> None:
+        """TX ``help`` must list the ``input`` command."""
+        output = console.send_command("help")
+        assert "input" in output.lower()
+
+    @pytest.mark.tx
+    def test_help_lists_rescan(self, console: Console) -> None:
+        """TX ``help`` must list the ``rescan`` command."""
+        output = console.send_command("help")
+        assert "rescan" in output.lower()
+
+    @pytest.mark.tx
+    def test_help_lists_reboot_tx(self, console: Console) -> None:
+        """TX ``help`` must list the ``reboot`` command."""
+        output = console.send_command("help")
+        assert "reboot" in output.lower()

From 7f8dc638c307cc5f2eb3fa6808462b5dfe172ad8 Mon Sep 17 00:00:00 2001
From: Peter Buchegger <peter.buchegger7@gmail.com>
Date: Fri, 13 Mar 2026 19:51:09 +0100
Subject: [PATCH 03/11] fix: update .gitignore to exclude Python bytecode and
 remove cached test files

---
 .gitignore                                      |   3 +++
 .../conftest.cpython-313-pytest-9.0.2.pyc       | Bin 6641 -> 0 bytes
 .../__pycache__/console.cpython-313.pyc         | Bin 4316 -> 0 bytes
 ...commands_common.cpython-313-pytest-9.0.2.pyc | Bin 22900 -> 0 bytes
 ...est_commands_rx.cpython-313-pytest-9.0.2.pyc | Bin 12050 -> 0 bytes
 ...est_commands_tx.cpython-313-pytest-9.0.2.pyc | Bin 14255 -> 0 bytes
 .../test_help.cpython-313-pytest-9.0.2.pyc      | Bin 10748 -> 0 bytes
 .../test_startup.cpython-313-pytest-9.0.2.pyc   | Bin 12886 -> 0 bytes
 .../__pycache__/transport.cpython-313.pyc       | Bin 13692 -> 0 bytes
 9 files changed, 3 insertions(+)
 delete mode 100644 firmware/test/test_console/__pycache__/conftest.cpython-313-pytest-9.0.2.pyc
 delete mode 100644 firmware/test/test_console/__pycache__/console.cpython-313.pyc
 delete mode 100644 firmware/test/test_console/__pycache__/test_commands_common.cpython-313-pytest-9.0.2.pyc
 delete mode 100644 firmware/test/test_console/__pycache__/test_commands_rx.cpython-313-pytest-9.0.2.pyc
 delete mode 100644 firmware/test/test_console/__pycache__/test_commands_tx.cpython-313-pytest-9.0.2.pyc
 delete mode 100644 firmware/test/test_console/__pycache__/test_help.cpython-313-pytest-9.0.2.pyc
 delete mode 100644 firmware/test/test_console/__pycache__/test_startup.cpython-313-pytest-9.0.2.pyc
 delete mode 100644 firmware/test/test_console/__pycache__/transport.cpython-313.pyc

diff --git a/.gitignore b/.gitignore
index 59a1aa2..b0b106d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,3 +14,6 @@
 *.bak
 *.000
 fp-info-cache
+
+# Python bytecode
+__pycache__
diff --git a/firmware/test/test_console/__pycache__/conftest.cpython-313-pytest-9.0.2.pyc b/firmware/test/test_console/__pycache__/conftest.cpython-313-pytest-9.0.2.pyc
deleted file mode 100644
index 0168a348e6f31bd88d8c74f54ce4488b0fabd5b6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6641
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
QCg58*KQhX9u*J6YKW*2ILjV8(

diff --git a/firmware/test/test_console/__pycache__/console.cpython-313.pyc b/firmware/test/test_console/__pycache__/console.cpython-313.pyc
deleted file mode 100644
index 6dae39cd082afe5e3cc45da62760a7e886e27110..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4316
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
JA=tBH{s(S4tY!cJ

diff --git a/firmware/test/test_console/__pycache__/test_commands_common.cpython-313-pytest-9.0.2.pyc b/firmware/test/test_console/__pycache__/test_commands_common.cpython-313-pytest-9.0.2.pyc
deleted file mode 100644
index 75fa3cf4a8a9e16f20615d16c4af523ce4645a3c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 22900
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

diff --git a/firmware/test/test_console/__pycache__/test_commands_rx.cpython-313-pytest-9.0.2.pyc b/firmware/test/test_console/__pycache__/test_commands_rx.cpython-313-pytest-9.0.2.pyc
deleted file mode 100644
index 6ab8cdd7ef107e458596afac2a06a8cfa8988b34..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 12050
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
TjNK4G+)l0cM7|V2(6jzO%eHf8

diff --git a/firmware/test/test_console/__pycache__/test_commands_tx.cpython-313-pytest-9.0.2.pyc b/firmware/test/test_console/__pycache__/test_commands_tx.cpython-313-pytest-9.0.2.pyc
deleted file mode 100644
index a5f0074130dbd96f7a3569040cc7f16fb8db3fcc..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14255
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

diff --git a/firmware/test/test_console/__pycache__/test_help.cpython-313-pytest-9.0.2.pyc b/firmware/test/test_console/__pycache__/test_help.cpython-313-pytest-9.0.2.pyc
deleted file mode 100644
index 2e470b35f497c881c167716565bb036c5ba44df6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10748
zcmeGiU2hx5agRJ6kCbFu{*-0MVH7yh$q@BrC3PdKO)EQw>?(~ebPXuYnIcaTTk?+G
zBV|i<0tXEmJ@mmrU{r=5>{lUA{UsGGOG>vd1&W}^n_3wt(5KGa-UlgBloiE59!MN#
zXJ=>T=5}{x_I7Wpr6o$>_u#9)WS5!<`6pJ~pU4qm>joeXh)O6?1vPL@7z@xq9P!|_
zAQkO0G$vU<8w*p}X^GGXw20TDV@<RvPTEKZQA6!Sm4*UbFKwO)D&d7!KhUkB6`wX~
zyf~}JZ{3>JbA?;C;%PIVPZ^oSx5%vstSMy}W-(RFnuawF_3+ODF>`vFYvVA;3t?+c
zK$AZtQ~<LBsz8Hk08EXk!FKW+k%j;hZA=0T%mP{%Fv-Sbz``~b`7k<hqVfhDpJ>}j
z0~r}*hMXqavWx7QnzE59+1S2hqgAqp_a)m@CEL0$+2$(QBWephI&(-l%w!zWt1yh;
zz5>s>(0@ax+39&0-c->a-&_`lJ(bJF^*aSUUDPw~kXwngGezv4iU5Rh6}GwnJ|Ib9
z0>*axPZfq7su4&ACMx9}R&%g}xMO38lOb0_QuHK4YQWT!(vLqQ#Jt_*FuW^d#tE5}
zT>c5!#rzVcb}$*f0Mq^EjSGPx$8prqr0rbDH__~KyO?j!+d#^^T6LF0E|*_+kV!`~
zA+F7?m8teB>BGL1i`9~TPf$auv@a`9SKX(kmC3*k>%fO9da$N-z7$v`?a3W<@3AMR
zH@<svhF(~w<Z`Ovgwz9b!;mYqA94HKFJXqro=l_%8q{b~?h|a;$mDUCvqDRaxYI$B
z5m$>_>Vn#INic%&7vUeeBoyXmnv~{+PA`<^OI9&npk}6&*5ih0^yv9QaXxOAiiJ`!
z!9<L>6kP_wsxYDm3sdL13iEF%R`mA{62BBjtWUAJupDxm0CAcIT@oM;sb8@YR*_~4
z(T}^7=*MuyM{G6ypoax>y1^uFgCemYXh+bGU=YC&g149mw7!LQv@uTgVu>0MDJmae
zp*1>^vMikzx$*%}jzR<DN;7M=bR(lVxrBvmb0{P_!lFMd%oia}X(`HDwKN1Gjp_vo
ztc4WSSu-?iQ>ARKm^CaW<xJqPSes_enx$OEX4PhL=2R-D8L7O^BAS(&)=>j!gJhOZ
zfo9vPyfwoPy<?-0yDn2|Qg+m3f!LQz8Fp4vqD-{(+%yZPd1j*+GguQE!Zi(4RxVUl
z-mI)#tgQTqKMA*}zrU(BXkmPcdp~xich=17y@jb#dRCvA(P{5{1>G2>**X1cX=<Q%
zI!p7np?7+*<7@z3YiD6z!9hwC=2@HFu~>tS!XdLXKG5tnH#H=7V~K-F*53i#BmZb^
z+h{#kZaw#8dbPD@QTqDmsXq^YF}xy=-XH#Q1d2ad_eWM^9e_P~-v;H_8yoT{zgFeZ
zl~{*Y<;WTed9-p>jg!|w`<s;<ZVg255Az04eSgG5y}JPU$@`ut7_`#m*y0fZ0X<vr
zc%&-Hg@Irvxn}Ug7fEueU=GwwbEAG*G1X)UQ;Rw6risj7ArN~>WWq~oXb=BEpb8`<
zNM*sBLw+i&kg1vel3qAg#eJs}-=6)X6JM&fMP3qubRzC)zn>)b((5G&HIxwT@Eukq
zHJl7P!Canfb^Eg7t~FCa(n|>y!JIh3T!KJ;d4?$RIK>svvcLjaV_8@j#Q+SUHJ&x>
zcvmA#*ACB#oOxTPJQmxbWm%-y;WUN-b23HC|97Y&m|ny{U6{YP9HqygjfHF-6jKvD
zi2#-ZgyL$Lo<abt5JGX$N6!LSj!;<C5E@6YJ(%^;4kW*h;57g|Xz@5z9klu^>;NxH
zQJl=|m>)mvm86EzhP_fFy!g%MK+yUEz&-Ny_RtbLz9M%%KJ)Ml6ia6woyFp8Io7!$
zJJ(aWb8(K>p82TP478;aUajoc)=(dBSVf&4kB6+wo%B3db-;iScxeG4Xa@xGI|hXP
zt%7lV>AT>|3J9T!d(;je-z6YOUO)(|@=FT{5grhjWWn2T$)dQJq`e5x#b_Ubegp#u
z1`*(UPc0`pvE7NdN@l;4U&Ulzn?V76Te~^Z$rV|7Jp2&Sw6Zk(2-38&G*XT!8?tjf
zm6gRiy!OmTy=I^-LH>1^%YJPQ_3?&P)amhf$hxdF90`U7bAG1bNYD%Zi!!_>ZO^Qp
zBf%PWIy>{dIuch|$B{UL?Yln#GaK_3I-xOdUuZ?>&f9Q$7WPE-+(9Pp$?XB&(aGYw
zuB03eOfkDIrrK8I?#I_3UWa1o`lE3y#>=tp4cWP#%H50ey!OmTy=I^-UGZvVzqW?@
zc*82{^msgEUG8r9Qp1<vw4tUiMXKJeB1&{2F>%x1l(u)u@P)xSi<r}Av+0~(aU5a4
zjIprOP~Y{&>#x3c_@1M*j_)}f_ImD180C9pQzA!BRqv9-8r}yR?zQ(e8m}@iYoK>(
zzx4Qf8!zWoW~cX^|DcZdO=XSD4%ZWrdLX~sv2}nN>ueohGcHZGcK5i(=0U^bY{vos
zndgVId9Y89gVUP)PLD(C_v>+}v5v=K^E=R$^p^-4dt;4PqZeMz_0&r!c{l>Cv6_=O
z{XkQE$5tBGS!V};GrS8k+}b^{G&a*3i3Mhe{riC@mi~I4m&sbN<7L2iK0DG&)NebG
z2exnD%JB8F*LU5`@R@!Aom|HgPp`;5kMBOb3&qmiN1tHvNjcWDAv@Poxo7b%uRZfo
zuNi1daD3!2m;Krr>f;TosMF)|kafAo&VkEhToGv;%%pfi!X$pS&ct!k(3N9M*6dFa
zG>t_yjYk*2n>FosrBn_-Qh-`a)8G)_D(13=ZkRv_Yg)!kYZ}EpeR>hWB?Lc1a0LL9
z_;(Ua%%|vYS%BW5V@M7Z@6d5%QW5+L!6ed;YZ{&+WYb!z2zh*}1j7RAe~k>7$?fAi
zif?B&z{5i8D*%5ae-qz+E(SxFh3C;gsOz~L2z7hl{H9E#=FcZTo&5ZxPe0lU1ViVy
zf<!vDiP&azTU(dc*0ry;Zcnazhg`yL!#gMVbKoN=Ei?lKcKCD&K6HRCrf`f;nCyN!
zVjqsOQyTBY1V3Aa??4h%zfH46_;AD{v9Lqq=c_vC@kg8YSamNld6*CL2sMEjKY+9F
mD0MR^2*SU+i15ZYq~l+Nd`AAz@(nrtUpUrJ{D%OrAK?E=hw2;v

diff --git a/firmware/test/test_console/__pycache__/test_startup.cpython-313-pytest-9.0.2.pyc b/firmware/test/test_console/__pycache__/test_startup.cpython-313-pytest-9.0.2.pyc
deleted file mode 100644
index 9214bbb5d85fa40dbcef429dae5e7e5306d377f8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 12886
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
Tzhr<s9CICXb^L|_LPz<(<a6nc

diff --git a/firmware/test/test_console/__pycache__/transport.cpython-313.pyc b/firmware/test/test_console/__pycache__/transport.cpython-313.pyc
deleted file mode 100644
index 3c2905896410ac488e5192ade5a9e47fcba2ce40..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 13692
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
K9|}}*E&0Fi3plp`


From 44d44d76a5abe5530d812da53a2104a999e2a052 Mon Sep 17 00:00:00 2001
From: Peter Buchegger <peter.buchegger7@gmail.com>
Date: Fri, 13 Mar 2026 20:05:38 +0100
Subject: [PATCH 04/11] refactor: split shell command files and console tests
 into smaller modules
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Extract shared helpers (shellPrintName, shellParseModel, shellListModels,
  shellListFunctions, cmdReboot) into lib/odh-shell/ShellHelpers.h/.cpp
- Split ReceiverShellCommands.cpp into cmd_status, cmd_channel, cmd_config,
  cmd_output with ReceiverShellCmds.h internal header
- Split TransmitterShellCommands.cpp into cmd_status, cmd_bind, cmd_channel,
  cmd_io, cmd_config with TransmitterShellCmds.h internal header
- Original facade files (ReceiverShellCommands.cpp, TransmitterShellCommands.cpp)
  now only register commands — no logic changes
- Split console tests into common/, rx/, tx/ subdirectories:
  common/test_basics, common/test_status, common/test_channel, common/test_config
  rx/test_channel, rx/test_output
  tx/test_bind, tx/test_io, tx/test_config
- All 140 native tests pass, all 6 builds succeed,
  all console tests pass (RX: 53, TX: 55)
---
 firmware/lib/odh-shell/ShellHelpers.cpp       | 100 ++++
 firmware/lib/odh-shell/ShellHelpers.h         |  57 ++
 firmware/lib/odh-shell/library.json           |   8 +
 .../src/receiver/shell/ReceiverShellCmds.h    |  51 ++
 .../receiver/shell/ReceiverShellCommands.cpp  | 378 +-----------
 firmware/src/receiver/shell/cmd_channel.cpp   |  94 +++
 firmware/src/receiver/shell/cmd_config.cpp    | 141 +++++
 firmware/src/receiver/shell/cmd_output.cpp    | 125 ++++
 firmware/src/receiver/shell/cmd_status.cpp    |  54 ++
 .../transmitter/shell/TransmitterShellCmds.h  |  56 ++
 .../shell/TransmitterShellCommands.cpp        | 546 +-----------------
 firmware/src/transmitter/shell/cmd_bind.cpp   | 125 ++++
 .../src/transmitter/shell/cmd_channel.cpp     |  95 +++
 firmware/src/transmitter/shell/cmd_config.cpp | 156 +++++
 firmware/src/transmitter/shell/cmd_io.cpp     | 182 ++++++
 firmware/src/transmitter/shell/cmd_status.cpp |  55 ++
 firmware/test/test_console/common/__init__.py |   0
 .../test/test_console/common/test_basics.py   |  70 +++
 .../test/test_console/common/test_channel.py  |  43 ++
 .../test_config.py}                           | 124 +---
 .../test/test_console/common/test_status.py   |  54 ++
 firmware/test/test_console/rx/__init__.py     |   0
 firmware/test/test_console/rx/test_channel.py | 104 ++++
 .../test_output.py}                           |  71 +--
 firmware/test/test_console/tx/__init__.py     |   0
 firmware/test/test_console/tx/test_bind.py    |  75 +++
 firmware/test/test_console/tx/test_config.py  |  41 ++
 .../{test_commands_tx.py => tx/test_io.py}    |  74 +--
 28 files changed, 1744 insertions(+), 1135 deletions(-)
 create mode 100644 firmware/lib/odh-shell/ShellHelpers.cpp
 create mode 100644 firmware/lib/odh-shell/ShellHelpers.h
 create mode 100644 firmware/lib/odh-shell/library.json
 create mode 100644 firmware/src/receiver/shell/ReceiverShellCmds.h
 create mode 100644 firmware/src/receiver/shell/cmd_channel.cpp
 create mode 100644 firmware/src/receiver/shell/cmd_config.cpp
 create mode 100644 firmware/src/receiver/shell/cmd_output.cpp
 create mode 100644 firmware/src/receiver/shell/cmd_status.cpp
 create mode 100644 firmware/src/transmitter/shell/TransmitterShellCmds.h
 create mode 100644 firmware/src/transmitter/shell/cmd_bind.cpp
 create mode 100644 firmware/src/transmitter/shell/cmd_channel.cpp
 create mode 100644 firmware/src/transmitter/shell/cmd_config.cpp
 create mode 100644 firmware/src/transmitter/shell/cmd_io.cpp
 create mode 100644 firmware/src/transmitter/shell/cmd_status.cpp
 create mode 100644 firmware/test/test_console/common/__init__.py
 create mode 100644 firmware/test/test_console/common/test_basics.py
 create mode 100644 firmware/test/test_console/common/test_channel.py
 rename firmware/test/test_console/{test_commands_common.py => common/test_config.py} (54%)
 create mode 100644 firmware/test/test_console/common/test_status.py
 create mode 100644 firmware/test/test_console/rx/__init__.py
 create mode 100644 firmware/test/test_console/rx/test_channel.py
 rename firmware/test/test_console/{test_commands_rx.py => rx/test_output.py} (63%)
 create mode 100644 firmware/test/test_console/tx/__init__.py
 create mode 100644 firmware/test/test_console/tx/test_bind.py
 create mode 100644 firmware/test/test_console/tx/test_config.py
 rename firmware/test/test_console/{test_commands_tx.py => tx/test_io.py} (72%)

diff --git a/firmware/lib/odh-shell/ShellHelpers.cpp b/firmware/lib/odh-shell/ShellHelpers.cpp
new file mode 100644
index 0000000..c11e6e6
--- /dev/null
+++ b/firmware/lib/odh-shell/ShellHelpers.cpp
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+#include "ShellHelpers.h"
+
+#ifndef NATIVE_TEST
+
+#include <Arduino.h>
+
+#include <FunctionMap.h>
+#include <Shell.h>
+#include <cstring>
+
+namespace odh {
+
+void shellPrintName(Shell &shell, const char *prefix, NameView name) {
+#ifdef ODH_HAS_STRING_VIEW
+    shell.println("%s%.*s", prefix, static_cast<int>(name.size()), name.data());
+#else
+    shell.println("%s%s", prefix, name);
+#endif
+}
+
+bool shellParseModel(const char *str, ModelType &out) {
+    for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
+        auto mn = modelName(static_cast<ModelType>(m));
+#ifdef ODH_HAS_STRING_VIEW
+        if (mn.size() > 0) {
+            bool match    = true;
+            const char *s = str;
+            for (size_t i = 0; i < mn.size(); ++i) {
+                if (*s == '\0' || (*s | 0x20) != (mn[i] | 0x20)) {
+                    match = false;
+                    break;
+                }
+                ++s;
+            }
+            if (match && *s == '\0') {
+                out = static_cast<ModelType>(m);
+                return true;
+            }
+        }
+#else
+        if (strcasecmp(str, mn) == 0) {
+            out = static_cast<ModelType>(m);
+            return true;
+        }
+#endif
+    }
+    return false;
+}
+
+void shellListModels(Shell &shell) {
+    shell.println("Available models:");
+    for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
+        shellPrintName(shell, "  ", modelName(static_cast<ModelType>(m)));
+    }
+}
+
+void shellListFunctions(Shell &shell) {
+    shell.println("Available functions:");
+    for (uint8_t f = 0; f <= static_cast<uint8_t>(Function::TrackR); ++f) {
+        shellPrintName(shell, "  ", functionName(f));
+    }
+}
+
+// cppcheck-suppress constParameterCallback
+int cmdReboot(Shell &shell, int, const char *const *, void *) {
+#ifdef NATIVE_SIM
+    shell.println("Reboot not available in simulation");
+    return 1;
+#else
+    shell.println("Rebooting...");
+    delay(100);
+    ESP.restart();
+    return 0; // unreachable
+#endif
+}
+
+} // namespace odh
+
+#endif // NATIVE_TEST
diff --git a/firmware/lib/odh-shell/ShellHelpers.h b/firmware/lib/odh-shell/ShellHelpers.h
new file mode 100644
index 0000000..4917f1f
--- /dev/null
+++ b/firmware/lib/odh-shell/ShellHelpers.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * ShellHelpers.h – Shared helper functions for shell command handlers.
+ *
+ * These utilities are used by both receiver and transmitter shell commands
+ * and are therefore kept in the shared odh-shell library.
+ */
+
+#pragma once
+
+#ifndef NATIVE_TEST
+
+#include <FunctionMap.h>
+
+namespace odh {
+
+class Shell;
+
+/// Print a NameView through the shell with an optional prefix.
+void shellPrintName(Shell &shell, const char *prefix, NameView name);
+
+/// Parse a model name string (case-insensitive) into a ModelType.
+/// Returns true on success.
+bool shellParseModel(const char *str, ModelType &out);
+
+/// Print the list of available model names.
+void shellListModels(Shell &shell);
+
+/// Print the list of available function names.
+void shellListFunctions(Shell &shell);
+
+/// Common ``reboot`` command handler (shared by RX and TX).
+int cmdReboot(Shell &shell, int argc, const char *const *argv, void *ctx);
+
+} // namespace odh
+
+#endif // NATIVE_TEST
diff --git a/firmware/lib/odh-shell/library.json b/firmware/lib/odh-shell/library.json
new file mode 100644
index 0000000..db6bcc7
--- /dev/null
+++ b/firmware/lib/odh-shell/library.json
@@ -0,0 +1,8 @@
+{
+    "name": "odh-shell",
+    "version": "1.0.0",
+    "description": "OpenDriveHub interactive shell (command registration, line editing, helpers)",
+    "dependencies": [
+        {"name": "odh-protocol"}
+    ]
+}
diff --git a/firmware/src/receiver/shell/ReceiverShellCmds.h b/firmware/src/receiver/shell/ReceiverShellCmds.h
new file mode 100644
index 0000000..4c7a18b
--- /dev/null
+++ b/firmware/src/receiver/shell/ReceiverShellCmds.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * ReceiverShellCmds.h – Internal declarations for receiver shell command
+ * handler functions.  Each handler lives in its own translation unit
+ * (cmd_status.cpp, cmd_channel.cpp, cmd_config.cpp, cmd_output.cpp).
+ *
+ * This header is NOT part of the public API – only
+ * ReceiverShellCommands.cpp includes it.
+ */
+
+#pragma once
+
+#include <Shell.h>
+
+namespace odh {
+
+// cmd_status.cpp
+int rxCmdStatus(Shell &shell, int argc, const char *const *argv, void *ctx);
+
+// cmd_channel.cpp
+int rxCmdChannel(Shell &shell, int argc, const char *const *argv, void *ctx);
+int rxCmdVehicle(Shell &shell, int argc, const char *const *argv, void *ctx);
+
+// cmd_config.cpp
+int rxCmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx);
+
+// cmd_output.cpp
+int rxCmdMapping(Shell &shell, int argc, const char *const *argv, void *ctx);
+int rxCmdFailsafe(Shell &shell, int argc, const char *const *argv, void *ctx);
+
+} // namespace odh
diff --git a/firmware/src/receiver/shell/ReceiverShellCommands.cpp b/firmware/src/receiver/shell/ReceiverShellCommands.cpp
index 422127f..b0f7963 100644
--- a/firmware/src/receiver/shell/ReceiverShellCommands.cpp
+++ b/firmware/src/receiver/shell/ReceiverShellCommands.cpp
@@ -19,372 +19,34 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
+/**
+ * ReceiverShellCommands – registration façade.
+ *
+ * The actual command handlers live in separate translation units:
+ *   cmd_status.cpp   – status
+ *   cmd_channel.cpp  – channel, vehicle
+ *   cmd_config.cpp   – config
+ *   cmd_output.cpp   – mapping, failsafe
+ *
+ * The shared ``reboot`` handler comes from ShellHelpers (lib/odh-shell).
+ */
+
 #include "ReceiverShellCommands.h"
 
-#include "../ReceiverApp.h"
+#include "ReceiverShellCmds.h"
 
-#include <Channel.h>
-#include <Config.h>
-#include <FunctionMap.h>
-#include <NvsStore.h>
-#include <Protocol.h>
 #include <Shell.h>
-#include <cstdlib>
-#include <cstring>
+#include <ShellHelpers.h>
 
 namespace odh {
 
-// ── Helper: print a NameView via shell ──────────────────────────────────
-
-static void printName(Shell &shell, const char *prefix, NameView name) {
-#ifdef ODH_HAS_STRING_VIEW
-    shell.println("%s%.*s", prefix, static_cast<int>(name.size()), name.data());
-#else
-    shell.println("%s%s", prefix, name);
-#endif
-}
-
-// ── Helper: parse model name to ModelType ───────────────────────────────
-
-static bool parseModel(const char *str, ModelType &out) {
-    for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
-        auto mn = modelName(static_cast<ModelType>(m));
-#ifdef ODH_HAS_STRING_VIEW
-        // Case-insensitive compare
-        if (mn.size() > 0) {
-            bool match    = true;
-            const char *s = str;
-            for (size_t i = 0; i < mn.size(); ++i) {
-                if (*s == '\0' || (*s | 0x20) != (mn[i] | 0x20)) {
-                    match = false;
-                    break;
-                }
-                ++s;
-            }
-            if (match && *s == '\0') {
-                out = static_cast<ModelType>(m);
-                return true;
-            }
-        }
-#else
-        if (strcasecmp(str, mn) == 0) {
-            out = static_cast<ModelType>(m);
-            return true;
-        }
-#endif
-    }
-    return false;
-}
-
-// ── Helper: list available model names ──────────────────────────────────
-
-static void listModels(Shell &shell) {
-    shell.println("Available models:");
-    for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
-        printName(shell, "  ", modelName(static_cast<ModelType>(m)));
-    }
-}
-
-// ── Helper: list available function names ───────────────────────────────
-
-static void listFunctions(Shell &shell) {
-    shell.println("Available functions:");
-    for (uint8_t f = 0; f <= static_cast<uint8_t>(Function::TrackR); ++f) {
-        printName(shell, "  ", functionName(f));
-    }
-}
-
-// ── status ──────────────────────────────────────────────────────────────
-
-static int cmdStatus(Shell &shell, int, const char *const *, void *ctx) {
-    auto &app = *static_cast<ReceiverApp *>(ctx);
-
-    const char *linkStr = app.radio().isBound() ? "connected" : "announcing";
-    shell.println("Link:     %s", linkStr);
-
-    if (app.radio().isBound()) {
-        shell.println("RSSI:     %d dBm", app.radio().lastRssi());
-        shell.println("Last pkt: %lu ms ago", static_cast<unsigned long>(app.radio().msSinceLastControl()));
-    }
-
-    shell.println("Battery:  %u mV (%uS)", app.battery().voltageMv(), app.battery().cells());
-
-    printName(shell, "Model:    ", modelName(app.output().modelType()));
-
-    shell.println("Vehicle:  %s", app.vehicleName());
-    return 0;
-}
-
-// ── channel ─────────────────────────────────────────────────────────────
-
-static int cmdChannel(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    auto &app = *static_cast<ReceiverApp *>(ctx);
-
-    if (argc < 2) {
-        shell.println("Usage: channel <get|set>");
-        return 1;
-    }
-
-    if (strcmp(argv[1], "get") == 0) {
-        const auto &vals = app.output().channelValues();
-        for (uint8_t i = 0; i < config::rx::kChannelCount; ++i) {
-            shell.println("  CH%u: %u us", i, vals[i]);
-        }
-        return 0;
-    }
-
-    if (strcmp(argv[1], "set") == 0) {
-        if (argc < 4) {
-            shell.println("Usage: channel set <ch> <us>");
-            return 1;
-        }
-        int ch = atoi(argv[2]);
-        int us = atoi(argv[3]);
-        if (ch < 0 || ch >= config::rx::kChannelCount) {
-            shell.println("Channel %d out of range (0-%d)", ch, config::rx::kChannelCount - 1);
-            return 1;
-        }
-        if (us < kChannelMin || us > kChannelMax) {
-            shell.println("Value %d out of range (%d-%d)", us, kChannelMin, kChannelMax);
-            return 1;
-        }
-        app.output().setChannel(static_cast<uint8_t>(ch), static_cast<uint16_t>(us));
-        shell.println("CH%d = %d us", ch, us);
-        return 0;
-    }
-
-    shell.println("Unknown sub-command: %s", argv[1]);
-    return 1;
-}
-
-// ── config ──────────────────────────────────────────────────────────────
-
-static int cmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    auto &app = *static_cast<ReceiverApp *>(ctx);
-
-    if (argc < 2) {
-        shell.println("Usage: config <get|set|help|reset>");
-        return 1;
-    }
-
-    // ── config get ──
-    if (strcmp(argv[1], "get") == 0) {
-        NvsStore store("odh", true);
-        shell.println("  radio_ch:  %u", store.getU8("radio_ch", channel::kDefaultChannel));
-
-        printName(shell, "  model:     ", modelName(app.output().modelType()));
-
-        shell.println("  vehicle:   %s", app.vehicleName());
-        shell.println("  batt_cell: %u", app.battery().cells());
-        return 0;
-    }
-
-    // ── config help ──
-    if (strcmp(argv[1], "help") == 0) {
-        shell.println("Available config keys:");
-        shell.println("  radio_ch   WiFi channel (1, 6, 11)");
-        shell.println("  batt_cell  Battery cells (0-6, 0=auto)");
-        shell.println("  model      Model type:");
-        for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
-            printName(shell, "               ", modelName(static_cast<ModelType>(m)));
-        }
-        shell.println("  vehicle    Vehicle name (max %u chars)", kVehicleNameMax - 1);
-        return 0;
-    }
-
-    // ── config reset ──
-    if (strcmp(argv[1], "reset") == 0) {
-        app.output().setModelType(app.output().modelType());
-        app.output().saveToNvs();
-        shell.println("Config reset to defaults");
-        return 0;
-    }
-
-    // ── config set ──
-    if (strcmp(argv[1], "set") == 0) {
-        if (argc < 4) {
-            shell.println("Usage: config set <key> <value>");
-            shell.println("  Use 'config help' to see available keys");
-            return 1;
-        }
-
-        if (strcmp(argv[2], "radio_ch") == 0) {
-            int ch = atoi(argv[3]);
-            if (!channel::isValidChannel(static_cast<uint8_t>(ch))) {
-                shell.println("Invalid channel (valid: 1, 6, 11)");
-                return 1;
-            }
-            NvsStore store("odh", false);
-            store.putU8("radio_ch", static_cast<uint8_t>(ch));
-            shell.println("radio_ch = %d (restart required)", ch);
-            return 0;
-        }
-
-        if (strcmp(argv[2], "batt_cell") == 0) {
-            int cells = atoi(argv[3]);
-            if (cells < 0 || cells > 6) {
-                shell.println("Cell count must be 0-6 (0 = auto)");
-                return 1;
-            }
-            NvsStore store("odh", false);
-            store.putU8("batt_cell", static_cast<uint8_t>(cells));
-            shell.println("batt_cell = %d", cells);
-            return 0;
-        }
-
-        if (strcmp(argv[2], "model") == 0) {
-            ModelType model;
-            if (!parseModel(argv[3], model)) {
-                shell.println("Unknown model: %s", argv[3]);
-                listModels(shell);
-                return 1;
-            }
-            app.output().setModelType(model);
-            app.output().saveToNvs();
-            printName(shell, "model = ", modelName(model));
-            return 0;
-        }
-
-        if (strcmp(argv[2], "vehicle") == 0) {
-            app.setVehicleName(argv[3]);
-            shell.println("vehicle = %s", app.vehicleName());
-            return 0;
-        }
-
-        shell.println("Unknown key: %s", argv[2]);
-        shell.println("  Use 'config help' to see available keys");
-        return 1;
-    }
-
-    shell.println("Unknown sub-command: %s", argv[1]);
-    return 1;
-}
-
-// ── vehicle ─────────────────────────────────────────────────────────────
-
-static int cmdVehicle(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    auto &app = *static_cast<ReceiverApp *>(ctx);
-
-    if (argc < 2) {
-        shell.println("Vehicle: %s", app.vehicleName());
-        return 0;
-    }
-
-    app.setVehicleName(argv[1]);
-    shell.println("Vehicle name set to: %s", app.vehicleName());
-    return 0;
-}
-
-// ── mapping ─────────────────────────────────────────────────────────────
-
-static int cmdMapping(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    auto &app = *static_cast<ReceiverApp *>(ctx);
-
-    if (argc < 2) {
-        shell.println("Usage: mapping <get|help|reset>");
-        return 1;
-    }
-
-    if (strcmp(argv[1], "get") == 0) {
-        const auto &map = app.output().functionMap();
-        for (uint8_t ch = 0; ch < config::rx::kChannelCount; ++ch) {
-            auto func = channelToFunction(map, ch);
-            if (func.has_value()) {
-                auto fn = functionName(*func);
-#ifdef ODH_HAS_STRING_VIEW
-                shell.println("  CH%u: %.*s", ch, static_cast<int>(fn.size()), fn.data());
-#else
-                shell.println("  CH%u: %s", ch, fn);
-#endif
-            } else {
-                shell.println("  CH%u: (unmapped)", ch);
-            }
-        }
-        return 0;
-    }
-
-    if (strcmp(argv[1], "help") == 0) {
-        listFunctions(shell);
-        return 0;
-    }
-
-    if (strcmp(argv[1], "reset") == 0) {
-        app.output().setModelType(app.output().modelType());
-        app.output().saveToNvs();
-        shell.println("Function map reset to defaults");
-        return 0;
-    }
-
-    shell.println("Unknown sub-command: %s", argv[1]);
-    return 1;
-}
-
-// ── failsafe ────────────────────────────────────────────────────────────
-
-static int cmdFailsafe(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    auto &app = *static_cast<ReceiverApp *>(ctx);
-
-    if (argc < 2) {
-        shell.println("Usage: failsafe <get|set <ch> <us>>");
-        return 1;
-    }
-
-    if (strcmp(argv[1], "get") == 0) {
-        for (uint8_t i = 0; i < config::rx::kChannelCount; ++i) {
-            shell.println("  CH%u: %u us", i, app.output().failsafeValue(i));
-        }
-        return 0;
-    }
-
-    if (strcmp(argv[1], "set") == 0) {
-        if (argc < 4) {
-            shell.println("Usage: failsafe set <ch> <us>");
-            return 1;
-        }
-        int ch = atoi(argv[2]);
-        int us = atoi(argv[3]);
-        if (ch < 0 || ch >= config::rx::kChannelCount) {
-            shell.println("Channel %d out of range (0-%d)", ch, config::rx::kChannelCount - 1);
-            return 1;
-        }
-        if (us < kChannelMin || us > kChannelMax) {
-            shell.println("Value %d out of range (%d-%d)", us, kChannelMin, kChannelMax);
-            return 1;
-        }
-        app.output().setFailsafeValue(static_cast<uint8_t>(ch), static_cast<uint16_t>(us));
-        app.output().saveToNvs();
-        shell.println("Failsafe CH%d = %d us", ch, us);
-        return 0;
-    }
-
-    shell.println("Unknown sub-command: %s", argv[1]);
-    return 1;
-}
-
-// ── reboot ──────────────────────────────────────────────────────────────
-
-// cppcheck-suppress constParameterCallback
-static int cmdReboot(Shell &shell, int, const char *const *, void *) {
-#ifdef NATIVE_SIM
-    shell.println("Reboot not available in simulation");
-    return 1;
-#else
-    shell.println("Rebooting...");
-    delay(100);
-    ESP.restart();
-    return 0; // unreachable
-#endif
-}
-
-// ── Registration ────────────────────────────────────────────────────────
-
 void registerReceiverShellCommands(Shell &shell, ReceiverApp &app) {
-    shell.registerCommand("status", "Show link, battery and vehicle info", cmdStatus, &app);
-    shell.registerCommand("channel", "Channel ops: get, set <ch> <us>", cmdChannel, &app);
-    shell.registerCommand("config", "Config ops: get, set, help, reset", cmdConfig, &app);
-    shell.registerCommand("vehicle", "Get/set vehicle name", cmdVehicle, &app);
-    shell.registerCommand("mapping", "Function map: get, help, reset", cmdMapping, &app);
-    shell.registerCommand("failsafe", "Failsafe: get, set <ch> <us>", cmdFailsafe, &app);
+    shell.registerCommand("status", "Show link, battery and vehicle info", rxCmdStatus, &app);
+    shell.registerCommand("channel", "Channel ops: get, set <ch> <us>", rxCmdChannel, &app);
+    shell.registerCommand("config", "Config ops: get, set, help, reset", rxCmdConfig, &app);
+    shell.registerCommand("vehicle", "Get/set vehicle name", rxCmdVehicle, &app);
+    shell.registerCommand("mapping", "Function map: get, help, reset", rxCmdMapping, &app);
+    shell.registerCommand("failsafe", "Failsafe: get, set <ch> <us>", rxCmdFailsafe, &app);
     shell.registerCommand("reboot", "Restart the device", cmdReboot, nullptr);
 }
 
diff --git a/firmware/src/receiver/shell/cmd_channel.cpp b/firmware/src/receiver/shell/cmd_channel.cpp
new file mode 100644
index 0000000..b2b3a07
--- /dev/null
+++ b/firmware/src/receiver/shell/cmd_channel.cpp
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * cmd_channel – ``channel`` and ``vehicle`` command handlers for the receiver.
+ */
+
+#include "../ReceiverApp.h"
+#include "ReceiverShellCmds.h"
+
+#include <Config.h>
+#include <Protocol.h>
+#include <Shell.h>
+#include <cstdlib>
+#include <cstring>
+
+namespace odh {
+
+// ── channel ─────────────────────────────────────────────────────────────
+
+int rxCmdChannel(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<ReceiverApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Usage: channel <get|set>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "get") == 0) {
+        const auto &vals = app.output().channelValues();
+        for (uint8_t i = 0; i < config::rx::kChannelCount; ++i) {
+            shell.println("  CH%u: %u us", i, vals[i]);
+        }
+        return 0;
+    }
+
+    if (strcmp(argv[1], "set") == 0) {
+        if (argc < 4) {
+            shell.println("Usage: channel set <ch> <us>");
+            return 1;
+        }
+        int ch = atoi(argv[2]);
+        int us = atoi(argv[3]);
+        if (ch < 0 || ch >= config::rx::kChannelCount) {
+            shell.println("Channel %d out of range (0-%d)", ch, config::rx::kChannelCount - 1);
+            return 1;
+        }
+        if (us < kChannelMin || us > kChannelMax) {
+            shell.println("Value %d out of range (%d-%d)", us, kChannelMin, kChannelMax);
+            return 1;
+        }
+        app.output().setChannel(static_cast<uint8_t>(ch), static_cast<uint16_t>(us));
+        shell.println("CH%d = %d us", ch, us);
+        return 0;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+// ── vehicle ─────────────────────────────────────────────────────────────
+
+int rxCmdVehicle(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<ReceiverApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Vehicle: %s", app.vehicleName());
+        return 0;
+    }
+
+    app.setVehicleName(argv[1]);
+    shell.println("Vehicle name set to: %s", app.vehicleName());
+    return 0;
+}
+
+} // namespace odh
diff --git a/firmware/src/receiver/shell/cmd_config.cpp b/firmware/src/receiver/shell/cmd_config.cpp
new file mode 100644
index 0000000..fb31b9e
--- /dev/null
+++ b/firmware/src/receiver/shell/cmd_config.cpp
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * cmd_config – ``config`` command handler for the receiver.
+ */
+
+#include "../ReceiverApp.h"
+#include "ReceiverShellCmds.h"
+
+#include <Channel.h>
+#include <FunctionMap.h>
+#include <NvsStore.h>
+#include <Protocol.h>
+#include <Shell.h>
+#include <ShellHelpers.h>
+#include <cstdlib>
+#include <cstring>
+
+namespace odh {
+
+int rxCmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<ReceiverApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Usage: config <get|set|help|reset>");
+        return 1;
+    }
+
+    // ── config get ──
+    if (strcmp(argv[1], "get") == 0) {
+        NvsStore store("odh", true);
+        shell.println("  radio_ch:  %u", store.getU8("radio_ch", channel::kDefaultChannel));
+
+        shellPrintName(shell, "  model:     ", modelName(app.output().modelType()));
+
+        shell.println("  vehicle:   %s", app.vehicleName());
+        shell.println("  batt_cell: %u", app.battery().cells());
+        return 0;
+    }
+
+    // ── config help ──
+    if (strcmp(argv[1], "help") == 0) {
+        shell.println("Available config keys:");
+        shell.println("  radio_ch   WiFi channel (1, 6, 11)");
+        shell.println("  batt_cell  Battery cells (0-6, 0=auto)");
+        shell.println("  model      Model type:");
+        for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
+            shellPrintName(shell, "               ", modelName(static_cast<ModelType>(m)));
+        }
+        shell.println("  vehicle    Vehicle name (max %u chars)", kVehicleNameMax - 1);
+        return 0;
+    }
+
+    // ── config reset ──
+    if (strcmp(argv[1], "reset") == 0) {
+        app.output().setModelType(app.output().modelType());
+        app.output().saveToNvs();
+        shell.println("Config reset to defaults");
+        return 0;
+    }
+
+    // ── config set ──
+    if (strcmp(argv[1], "set") == 0) {
+        if (argc < 4) {
+            shell.println("Usage: config set <key> <value>");
+            shell.println("  Use 'config help' to see available keys");
+            return 1;
+        }
+
+        if (strcmp(argv[2], "radio_ch") == 0) {
+            int ch = atoi(argv[3]);
+            if (!channel::isValidChannel(static_cast<uint8_t>(ch))) {
+                shell.println("Invalid channel (valid: 1, 6, 11)");
+                return 1;
+            }
+            NvsStore store("odh", false);
+            store.putU8("radio_ch", static_cast<uint8_t>(ch));
+            shell.println("radio_ch = %d (restart required)", ch);
+            return 0;
+        }
+
+        if (strcmp(argv[2], "batt_cell") == 0) {
+            int cells = atoi(argv[3]);
+            if (cells < 0 || cells > 6) {
+                shell.println("Cell count must be 0-6 (0 = auto)");
+                return 1;
+            }
+            NvsStore store("odh", false);
+            store.putU8("batt_cell", static_cast<uint8_t>(cells));
+            shell.println("batt_cell = %d", cells);
+            return 0;
+        }
+
+        if (strcmp(argv[2], "model") == 0) {
+            ModelType model;
+            if (!shellParseModel(argv[3], model)) {
+                shell.println("Unknown model: %s", argv[3]);
+                shellListModels(shell);
+                return 1;
+            }
+            app.output().setModelType(model);
+            app.output().saveToNvs();
+            shellPrintName(shell, "model = ", modelName(model));
+            return 0;
+        }
+
+        if (strcmp(argv[2], "vehicle") == 0) {
+            app.setVehicleName(argv[3]);
+            shell.println("vehicle = %s", app.vehicleName());
+            return 0;
+        }
+
+        shell.println("Unknown key: %s", argv[2]);
+        shell.println("  Use 'config help' to see available keys");
+        return 1;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+} // namespace odh
diff --git a/firmware/src/receiver/shell/cmd_output.cpp b/firmware/src/receiver/shell/cmd_output.cpp
new file mode 100644
index 0000000..9f1364e
--- /dev/null
+++ b/firmware/src/receiver/shell/cmd_output.cpp
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * cmd_output – ``mapping`` and ``failsafe`` command handlers for the receiver.
+ */
+
+#include "../ReceiverApp.h"
+#include "ReceiverShellCmds.h"
+
+#include <Config.h>
+#include <FunctionMap.h>
+#include <Protocol.h>
+#include <Shell.h>
+#include <ShellHelpers.h>
+#include <cstdlib>
+#include <cstring>
+
+namespace odh {
+
+// ── mapping ─────────────────────────────────────────────────────────────
+
+int rxCmdMapping(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<ReceiverApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Usage: mapping <get|help|reset>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "get") == 0) {
+        const auto &map = app.output().functionMap();
+        for (uint8_t ch = 0; ch < config::rx::kChannelCount; ++ch) {
+            auto func = channelToFunction(map, ch);
+            if (func.has_value()) {
+                auto fn = functionName(*func);
+#ifdef ODH_HAS_STRING_VIEW
+                shell.println("  CH%u: %.*s", ch, static_cast<int>(fn.size()), fn.data());
+#else
+                shell.println("  CH%u: %s", ch, fn);
+#endif
+            } else {
+                shell.println("  CH%u: (unmapped)", ch);
+            }
+        }
+        return 0;
+    }
+
+    if (strcmp(argv[1], "help") == 0) {
+        shellListFunctions(shell);
+        return 0;
+    }
+
+    if (strcmp(argv[1], "reset") == 0) {
+        app.output().setModelType(app.output().modelType());
+        app.output().saveToNvs();
+        shell.println("Function map reset to defaults");
+        return 0;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+// ── failsafe ────────────────────────────────────────────────────────────
+
+int rxCmdFailsafe(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<ReceiverApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Usage: failsafe <get|set <ch> <us>>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "get") == 0) {
+        for (uint8_t i = 0; i < config::rx::kChannelCount; ++i) {
+            shell.println("  CH%u: %u us", i, app.output().failsafeValue(i));
+        }
+        return 0;
+    }
+
+    if (strcmp(argv[1], "set") == 0) {
+        if (argc < 4) {
+            shell.println("Usage: failsafe set <ch> <us>");
+            return 1;
+        }
+        int ch = atoi(argv[2]);
+        int us = atoi(argv[3]);
+        if (ch < 0 || ch >= config::rx::kChannelCount) {
+            shell.println("Channel %d out of range (0-%d)", ch, config::rx::kChannelCount - 1);
+            return 1;
+        }
+        if (us < kChannelMin || us > kChannelMax) {
+            shell.println("Value %d out of range (%d-%d)", us, kChannelMin, kChannelMax);
+            return 1;
+        }
+        app.output().setFailsafeValue(static_cast<uint8_t>(ch), static_cast<uint16_t>(us));
+        app.output().saveToNvs();
+        shell.println("Failsafe CH%d = %d us", ch, us);
+        return 0;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+} // namespace odh
diff --git a/firmware/src/receiver/shell/cmd_status.cpp b/firmware/src/receiver/shell/cmd_status.cpp
new file mode 100644
index 0000000..497a3f6
--- /dev/null
+++ b/firmware/src/receiver/shell/cmd_status.cpp
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * cmd_status – ``status`` command handler for the receiver.
+ */
+
+#include "../ReceiverApp.h"
+#include "ReceiverShellCmds.h"
+
+#include <FunctionMap.h>
+#include <Shell.h>
+#include <ShellHelpers.h>
+
+namespace odh {
+
+int rxCmdStatus(Shell &shell, int, const char *const *, void *ctx) {
+    auto &app = *static_cast<ReceiverApp *>(ctx);
+
+    const char *linkStr = app.radio().isBound() ? "connected" : "announcing";
+    shell.println("Link:     %s", linkStr);
+
+    if (app.radio().isBound()) {
+        shell.println("RSSI:     %d dBm", app.radio().lastRssi());
+        shell.println("Last pkt: %lu ms ago", static_cast<unsigned long>(app.radio().msSinceLastControl()));
+    }
+
+    shell.println("Battery:  %u mV (%uS)", app.battery().voltageMv(), app.battery().cells());
+
+    shellPrintName(shell, "Model:    ", modelName(app.output().modelType()));
+
+    shell.println("Vehicle:  %s", app.vehicleName());
+    return 0;
+}
+
+} // namespace odh
diff --git a/firmware/src/transmitter/shell/TransmitterShellCmds.h b/firmware/src/transmitter/shell/TransmitterShellCmds.h
new file mode 100644
index 0000000..de54ddd
--- /dev/null
+++ b/firmware/src/transmitter/shell/TransmitterShellCmds.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * TransmitterShellCmds.h – Internal declarations for transmitter shell
+ * command handler functions.  Each handler lives in its own translation unit
+ * (cmd_status.cpp, cmd_bind.cpp, cmd_channel.cpp, cmd_io.cpp, cmd_config.cpp).
+ *
+ * This header is NOT part of the public API – only
+ * TransmitterShellCommands.cpp includes it.
+ */
+
+#pragma once
+
+#include <Shell.h>
+
+namespace odh {
+
+// cmd_status.cpp
+int txCmdStatus(Shell &shell, int argc, const char *const *argv, void *ctx);
+
+// cmd_bind.cpp
+int txCmdBind(Shell &shell, int argc, const char *const *argv, void *ctx);
+int txCmdDisconnect(Shell &shell, int argc, const char *const *argv, void *ctx);
+
+// cmd_channel.cpp
+int txCmdChannel(Shell &shell, int argc, const char *const *argv, void *ctx);
+
+// cmd_io.cpp
+int txCmdTrim(Shell &shell, int argc, const char *const *argv, void *ctx);
+int txCmdModule(Shell &shell, int argc, const char *const *argv, void *ctx);
+int txCmdInput(Shell &shell, int argc, const char *const *argv, void *ctx);
+int txCmdRescan(Shell &shell, int argc, const char *const *argv, void *ctx);
+
+// cmd_config.cpp
+int txCmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx);
+
+} // namespace odh
diff --git a/firmware/src/transmitter/shell/TransmitterShellCommands.cpp b/firmware/src/transmitter/shell/TransmitterShellCommands.cpp
index 96f35ee..596fbd4 100644
--- a/firmware/src/transmitter/shell/TransmitterShellCommands.cpp
+++ b/firmware/src/transmitter/shell/TransmitterShellCommands.cpp
@@ -19,536 +19,38 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
+/**
+ * TransmitterShellCommands – registration façade.
+ *
+ * The actual command handlers live in separate translation units:
+ *   cmd_status.cpp   – status
+ *   cmd_bind.cpp     – bind, disconnect
+ *   cmd_channel.cpp  – channel
+ *   cmd_io.cpp       – trim, module, input, rescan
+ *   cmd_config.cpp   – config
+ *
+ * The shared ``reboot`` handler comes from ShellHelpers (lib/odh-shell).
+ */
+
 #include "TransmitterShellCommands.h"
 
-#include "../TransmitterApp.h"
+#include "TransmitterShellCmds.h"
 
-#include <Channel.h>
-#include <Config.h>
-#include <FunctionMap.h>
-#include <NvsStore.h>
-#include <Protocol.h>
 #include <Shell.h>
-
-#ifdef NATIVE_SIM
-#include <sim_keyboard.h>
-#endif
-
-#include <cstdlib>
-#include <cstring>
+#include <ShellHelpers.h>
 
 namespace odh {
 
-// ── Helper: print a NameView via shell ──────────────────────────────────
-
-static void printName(Shell &shell, const char *prefix, NameView name) {
-#ifdef ODH_HAS_STRING_VIEW
-    shell.println("%s%.*s", prefix, static_cast<int>(name.size()), name.data());
-#else
-    shell.println("%s%s", prefix, name);
-#endif
-}
-
-// ── Helper: parse model name to ModelType ───────────────────────────────
-
-static bool parseModel(const char *str, ModelType &out) {
-    for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
-        auto mn = modelName(static_cast<ModelType>(m));
-#ifdef ODH_HAS_STRING_VIEW
-        bool match    = true;
-        const char *s = str;
-        for (size_t i = 0; i < mn.size(); ++i) {
-            if (*s == '\0' || (*s | 0x20) != (mn[i] | 0x20)) {
-                match = false;
-                break;
-            }
-            ++s;
-        }
-        if (match && *s == '\0') {
-            out = static_cast<ModelType>(m);
-            return true;
-        }
-#else
-        if (strcasecmp(str, mn) == 0) {
-            out = static_cast<ModelType>(m);
-            return true;
-        }
-#endif
-    }
-    return false;
-}
-
-// ── Helper: list available model names ──────────────────────────────────
-
-static void listModels(Shell &shell) {
-    shell.println("Available models:");
-    for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
-        printName(shell, "  ", modelName(static_cast<ModelType>(m)));
-    }
-}
-
-// ── Helper: list available function names ───────────────────────────────
-
-static void listFunctions(Shell &shell) {
-    shell.println("Available functions:");
-    for (uint8_t f = 0; f <= static_cast<uint8_t>(Function::TrackR); ++f) {
-        printName(shell, "  ", functionName(f));
-    }
-}
-
-// ── status ──────────────────────────────────────────────────────────────
-
-static int cmdStatus(Shell &shell, int, const char *const *, void *ctx) {
-    auto &app = *static_cast<TransmitterApp *>(ctx);
-
-    const char *linkStr = app.radio().isBound() ? "connected" : (app.radio().isScanning() ? "scanning" : "idle");
-    shell.println("Link:      %s", linkStr);
-
-    if (app.radio().isBound()) {
-        shell.println("RSSI:      %d dBm", app.radio().lastRssi());
-    }
-
-    shell.println("TX Batt:   %u mV (%uS)", app.battery().voltageMv(), app.battery().cells());
-
-    if (app.telemetry().hasData()) {
-        shell.println("RX Batt:   %u mV (%uS)", app.telemetry().rxBatteryMv(), app.telemetry().rxCells());
-        shell.println("RX RSSI:   %d dBm", app.telemetry().rssi());
-        shell.println("Pkts/s:    %.1f", static_cast<double>(app.telemetry().packetsPerSecond()));
-        shell.println("Uptime:    %lu ms", static_cast<unsigned long>(app.telemetry().connectionUptimeMs()));
-    }
-
-    return 0;
-}
-
-// ── bind ─────────────────────────────────────────────────────────────────
-
-static int cmdBind(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    auto &app = *static_cast<TransmitterApp *>(ctx);
-
-    if (argc < 2) {
-        shell.println("Usage: bind <scan|list|connect <n>|help>");
-        return 1;
-    }
-
-    if (strcmp(argv[1], "help") == 0) {
-        shell.println("bind sub-commands:");
-        shell.println("  scan        Start scanning for vehicles");
-        shell.println("  list        List discovered vehicles");
-        shell.println("  connect <n> Connect to vehicle by index");
-        return 0;
-    }
-
-    if (strcmp(argv[1], "scan") == 0) {
-        if (app.radio().isBound()) {
-            shell.println("Already connected – disconnect first");
-            return 1;
-        }
-        app.radio().startScanning();
-        shell.println("Scanning for vehicles...");
-        return 0;
-    }
-
-    if (strcmp(argv[1], "list") == 0) {
-        uint8_t count = app.radio().discoveredCount();
-        if (count == 0) {
-            shell.println("No vehicles discovered");
-            return 0;
-        }
-        for (uint8_t i = 0; i < count; ++i) {
-            const auto *v = app.radio().discoveredVehicle(i);
-            if (v && v->valid) {
-                auto mn = modelName(v->modelType);
-#ifdef ODH_HAS_STRING_VIEW
-                shell.println("  [%u] %-15s  %.*s  RSSI %d", i, v->name, static_cast<int>(mn.size()), mn.data(), v->rssi);
-#else
-                shell.println("  [%u] %-15s  %s  RSSI %d", i, v->name, mn, v->rssi);
-#endif
-            }
-        }
-        return 0;
-    }
-
-    if (strcmp(argv[1], "connect") == 0) {
-        if (argc < 3) {
-            shell.println("Usage: bind connect <index>");
-            return 1;
-        }
-        int idx = atoi(argv[2]);
-        if (idx < 0 || idx >= app.radio().discoveredCount()) {
-            shell.println("Index %d out of range (0-%d)", idx, app.radio().discoveredCount() - 1);
-            return 1;
-        }
-        const auto *veh = app.radio().discoveredVehicle(static_cast<uint8_t>(idx));
-        if (veh && veh->valid) {
-            app.loadInputMapForModel(veh->modelType);
-        }
-        if (app.radio().connectTo(static_cast<uint8_t>(idx))) {
-            shell.println("Connected to vehicle %d", idx);
-            app.telemetry().reset();
-        } else {
-            shell.println("Connection failed");
-        }
-        return 0;
-    }
-
-    shell.println("Unknown sub-command: %s", argv[1]);
-    return 1;
-}
-
-// ── disconnect ──────────────────────────────────────────────────────────
-
-static int cmdDisconnect(Shell &shell, int, const char *const *, void *ctx) {
-    auto &app = *static_cast<TransmitterApp *>(ctx);
-    if (!app.radio().isBound()) {
-        shell.println("Not connected");
-        return 1;
-    }
-    app.radio().disconnect();
-    shell.println("Disconnected – scanning");
-    return 0;
-}
-
-// ── channel ─────────────────────────────────────────────────────────────
-
-static int cmdChannel(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    auto &app = *static_cast<TransmitterApp *>(ctx);
-
-    if (argc < 2) {
-        shell.println("Usage: channel <get|set <idx> <us>>");
-        return 1;
-    }
-
-    if (strcmp(argv[1], "get") == 0) {
-        auto snap = app.snapshotFuncValues();
-        for (uint8_t i = 0; i < snap.second; ++i) {
-            auto fn = functionName(snap.first[i].function);
-#ifdef ODH_HAS_STRING_VIEW
-            shell.println("  [%u] %-10.*s %4u us  trim %+d", i, static_cast<int>(fn.size()), fn.data(), snap.first[i].value, snap.first[i].trim);
-#else
-            shell.println("  [%u] %-10s %4u us  trim %+d", i, fn, snap.first[i].value, snap.first[i].trim);
-#endif
-        }
-        return 0;
-    }
-
-    if (strcmp(argv[1], "set") == 0) {
-#ifdef NATIVE_SIM
-        if (argc < 4) {
-            shell.println("Usage: channel set <idx> <us>");
-            return 1;
-        }
-        int idx = atoi(argv[2]);
-        int us  = atoi(argv[3]);
-        if (idx < 0 || idx >= 16) {
-            shell.println("Index must be 0-15");
-            return 1;
-        }
-        if (us < kChannelMin || us > kChannelMax) {
-            shell.println("Value must be %d-%d", kChannelMin, kChannelMax);
-            return 1;
-        }
-        {
-            std::lock_guard<std::mutex> lock(g_simKeyboard.mtx);
-            g_simKeyboard.channels[idx] = static_cast<uint16_t>(us);
-        }
-        shell.println("Channel %d = %d us", idx, us);
-        return 0;
-#else
-        shell.println("channel set is only available in simulation");
-        return 1;
-#endif
-    }
-
-    shell.println("Unknown sub-command: %s", argv[1]);
-    return 1;
-}
-
-// ── trim ─────────────────────────────────────────────────────────────────
-
-static int cmdTrim(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    auto &app = *static_cast<TransmitterApp *>(ctx);
-
-    if (argc < 2) {
-        shell.println("Usage: trim <get|set <idx> <val>>");
-        return 1;
-    }
-
-    if (strcmp(argv[1], "get") == 0) {
-        auto snap = app.snapshotFuncValues();
-        for (uint8_t i = 0; i < snap.second; ++i) {
-            auto fn = functionName(snap.first[i].function);
-#ifdef ODH_HAS_STRING_VIEW
-            shell.println("  [%u] %-10.*s trim %+d", i, static_cast<int>(fn.size()), fn.data(), snap.first[i].trim);
-#else
-            shell.println("  [%u] %-10s trim %+d", i, fn, snap.first[i].trim);
-#endif
-        }
-        return 0;
-    }
-
-    if (strcmp(argv[1], "set") == 0) {
-        if (argc < 4) {
-            shell.println("Usage: trim set <idx> <value>");
-            return 1;
-        }
-        int idx = atoi(argv[2]);
-        int val = atoi(argv[3]);
-        if (val < -100 || val > 100) {
-            shell.println("Trim must be -100 to +100");
-            return 1;
-        }
-        if (!app.setTrim(static_cast<uint8_t>(idx), static_cast<int8_t>(val))) {
-            shell.println("Index %d out of range", idx);
-            return 1;
-        }
-        shell.println("Trim[%d] = %+d", idx, val);
-        return 0;
-    }
-
-    shell.println("Unknown sub-command: %s", argv[1]);
-    return 1;
-}
-
-// ── module ──────────────────────────────────────────────────────────────
-
-// cppcheck-suppress constParameterCallback
-static int cmdModule(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    if (argc < 2) {
-        shell.println("Usage: module <list>");
-        return 1;
-    }
-
-    if (strcmp(argv[1], "list") == 0) {
-        const auto &app = *static_cast<const TransmitterApp *>(ctx);
-        for (uint8_t s = 0; s < app.modules().slotCount(); ++s) {
-            const char *typeStr = "empty";
-            switch (app.modules().typeAt(s)) {
-            case ModuleType::Switch:
-                typeStr = "Switch";
-                break;
-            case ModuleType::Button:
-                typeStr = "Button";
-                break;
-            case ModuleType::Potentiometer:
-                typeStr = "Pot";
-                break;
-            case ModuleType::Encoder:
-                typeStr = "Encoder";
-                break;
-            default:
-                break;
-            }
-            shell.println("  Slot %u: %s (%u inputs)", s, typeStr, app.modules().inputCount(s));
-        }
-        return 0;
-    }
-
-    shell.println("Unknown sub-command: %s", argv[1]);
-    return 1;
-}
-
-// ── input ───────────────────────────────────────────────────────────────
-
-static int cmdInput(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    auto &app = *static_cast<TransmitterApp *>(ctx);
-
-    if (argc < 2) {
-        shell.println("Usage: input <get|help|reset>");
-        return 1;
-    }
-
-    if (strcmp(argv[1], "get") == 0) {
-        auto snap = app.snapshotFuncValues();
-        if (snap.second == 0) {
-            shell.println("No input map configured");
-            return 0;
-        }
-        for (uint8_t i = 0; i < snap.second; ++i) {
-            auto fn = functionName(snap.first[i].function);
-#ifdef ODH_HAS_STRING_VIEW
-            shell.println("  [%u] %.*s  value %u us  trim %+d", i, static_cast<int>(fn.size()), fn.data(), snap.first[i].value, snap.first[i].trim);
-#else
-            shell.println("  [%u] %s  value %u us  trim %+d", i, fn, snap.first[i].value, snap.first[i].trim);
-#endif
-        }
-        return 0;
-    }
-
-    if (strcmp(argv[1], "help") == 0) {
-        listFunctions(shell);
-        return 0;
-    }
-
-    if (strcmp(argv[1], "reset") == 0) {
-        NvsStore nvs("odh", true);
-        uint8_t model = nvs.getU8("model_type", static_cast<uint8_t>(ModelType::Generic));
-        app.loadInputMapForModel(model);
-        shell.println("Input map reset to defaults");
-        return 0;
-    }
-
-    shell.println("Unknown sub-command: %s", argv[1]);
-    return 1;
-}
-
-// ── config ──────────────────────────────────────────────────────────────
-
-static int cmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx) {
-    if (argc < 2) {
-        shell.println("Usage: config <get|set|help|reset>");
-        return 1;
-    }
-
-    // ── config get ──
-    if (strcmp(argv[1], "get") == 0) {
-        NvsStore nvs("odh", true);
-        shell.println("  radio_ch:  %u", nvs.getU8("radio_ch", channel::kDefaultChannel));
-
-        uint8_t modelRaw = nvs.getU8("model_type", static_cast<uint8_t>(ModelType::Generic));
-        printName(shell, "  model:     ", modelName(modelRaw));
-
-        shell.println("  tx_cells:  %u", nvs.getU8("tx_cells", 0));
-        shell.println("  rx_cells:  %u", nvs.getU8("rx_cells", 0));
-        String dn = nvs.getString("dev_name", "TX");
-        shell.println("  dev_name:  %s", dn.c_str());
-        return 0;
-    }
-
-    // ── config help ──
-    if (strcmp(argv[1], "help") == 0) {
-        shell.println("Available config keys:");
-        shell.println("  radio_ch   WiFi channel (1, 6, 11)");
-        shell.println("  model      Model type:");
-        for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
-            printName(shell, "               ", modelName(static_cast<ModelType>(m)));
-        }
-        shell.println("  tx_cells   TX battery cells (0-6, 0=auto)");
-        shell.println("  rx_cells   RX battery cells (0-6, 0=auto)");
-        shell.println("  dev_name   Device name (max %u chars)", kVehicleNameMax - 1);
-        return 0;
-    }
-
-    // ── config reset ──
-    if (strcmp(argv[1], "reset") == 0) {
-        NvsStore nvs("odh", false);
-        nvs.raw().clear();
-        shell.println("Config reset – restart required");
-        return 0;
-    }
-
-    // ── config set ──
-    if (strcmp(argv[1], "set") == 0) {
-        if (argc < 4) {
-            shell.println("Usage: config set <key> <value>");
-            shell.println("  Use 'config help' to see available keys");
-            return 1;
-        }
-
-        NvsStore nvs("odh", false);
-
-        if (strcmp(argv[2], "radio_ch") == 0) {
-            int ch = atoi(argv[3]);
-            if (!channel::isValidChannel(static_cast<uint8_t>(ch))) {
-                shell.println("Invalid channel (valid: 1, 6, 11)");
-                return 1;
-            }
-            nvs.putU8("radio_ch", static_cast<uint8_t>(ch));
-            shell.println("radio_ch = %d (restart required)", ch);
-            return 0;
-        }
-
-        if (strcmp(argv[2], "model") == 0) {
-            ModelType model;
-            if (!parseModel(argv[3], model)) {
-                shell.println("Unknown model: %s", argv[3]);
-                listModels(shell);
-                return 1;
-            }
-            nvs.putU8("model_type", static_cast<uint8_t>(model));
-            auto &app = *static_cast<TransmitterApp *>(ctx);
-            app.loadInputMapForModel(static_cast<uint8_t>(model));
-            printName(shell, "model = ", modelName(model));
-            return 0;
-        }
-
-        if (strcmp(argv[2], "tx_cells") == 0) {
-            int c = atoi(argv[3]);
-            if (c < 0 || c > 6) {
-                shell.println("Must be 0-6 (0 = auto)");
-                return 1;
-            }
-            nvs.putU8("tx_cells", static_cast<uint8_t>(c));
-            shell.println("tx_cells = %d", c);
-            return 0;
-        }
-
-        if (strcmp(argv[2], "rx_cells") == 0) {
-            int c = atoi(argv[3]);
-            if (c < 0 || c > 6) {
-                shell.println("Must be 0-6 (0 = auto)");
-                return 1;
-            }
-            nvs.putU8("rx_cells", static_cast<uint8_t>(c));
-            shell.println("rx_cells = %d", c);
-            return 0;
-        }
-
-        if (strcmp(argv[2], "dev_name") == 0) {
-            nvs.putString("dev_name", argv[3]);
-            shell.println("dev_name = %s", argv[3]);
-            return 0;
-        }
-
-        shell.println("Unknown key: %s", argv[2]);
-        shell.println("  Use 'config help' to see available keys");
-        return 1;
-    }
-
-    shell.println("Unknown sub-command: %s", argv[1]);
-    return 1;
-}
-
-// ── rescan ──────────────────────────────────────────────────────────────
-
-// cppcheck-suppress constParameterCallback
-static int cmdRescan(Shell &shell, int, const char *const *, void *ctx) {
-    auto &app = *static_cast<TransmitterApp *>(ctx);
-    if (app.radio().isBound()) {
-        shell.println("Cannot rescan while connected – disconnect first");
-        return 1;
-    }
-    app.rescan();
-    shell.println("Channel rescan initiated");
-    return 0;
-}
-
-// ── reboot ──────────────────────────────────────────────────────────────
-
-// cppcheck-suppress constParameterCallback
-static int cmdReboot(Shell &shell, int, const char *const *, void *) {
-#ifdef NATIVE_SIM
-    shell.println("Reboot not available in simulation");
-    return 1;
-#else
-    shell.println("Rebooting...");
-    delay(100);
-    ESP.restart();
-    return 0; // unreachable
-#endif
-}
-
-// ── Registration ────────────────────────────────────────────────────────
-
 void registerTransmitterShellCommands(Shell &shell, TransmitterApp &app) {
-    shell.registerCommand("status", "Show link, battery and telemetry", cmdStatus, &app);
-    shell.registerCommand("bind", "Bind: scan, list, connect <n>, help", cmdBind, &app);
-    shell.registerCommand("disconnect", "Disconnect from vehicle", cmdDisconnect, &app);
-    shell.registerCommand("channel", "Channel: get, set <idx> <us>", cmdChannel, &app);
-    shell.registerCommand("trim", "Trim: get, set <idx> <val>", cmdTrim, &app);
-    shell.registerCommand("module", "Module: list", cmdModule, &app);
-    shell.registerCommand("input", "Input map: get, help, reset", cmdInput, &app);
-    shell.registerCommand("config", "Config: get, set, help, reset", cmdConfig, &app);
-    shell.registerCommand("rescan", "Rescan WiFi channels", cmdRescan, &app);
+    shell.registerCommand("status", "Show link, battery and telemetry", txCmdStatus, &app);
+    shell.registerCommand("bind", "Bind: scan, list, connect <n>, help", txCmdBind, &app);
+    shell.registerCommand("disconnect", "Disconnect from vehicle", txCmdDisconnect, &app);
+    shell.registerCommand("channel", "Channel: get, set <idx> <us>", txCmdChannel, &app);
+    shell.registerCommand("trim", "Trim: get, set <idx> <val>", txCmdTrim, &app);
+    shell.registerCommand("module", "Module: list", txCmdModule, &app);
+    shell.registerCommand("input", "Input map: get, help, reset", txCmdInput, &app);
+    shell.registerCommand("config", "Config: get, set, help, reset", txCmdConfig, &app);
+    shell.registerCommand("rescan", "Rescan WiFi channels", txCmdRescan, &app);
     shell.registerCommand("reboot", "Restart the device", cmdReboot, nullptr);
 }
 
diff --git a/firmware/src/transmitter/shell/cmd_bind.cpp b/firmware/src/transmitter/shell/cmd_bind.cpp
new file mode 100644
index 0000000..c4d1aaa
--- /dev/null
+++ b/firmware/src/transmitter/shell/cmd_bind.cpp
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * cmd_bind – ``bind`` and ``disconnect`` command handlers for the transmitter.
+ */
+
+#include "../TransmitterApp.h"
+#include "TransmitterShellCmds.h"
+
+#include <FunctionMap.h>
+#include <Shell.h>
+#include <ShellHelpers.h>
+#include <cstdlib>
+#include <cstring>
+
+namespace odh {
+
+// ── bind ─────────────────────────────────────────────────────────────────
+
+int txCmdBind(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<TransmitterApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Usage: bind <scan|list|connect <n>|help>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "help") == 0) {
+        shell.println("bind sub-commands:");
+        shell.println("  scan        Start scanning for vehicles");
+        shell.println("  list        List discovered vehicles");
+        shell.println("  connect <n> Connect to vehicle by index");
+        return 0;
+    }
+
+    if (strcmp(argv[1], "scan") == 0) {
+        if (app.radio().isBound()) {
+            shell.println("Already connected – disconnect first");
+            return 1;
+        }
+        app.radio().startScanning();
+        shell.println("Scanning for vehicles...");
+        return 0;
+    }
+
+    if (strcmp(argv[1], "list") == 0) {
+        uint8_t count = app.radio().discoveredCount();
+        if (count == 0) {
+            shell.println("No vehicles discovered");
+            return 0;
+        }
+        for (uint8_t i = 0; i < count; ++i) {
+            const auto *v = app.radio().discoveredVehicle(i);
+            if (v && v->valid) {
+                auto mn = modelName(v->modelType);
+#ifdef ODH_HAS_STRING_VIEW
+                shell.println("  [%u] %-15s  %.*s  RSSI %d", i, v->name, static_cast<int>(mn.size()), mn.data(), v->rssi);
+#else
+                shell.println("  [%u] %-15s  %s  RSSI %d", i, v->name, mn, v->rssi);
+#endif
+            }
+        }
+        return 0;
+    }
+
+    if (strcmp(argv[1], "connect") == 0) {
+        if (argc < 3) {
+            shell.println("Usage: bind connect <index>");
+            return 1;
+        }
+        int idx = atoi(argv[2]);
+        if (idx < 0 || idx >= app.radio().discoveredCount()) {
+            shell.println("Index %d out of range (0-%d)", idx, app.radio().discoveredCount() - 1);
+            return 1;
+        }
+        const auto *veh = app.radio().discoveredVehicle(static_cast<uint8_t>(idx));
+        if (veh && veh->valid) {
+            app.loadInputMapForModel(veh->modelType);
+        }
+        if (app.radio().connectTo(static_cast<uint8_t>(idx))) {
+            shell.println("Connected to vehicle %d", idx);
+            app.telemetry().reset();
+        } else {
+            shell.println("Connection failed");
+        }
+        return 0;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+// ── disconnect ──────────────────────────────────────────────────────────
+
+int txCmdDisconnect(Shell &shell, int, const char *const *, void *ctx) {
+    auto &app = *static_cast<TransmitterApp *>(ctx);
+    if (!app.radio().isBound()) {
+        shell.println("Not connected");
+        return 1;
+    }
+    app.radio().disconnect();
+    shell.println("Disconnected – scanning");
+    return 0;
+}
+
+} // namespace odh
diff --git a/firmware/src/transmitter/shell/cmd_channel.cpp b/firmware/src/transmitter/shell/cmd_channel.cpp
new file mode 100644
index 0000000..445b163
--- /dev/null
+++ b/firmware/src/transmitter/shell/cmd_channel.cpp
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * cmd_channel – ``channel`` command handler for the transmitter.
+ */
+
+#include "../TransmitterApp.h"
+#include "TransmitterShellCmds.h"
+
+#include <FunctionMap.h>
+#include <Protocol.h>
+#include <Shell.h>
+
+#ifdef NATIVE_SIM
+#include <sim_keyboard.h>
+#endif
+
+#include <cstdlib>
+#include <cstring>
+
+namespace odh {
+
+int txCmdChannel(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<TransmitterApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Usage: channel <get|set <idx> <us>>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "get") == 0) {
+        auto snap = app.snapshotFuncValues();
+        for (uint8_t i = 0; i < snap.second; ++i) {
+            auto fn = functionName(snap.first[i].function);
+#ifdef ODH_HAS_STRING_VIEW
+            shell.println("  [%u] %-10.*s %4u us  trim %+d", i, static_cast<int>(fn.size()), fn.data(), snap.first[i].value, snap.first[i].trim);
+#else
+            shell.println("  [%u] %-10s %4u us  trim %+d", i, fn, snap.first[i].value, snap.first[i].trim);
+#endif
+        }
+        return 0;
+    }
+
+    if (strcmp(argv[1], "set") == 0) {
+#ifdef NATIVE_SIM
+        if (argc < 4) {
+            shell.println("Usage: channel set <idx> <us>");
+            return 1;
+        }
+        int idx = atoi(argv[2]);
+        int us  = atoi(argv[3]);
+        if (idx < 0 || idx >= 16) {
+            shell.println("Index must be 0-15");
+            return 1;
+        }
+        if (us < kChannelMin || us > kChannelMax) {
+            shell.println("Value must be %d-%d", kChannelMin, kChannelMax);
+            return 1;
+        }
+        {
+            std::lock_guard<std::mutex> lock(g_simKeyboard.mtx);
+            g_simKeyboard.channels[idx] = static_cast<uint16_t>(us);
+        }
+        shell.println("Channel %d = %d us", idx, us);
+        return 0;
+#else
+        shell.println("channel set is only available in simulation");
+        return 1;
+#endif
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+} // namespace odh
diff --git a/firmware/src/transmitter/shell/cmd_config.cpp b/firmware/src/transmitter/shell/cmd_config.cpp
new file mode 100644
index 0000000..385e7ad
--- /dev/null
+++ b/firmware/src/transmitter/shell/cmd_config.cpp
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * cmd_config – ``config`` command handler for the transmitter.
+ */
+
+#include "../TransmitterApp.h"
+#include "TransmitterShellCmds.h"
+
+#include <Channel.h>
+#include <Config.h>
+#include <FunctionMap.h>
+#include <NvsStore.h>
+#include <Protocol.h>
+#include <Shell.h>
+#include <ShellHelpers.h>
+#include <cstdlib>
+#include <cstring>
+
+namespace odh {
+
+int txCmdConfig(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    if (argc < 2) {
+        shell.println("Usage: config <get|set|help|reset>");
+        return 1;
+    }
+
+    // ── config get ──
+    if (strcmp(argv[1], "get") == 0) {
+        NvsStore nvs("odh", true);
+        shell.println("  radio_ch:  %u", nvs.getU8("radio_ch", channel::kDefaultChannel));
+
+        uint8_t modelRaw = nvs.getU8("model_type", static_cast<uint8_t>(ModelType::Generic));
+        shellPrintName(shell, "  model:     ", modelName(modelRaw));
+
+        shell.println("  tx_cells:  %u", nvs.getU8("tx_cells", 0));
+        shell.println("  rx_cells:  %u", nvs.getU8("rx_cells", 0));
+        String dn = nvs.getString("dev_name", "TX");
+        shell.println("  dev_name:  %s", dn.c_str());
+        return 0;
+    }
+
+    // ── config help ──
+    if (strcmp(argv[1], "help") == 0) {
+        shell.println("Available config keys:");
+        shell.println("  radio_ch   WiFi channel (1, 6, 11)");
+        shell.println("  model      Model type:");
+        for (uint8_t m = 0; m < static_cast<uint8_t>(ModelType::Count); ++m) {
+            shellPrintName(shell, "               ", modelName(static_cast<ModelType>(m)));
+        }
+        shell.println("  tx_cells   TX battery cells (0-6, 0=auto)");
+        shell.println("  rx_cells   RX battery cells (0-6, 0=auto)");
+        shell.println("  dev_name   Device name (max %u chars)", kVehicleNameMax - 1);
+        return 0;
+    }
+
+    // ── config reset ──
+    if (strcmp(argv[1], "reset") == 0) {
+        NvsStore nvs("odh", false);
+        nvs.raw().clear();
+        shell.println("Config reset – restart required");
+        return 0;
+    }
+
+    // ── config set ──
+    if (strcmp(argv[1], "set") == 0) {
+        if (argc < 4) {
+            shell.println("Usage: config set <key> <value>");
+            shell.println("  Use 'config help' to see available keys");
+            return 1;
+        }
+
+        NvsStore nvs("odh", false);
+
+        if (strcmp(argv[2], "radio_ch") == 0) {
+            int ch = atoi(argv[3]);
+            if (!channel::isValidChannel(static_cast<uint8_t>(ch))) {
+                shell.println("Invalid channel (valid: 1, 6, 11)");
+                return 1;
+            }
+            nvs.putU8("radio_ch", static_cast<uint8_t>(ch));
+            shell.println("radio_ch = %d (restart required)", ch);
+            return 0;
+        }
+
+        if (strcmp(argv[2], "model") == 0) {
+            ModelType model;
+            if (!shellParseModel(argv[3], model)) {
+                shell.println("Unknown model: %s", argv[3]);
+                shellListModels(shell);
+                return 1;
+            }
+            nvs.putU8("model_type", static_cast<uint8_t>(model));
+            auto &app = *static_cast<TransmitterApp *>(ctx);
+            app.loadInputMapForModel(static_cast<uint8_t>(model));
+            shellPrintName(shell, "model = ", modelName(model));
+            return 0;
+        }
+
+        if (strcmp(argv[2], "tx_cells") == 0) {
+            int c = atoi(argv[3]);
+            if (c < 0 || c > 6) {
+                shell.println("Must be 0-6 (0 = auto)");
+                return 1;
+            }
+            nvs.putU8("tx_cells", static_cast<uint8_t>(c));
+            shell.println("tx_cells = %d", c);
+            return 0;
+        }
+
+        if (strcmp(argv[2], "rx_cells") == 0) {
+            int c = atoi(argv[3]);
+            if (c < 0 || c > 6) {
+                shell.println("Must be 0-6 (0 = auto)");
+                return 1;
+            }
+            nvs.putU8("rx_cells", static_cast<uint8_t>(c));
+            shell.println("rx_cells = %d", c);
+            return 0;
+        }
+
+        if (strcmp(argv[2], "dev_name") == 0) {
+            nvs.putString("dev_name", argv[3]);
+            shell.println("dev_name = %s", argv[3]);
+            return 0;
+        }
+
+        shell.println("Unknown key: %s", argv[2]);
+        shell.println("  Use 'config help' to see available keys");
+        return 1;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+} // namespace odh
diff --git a/firmware/src/transmitter/shell/cmd_io.cpp b/firmware/src/transmitter/shell/cmd_io.cpp
new file mode 100644
index 0000000..6df9cb3
--- /dev/null
+++ b/firmware/src/transmitter/shell/cmd_io.cpp
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * cmd_io – ``trim``, ``module``, ``input`` and ``rescan`` command handlers
+ * for the transmitter.
+ */
+
+#include "../TransmitterApp.h"
+#include "TransmitterShellCmds.h"
+
+#include <FunctionMap.h>
+#include <NvsStore.h>
+#include <Protocol.h>
+#include <Shell.h>
+#include <ShellHelpers.h>
+#include <cstdlib>
+#include <cstring>
+
+namespace odh {
+
+// ── trim ─────────────────────────────────────────────────────────────────
+
+int txCmdTrim(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<TransmitterApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Usage: trim <get|set <idx> <val>>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "get") == 0) {
+        auto snap = app.snapshotFuncValues();
+        for (uint8_t i = 0; i < snap.second; ++i) {
+            auto fn = functionName(snap.first[i].function);
+#ifdef ODH_HAS_STRING_VIEW
+            shell.println("  [%u] %-10.*s trim %+d", i, static_cast<int>(fn.size()), fn.data(), snap.first[i].trim);
+#else
+            shell.println("  [%u] %-10s trim %+d", i, fn, snap.first[i].trim);
+#endif
+        }
+        return 0;
+    }
+
+    if (strcmp(argv[1], "set") == 0) {
+        if (argc < 4) {
+            shell.println("Usage: trim set <idx> <value>");
+            return 1;
+        }
+        int idx = atoi(argv[2]);
+        int val = atoi(argv[3]);
+        if (val < -100 || val > 100) {
+            shell.println("Trim must be -100 to +100");
+            return 1;
+        }
+        if (!app.setTrim(static_cast<uint8_t>(idx), static_cast<int8_t>(val))) {
+            shell.println("Index %d out of range", idx);
+            return 1;
+        }
+        shell.println("Trim[%d] = %+d", idx, val);
+        return 0;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+// ── module ──────────────────────────────────────────────────────────────
+
+// cppcheck-suppress constParameterCallback
+int txCmdModule(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    if (argc < 2) {
+        shell.println("Usage: module <list>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "list") == 0) {
+        const auto &app = *static_cast<const TransmitterApp *>(ctx);
+        for (uint8_t s = 0; s < app.modules().slotCount(); ++s) {
+            const char *typeStr = "empty";
+            switch (app.modules().typeAt(s)) {
+            case ModuleType::Switch:
+                typeStr = "Switch";
+                break;
+            case ModuleType::Button:
+                typeStr = "Button";
+                break;
+            case ModuleType::Potentiometer:
+                typeStr = "Pot";
+                break;
+            case ModuleType::Encoder:
+                typeStr = "Encoder";
+                break;
+            default:
+                break;
+            }
+            shell.println("  Slot %u: %s (%u inputs)", s, typeStr, app.modules().inputCount(s));
+        }
+        return 0;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+// ── input ───────────────────────────────────────────────────────────────
+
+int txCmdInput(Shell &shell, int argc, const char *const *argv, void *ctx) {
+    auto &app = *static_cast<TransmitterApp *>(ctx);
+
+    if (argc < 2) {
+        shell.println("Usage: input <get|help|reset>");
+        return 1;
+    }
+
+    if (strcmp(argv[1], "get") == 0) {
+        auto snap = app.snapshotFuncValues();
+        if (snap.second == 0) {
+            shell.println("No input map configured");
+            return 0;
+        }
+        for (uint8_t i = 0; i < snap.second; ++i) {
+            auto fn = functionName(snap.first[i].function);
+#ifdef ODH_HAS_STRING_VIEW
+            shell.println("  [%u] %.*s  value %u us  trim %+d", i, static_cast<int>(fn.size()), fn.data(), snap.first[i].value, snap.first[i].trim);
+#else
+            shell.println("  [%u] %s  value %u us  trim %+d", i, fn, snap.first[i].value, snap.first[i].trim);
+#endif
+        }
+        return 0;
+    }
+
+    if (strcmp(argv[1], "help") == 0) {
+        shellListFunctions(shell);
+        return 0;
+    }
+
+    if (strcmp(argv[1], "reset") == 0) {
+        NvsStore nvs("odh", true);
+        uint8_t model = nvs.getU8("model_type", static_cast<uint8_t>(ModelType::Generic));
+        app.loadInputMapForModel(model);
+        shell.println("Input map reset to defaults");
+        return 0;
+    }
+
+    shell.println("Unknown sub-command: %s", argv[1]);
+    return 1;
+}
+
+// ── rescan ──────────────────────────────────────────────────────────────
+
+// cppcheck-suppress constParameterCallback
+int txCmdRescan(Shell &shell, int, const char *const *, void *ctx) {
+    auto &app = *static_cast<TransmitterApp *>(ctx);
+    if (app.radio().isBound()) {
+        shell.println("Cannot rescan while connected – disconnect first");
+        return 1;
+    }
+    app.rescan();
+    shell.println("Channel rescan initiated");
+    return 0;
+}
+
+} // namespace odh
diff --git a/firmware/src/transmitter/shell/cmd_status.cpp b/firmware/src/transmitter/shell/cmd_status.cpp
new file mode 100644
index 0000000..bedee26
--- /dev/null
+++ b/firmware/src/transmitter/shell/cmd_status.cpp
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2026 Peter Buchegger
+ *
+ * This file is part of OpenDriveHub.
+ *
+ * OpenDriveHub is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * OpenDriveHub 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * cmd_status – ``status`` command handler for the transmitter.
+ */
+
+#include "../TransmitterApp.h"
+#include "TransmitterShellCmds.h"
+
+#include <Shell.h>
+
+namespace odh {
+
+int txCmdStatus(Shell &shell, int, const char *const *, void *ctx) {
+    auto &app = *static_cast<TransmitterApp *>(ctx);
+
+    const char *linkStr = app.radio().isBound() ? "connected" : (app.radio().isScanning() ? "scanning" : "idle");
+    shell.println("Link:      %s", linkStr);
+
+    if (app.radio().isBound()) {
+        shell.println("RSSI:      %d dBm", app.radio().lastRssi());
+    }
+
+    shell.println("TX Batt:   %u mV (%uS)", app.battery().voltageMv(), app.battery().cells());
+
+    if (app.telemetry().hasData()) {
+        shell.println("RX Batt:   %u mV (%uS)", app.telemetry().rxBatteryMv(), app.telemetry().rxCells());
+        shell.println("RX RSSI:   %d dBm", app.telemetry().rssi());
+        shell.println("Pkts/s:    %.1f", static_cast<double>(app.telemetry().packetsPerSecond()));
+        shell.println("Uptime:    %lu ms", static_cast<unsigned long>(app.telemetry().connectionUptimeMs()));
+    }
+
+    return 0;
+}
+
+} // namespace odh
diff --git a/firmware/test/test_console/common/__init__.py b/firmware/test/test_console/common/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/firmware/test/test_console/common/test_basics.py b/firmware/test/test_console/common/test_basics.py
new file mode 100644
index 0000000..e4548b8
--- /dev/null
+++ b/firmware/test/test_console/common/test_basics.py
@@ -0,0 +1,70 @@
+# Copyright (C) 2026 Peter Buchegger
+#
+# This file is part of OpenDriveHub.
+#
+# OpenDriveHub is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# OpenDriveHub 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Basic shell interaction tests (unknown command, empty line, sequential)."""
+
+from __future__ import annotations
+
+from console import Console
+
+
+class TestUnknownCommand:
+    """Verify behaviour when the user enters an unrecognised command."""
+
+    def test_unknown_command_error_message(self, console: Console) -> None:
+        output = console.send_command("foobar_nonexistent")
+        assert "unknown command" in output.lower(), (
+            f"Expected 'Unknown command' error, got:\n{output}"
+        )
+
+    def test_unknown_command_suggests_help(self, console: Console) -> None:
+        output = console.send_command("notacommand")
+        assert "help" in output.lower(), (
+            f"Expected suggestion to type 'help', got:\n{output}"
+        )
+
+
+class TestEmptyLine:
+    """Verify that pressing Enter without a command does nothing harmful."""
+
+    def test_empty_line_no_error(self, console: Console) -> None:
+        """An empty line should just produce a new prompt (no error)."""
+        output = console.send_command("")
+        assert "error" not in output.lower(), (
+            f"Empty line produced an error:\n{output}"
+        )
+        assert "unknown" not in output.lower(), (
+            f"Empty line triggered 'unknown command':\n{output}"
+        )
+
+
+class TestMultipleCommands:
+    """Verify that running several commands in sequence works."""
+
+    def test_sequential_commands(self, console: Console) -> None:
+        """Run 5 different commands and ensure all return valid output."""
+        commands = ["help", "status", "config get", "channel get", "help"]
+        for cmd in commands:
+            output = console.send_command(cmd)
+            assert len(output.strip()) > 0, (
+                f"Command {cmd!r} returned empty output"
+            )
+            assert "error" not in output.lower() or cmd == "config set", (
+                f"Command {cmd!r} produced error:\n{output}"
+            )
diff --git a/firmware/test/test_console/common/test_channel.py b/firmware/test/test_console/common/test_channel.py
new file mode 100644
index 0000000..5334c72
--- /dev/null
+++ b/firmware/test/test_console/common/test_channel.py
@@ -0,0 +1,43 @@
+# Copyright (C) 2026 Peter Buchegger
+#
+# This file is part of OpenDriveHub.
+#
+# OpenDriveHub is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# OpenDriveHub 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Tests for the ``channel`` command (shared by RX and TX)."""
+
+from __future__ import annotations
+
+from console import Console
+
+
+class TestChannelGet:
+    """Verify ``channel get`` shows channel information."""
+
+    def test_channel_get_returns_output(self, console: Console) -> None:
+        output = console.send_command("channel get")
+        assert len(output.strip()) > 0, "channel get returned empty output"
+
+
+class TestChannelGetNotList:
+    """Verify old ``channel list`` syntax is rejected."""
+
+    def test_channel_list_rejected(self, console: Console) -> None:
+        output = console.send_command("channel list")
+        out_lower = output.lower()
+        assert "unknown" in out_lower or "usage" in out_lower or "error" in out_lower, (
+            f"Expected error for old 'channel list' syntax:\n{output}"
+        )
diff --git a/firmware/test/test_console/test_commands_common.py b/firmware/test/test_console/common/test_config.py
similarity index 54%
rename from firmware/test/test_console/test_commands_common.py
rename to firmware/test/test_console/common/test_config.py
index d3b2108..2f5e462 100644
--- a/firmware/test/test_console/test_commands_common.py
+++ b/firmware/test/test_console/common/test_config.py
@@ -17,7 +17,7 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-"""Tests for commands shared by both receiver and transmitter."""
+"""Tests for the ``config`` command (shared by RX and TX)."""
 
 from __future__ import annotations
 
@@ -26,67 +26,6 @@
 from console import Console
 
 
-class TestUnknownCommand:
-    """Verify behaviour when the user enters an unrecognised command."""
-
-    def test_unknown_command_error_message(self, console: Console) -> None:
-        output = console.send_command("foobar_nonexistent")
-        assert "unknown command" in output.lower(), (
-            f"Expected 'Unknown command' error, got:\n{output}"
-        )
-
-    def test_unknown_command_suggests_help(self, console: Console) -> None:
-        output = console.send_command("notacommand")
-        assert "help" in output.lower(), (
-            f"Expected suggestion to type 'help', got:\n{output}"
-        )
-
-
-class TestEmptyLine:
-    """Verify that pressing Enter without a command does nothing harmful."""
-
-    def test_empty_line_no_error(self, console: Console) -> None:
-        """An empty line should just produce a new prompt (no error)."""
-        output = console.send_command("")
-        # Empty line should produce no output or just whitespace
-        assert "error" not in output.lower(), (
-            f"Empty line produced an error:\n{output}"
-        )
-        assert "unknown" not in output.lower(), (
-            f"Empty line triggered 'unknown command':\n{output}"
-        )
-
-
-class TestStatus:
-    """Verify the ``status`` command produces valid output."""
-
-    def test_status_returns_output(self, console: Console) -> None:
-        output = console.send_command("status")
-        assert len(output.strip()) > 0, "status returned empty output"
-
-    def test_status_contains_link_info(self, console: Console) -> None:
-        """``status`` must mention some kind of link/connection state."""
-        output = console.send_command("status").lower()
-        has_link_info = any(
-            kw in output
-            for kw in ("link", "connected", "disconnected", "scanning",
-                        "announcing", "idle", "state")
-        )
-        assert has_link_info, (
-            f"status output missing link info:\n{output}"
-        )
-
-    def test_status_contains_battery(self, console: Console) -> None:
-        """``status`` must mention battery information."""
-        output = console.send_command("status").lower()
-        has_battery = any(
-            kw in output for kw in ("battery", "batt", "voltage", "cell")
-        )
-        assert has_battery, (
-            f"status output missing battery info:\n{output}"
-        )
-
-
 class TestConfigGet:
     """Verify ``config get`` returns key-value data."""
 
@@ -109,56 +48,6 @@ def test_config_set_invalid_key(self, console: Console) -> None:
         )
 
 
-class TestConfigRoundtrip:
-    """Verify ``config set`` followed by ``config get`` persists values."""
-
-    @pytest.mark.rx
-    def test_config_set_get_batt_cell_rx(self, console: Console) -> None:
-        """RX: set batt_cell, read it back."""
-        console.send_command("config set batt_cell 3")
-        output = console.send_command("config get")
-        assert "3" in output, (
-            f"batt_cell not set to 3 in config get:\n{output}"
-        )
-        # Reset to auto
-        console.send_command("config set batt_cell 0")
-
-    @pytest.mark.tx
-    def test_config_set_get_tx_cells(self, console: Console) -> None:
-        """TX: set tx_cells, read it back."""
-        console.send_command("config set tx_cells 3")
-        output = console.send_command("config get")
-        assert "3" in output, (
-            f"tx_cells not set to 3 in config get:\n{output}"
-        )
-        # Reset to auto
-        console.send_command("config set tx_cells 0")
-
-
-class TestChannelGet:
-    """Verify ``channel get`` shows channel information."""
-
-    def test_channel_get_returns_output(self, console: Console) -> None:
-        output = console.send_command("channel get")
-        assert len(output.strip()) > 0, "channel get returned empty output"
-
-
-class TestMultipleCommands:
-    """Verify that running several commands in sequence works."""
-
-    def test_sequential_commands(self, console: Console) -> None:
-        """Run 5 different commands and ensure all return valid output."""
-        commands = ["help", "status", "config get", "channel get", "help"]
-        for cmd in commands:
-            output = console.send_command(cmd)
-            assert len(output.strip()) > 0, (
-                f"Command {cmd!r} returned empty output"
-            )
-            assert "error" not in output.lower() or cmd == "config set", (
-                f"Command {cmd!r} produced error:\n{output}"
-            )
-
-
 class TestConfigHelp:
     """Verify ``config help`` lists available keys with value ranges."""
 
@@ -246,17 +135,6 @@ def test_config_set_model_invalid(self, console: Console) -> None:
         )
 
 
-class TestChannelGetNotList:
-    """Verify old ``channel list`` syntax is rejected."""
-
-    def test_channel_list_rejected(self, console: Console) -> None:
-        output = console.send_command("channel list")
-        out_lower = output.lower()
-        assert "unknown" in out_lower or "usage" in out_lower or "error" in out_lower, (
-            f"Expected error for old 'channel list' syntax:\n{output}"
-        )
-
-
 class TestReboot:
     """Verify ``reboot`` in simulation."""
 
diff --git a/firmware/test/test_console/common/test_status.py b/firmware/test/test_console/common/test_status.py
new file mode 100644
index 0000000..8bc5673
--- /dev/null
+++ b/firmware/test/test_console/common/test_status.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2026 Peter Buchegger
+#
+# This file is part of OpenDriveHub.
+#
+# OpenDriveHub is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# OpenDriveHub 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Tests for the ``status`` command (shared by RX and TX)."""
+
+from __future__ import annotations
+
+from console import Console
+
+
+class TestStatus:
+    """Verify the ``status`` command produces valid output."""
+
+    def test_status_returns_output(self, console: Console) -> None:
+        output = console.send_command("status")
+        assert len(output.strip()) > 0, "status returned empty output"
+
+    def test_status_contains_link_info(self, console: Console) -> None:
+        """``status`` must mention some kind of link/connection state."""
+        output = console.send_command("status").lower()
+        has_link_info = any(
+            kw in output
+            for kw in ("link", "connected", "disconnected", "scanning",
+                        "announcing", "idle", "state")
+        )
+        assert has_link_info, (
+            f"status output missing link info:\n{output}"
+        )
+
+    def test_status_contains_battery(self, console: Console) -> None:
+        """``status`` must mention battery information."""
+        output = console.send_command("status").lower()
+        has_battery = any(
+            kw in output for kw in ("battery", "batt", "voltage", "cell")
+        )
+        assert has_battery, (
+            f"status output missing battery info:\n{output}"
+        )
diff --git a/firmware/test/test_console/rx/__init__.py b/firmware/test/test_console/rx/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/firmware/test/test_console/rx/test_channel.py b/firmware/test/test_console/rx/test_channel.py
new file mode 100644
index 0000000..e8f701f
--- /dev/null
+++ b/firmware/test/test_console/rx/test_channel.py
@@ -0,0 +1,104 @@
+# Copyright (C) 2026 Peter Buchegger
+#
+# This file is part of OpenDriveHub.
+#
+# OpenDriveHub is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# OpenDriveHub 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Receiver-specific tests for ``channel``, ``vehicle`` and config roundtrip."""
+
+from __future__ import annotations
+
+import pytest
+
+from console import Console
+
+pytestmark = pytest.mark.rx
+
+
+class TestVehicle:
+    """Verify the ``vehicle`` command for getting/setting the vehicle name."""
+
+    def test_vehicle_get(self, console: Console) -> None:
+        """``vehicle`` (no args) must return a name string."""
+        output = console.send_command("vehicle")
+        assert len(output.strip()) > 0, "vehicle returned empty output"
+
+    def test_vehicle_set_get_roundtrip(self, console: Console) -> None:
+        """Set vehicle name, then read it back."""
+        original = console.send_command("vehicle").strip()
+
+        console.send_command('vehicle "TestCar"')
+        output = console.send_command("vehicle")
+        assert "TestCar" in output, (
+            f"Vehicle name not updated to TestCar:\n{output}"
+        )
+
+        if original:
+            console.send_command(f'vehicle "{original}"')
+
+
+class TestChannelSetRx:
+    """Verify ``channel set`` on the receiver."""
+
+    def test_channel_set_valid(self, console: Console) -> None:
+        """Setting channel 0 to 1500us must succeed."""
+        output = console.send_command("channel set 0 1500")
+        out_lower = output.lower()
+        assert "error" not in out_lower and "invalid" not in out_lower, (
+            f"Valid channel set failed:\n{output}"
+        )
+
+    def test_channel_set_invalid_index(self, console: Console) -> None:
+        """Setting an out-of-range channel index must fail."""
+        output = console.send_command("channel set 99 1500")
+        out_lower = output.lower()
+        assert "error" in out_lower or "invalid" in out_lower or "range" in out_lower or "must be" in out_lower, (
+            f"Expected error for invalid channel index:\n{output}"
+        )
+
+    def test_channel_set_invalid_value(self, console: Console) -> None:
+        """Setting an out-of-range PWM value must fail."""
+        output = console.send_command("channel set 0 9999")
+        out_lower = output.lower()
+        assert "error" in out_lower or "invalid" in out_lower or "range" in out_lower or "must be" in out_lower, (
+            f"Expected error for invalid PWM value:\n{output}"
+        )
+
+
+class TestConfigSetVehicle:
+    """Verify ``config set vehicle`` on the receiver."""
+
+    def test_config_set_vehicle(self, console: Console) -> None:
+        """Setting vehicle via config set must update vehicle name."""
+        console.send_command('config set vehicle "TestTruck"')
+        output = console.send_command("vehicle")
+        assert "TestTruck" in output, (
+            f"Vehicle not set to TestTruck:\n{output}"
+        )
+        console.send_command('config set vehicle "RX"')
+
+
+class TestConfigRoundtripRx:
+    """Verify ``config set`` followed by ``config get`` persists values."""
+
+    def test_config_set_get_batt_cell_rx(self, console: Console) -> None:
+        """RX: set batt_cell, read it back."""
+        console.send_command("config set batt_cell 3")
+        output = console.send_command("config get")
+        assert "3" in output, (
+            f"batt_cell not set to 3 in config get:\n{output}"
+        )
+        console.send_command("config set batt_cell 0")
diff --git a/firmware/test/test_console/test_commands_rx.py b/firmware/test/test_console/rx/test_output.py
similarity index 63%
rename from firmware/test/test_console/test_commands_rx.py
rename to firmware/test/test_console/rx/test_output.py
index e1117a8..085c8dc 100644
--- a/firmware/test/test_console/test_commands_rx.py
+++ b/firmware/test/test_console/rx/test_output.py
@@ -17,7 +17,7 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-"""Receiver-specific console command tests."""
+"""Receiver-specific tests for ``mapping`` and ``failsafe`` commands."""
 
 from __future__ import annotations
 
@@ -28,58 +28,6 @@
 pytestmark = pytest.mark.rx
 
 
-class TestVehicle:
-    """Verify the ``vehicle`` command for getting/setting the vehicle name."""
-
-    def test_vehicle_get(self, console: Console) -> None:
-        """``vehicle`` (no args) must return a name string."""
-        output = console.send_command("vehicle")
-        assert len(output.strip()) > 0, "vehicle returned empty output"
-
-    def test_vehicle_set_get_roundtrip(self, console: Console) -> None:
-        """Set vehicle name, then read it back."""
-        # Save original
-        original = console.send_command("vehicle").strip()
-
-        console.send_command('vehicle "TestCar"')
-        output = console.send_command("vehicle")
-        assert "TestCar" in output, (
-            f"Vehicle name not updated to TestCar:\n{output}"
-        )
-
-        # Restore original
-        if original:
-            console.send_command(f'vehicle "{original}"')
-
-
-class TestChannelSetRx:
-    """Verify ``channel set`` on the receiver."""
-
-    def test_channel_set_valid(self, console: Console) -> None:
-        """Setting channel 0 to 1500µs must succeed."""
-        output = console.send_command("channel set 0 1500")
-        out_lower = output.lower()
-        assert "error" not in out_lower and "invalid" not in out_lower, (
-            f"Valid channel set failed:\n{output}"
-        )
-
-    def test_channel_set_invalid_index(self, console: Console) -> None:
-        """Setting an out-of-range channel index must fail."""
-        output = console.send_command("channel set 99 1500")
-        out_lower = output.lower()
-        assert "error" in out_lower or "invalid" in out_lower or "range" in out_lower or "must be" in out_lower, (
-            f"Expected error for invalid channel index:\n{output}"
-        )
-
-    def test_channel_set_invalid_value(self, console: Console) -> None:
-        """Setting an out-of-range PWM value must fail."""
-        output = console.send_command("channel set 0 9999")
-        out_lower = output.lower()
-        assert "error" in out_lower or "invalid" in out_lower or "range" in out_lower or "must be" in out_lower, (
-            f"Expected error for invalid PWM value:\n{output}"
-        )
-
-
 class TestMapping:
     """Verify the ``mapping`` command for function-to-channel mapping."""
 
@@ -124,11 +72,9 @@ def test_mapping_reset_roundtrip(self, console: Console) -> None:
         console.send_command("mapping reset")
         output = console.send_command("mapping get")
         out_lower = output.lower()
-        # Excavator defaults include BoomUD, Bucket, Swing
         assert "boom" in out_lower or "bucket" in out_lower or "track" in out_lower, (
             f"Excavator mapping not applied:\n{output}"
         )
-        # Reset back to Generic
         console.send_command("config set model Generic")
         console.send_command("mapping reset")
 
@@ -151,7 +97,6 @@ def test_failsafe_set(self, console: Console) -> None:
         assert "1200" in output, (
             f"Failsafe value 1200 not found:\n{output}"
         )
-        # Reset to default
         console.send_command("failsafe set 0 1500")
 
     def test_failsafe_set_invalid_channel(self, console: Console) -> None:
@@ -177,17 +122,3 @@ def test_failsafe_no_subcommand(self, console: Console) -> None:
         assert "usage" in out_lower or "get" in out_lower, (
             f"Expected usage hint:\n{output}"
         )
-
-
-class TestConfigSetVehicle:
-    """Verify ``config set vehicle`` on the receiver."""
-
-    def test_config_set_vehicle(self, console: Console) -> None:
-        """Setting vehicle via config set must update vehicle name."""
-        console.send_command('config set vehicle "TestTruck"')
-        output = console.send_command("vehicle")
-        assert "TestTruck" in output, (
-            f"Vehicle not set to TestTruck:\n{output}"
-        )
-        # Restore
-        console.send_command('config set vehicle "RX"')
diff --git a/firmware/test/test_console/tx/__init__.py b/firmware/test/test_console/tx/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/firmware/test/test_console/tx/test_bind.py b/firmware/test/test_console/tx/test_bind.py
new file mode 100644
index 0000000..d02d439
--- /dev/null
+++ b/firmware/test/test_console/tx/test_bind.py
@@ -0,0 +1,75 @@
+# Copyright (C) 2026 Peter Buchegger
+#
+# This file is part of OpenDriveHub.
+#
+# OpenDriveHub is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# OpenDriveHub 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Transmitter-specific tests for ``bind`` and ``disconnect`` commands."""
+
+from __future__ import annotations
+
+import pytest
+
+from console import Console
+
+pytestmark = pytest.mark.tx
+
+
+class TestBind:
+    """Verify ``bind`` subcommands."""
+
+    def test_bind_scan(self, console: Console) -> None:
+        """``bind scan`` must not crash."""
+        output = console.send_command("bind scan")
+        out_lower = output.lower()
+        assert "error" not in out_lower and "unknown" not in out_lower, (
+            f"bind scan failed:\n{output}"
+        )
+
+    def test_bind_list(self, console: Console) -> None:
+        """``bind list`` must return output (may be empty list)."""
+        output = console.send_command("bind list")
+        assert "error" not in output.lower(), (
+            f"bind list returned error:\n{output}"
+        )
+
+
+class TestBindHelp:
+    """Verify ``bind help`` shows sub-commands."""
+
+    def test_bind_help(self, console: Console) -> None:
+        output = console.send_command("bind help")
+        out_lower = output.lower()
+        assert "scan" in out_lower, (
+            f"bind help missing 'scan':\n{output}"
+        )
+        assert "list" in out_lower, (
+            f"bind help missing 'list':\n{output}"
+        )
+        assert "connect" in out_lower, (
+            f"bind help missing 'connect':\n{output}"
+        )
+
+
+class TestDisconnect:
+    """Verify ``disconnect`` when not connected."""
+
+    def test_disconnect_when_idle(self, console: Console) -> None:
+        """``disconnect`` when not connected must not crash."""
+        output = console.send_command("disconnect")
+        assert "error" not in output.lower() or "not connected" in output.lower(), (
+            f"disconnect produced unexpected error:\n{output}"
+        )
diff --git a/firmware/test/test_console/tx/test_config.py b/firmware/test/test_console/tx/test_config.py
new file mode 100644
index 0000000..10f58fe
--- /dev/null
+++ b/firmware/test/test_console/tx/test_config.py
@@ -0,0 +1,41 @@
+# Copyright (C) 2026 Peter Buchegger
+#
+# This file is part of OpenDriveHub.
+#
+# OpenDriveHub is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# OpenDriveHub 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 General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with OpenDriveHub. If not, see <https://www.gnu.org/licenses/>.
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Transmitter-specific config roundtrip tests."""
+
+from __future__ import annotations
+
+import pytest
+
+from console import Console
+
+pytestmark = pytest.mark.tx
+
+
+class TestConfigRoundtripTx:
+    """Verify ``config set`` followed by ``config get`` persists values."""
+
+    def test_config_set_get_tx_cells(self, console: Console) -> None:
+        """TX: set tx_cells, read it back."""
+        console.send_command("config set tx_cells 3")
+        output = console.send_command("config get")
+        assert "3" in output, (
+            f"tx_cells not set to 3 in config get:\n{output}"
+        )
+        console.send_command("config set tx_cells 0")
diff --git a/firmware/test/test_console/test_commands_tx.py b/firmware/test/test_console/tx/test_io.py
similarity index 72%
rename from firmware/test/test_console/test_commands_tx.py
rename to firmware/test/test_console/tx/test_io.py
index 8bae405..17df4cc 100644
--- a/firmware/test/test_console/test_commands_tx.py
+++ b/firmware/test/test_console/tx/test_io.py
@@ -17,7 +17,7 @@
 #
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-"""Transmitter-specific console command tests."""
+"""Transmitter-specific tests for ``trim``, ``module``, ``input`` and ``rescan``."""
 
 from __future__ import annotations
 
@@ -28,38 +28,6 @@
 pytestmark = pytest.mark.tx
 
 
-class TestBind:
-    """Verify ``bind`` subcommands."""
-
-    def test_bind_scan(self, console: Console) -> None:
-        """``bind scan`` must not crash."""
-        output = console.send_command("bind scan")
-        out_lower = output.lower()
-        assert "error" not in out_lower and "unknown" not in out_lower, (
-            f"bind scan failed:\n{output}"
-        )
-
-    def test_bind_list(self, console: Console) -> None:
-        """``bind list`` must return output (may be empty list)."""
-        output = console.send_command("bind list")
-        # Might say "no vehicles" or list entries – both are fine
-        assert "error" not in output.lower(), (
-            f"bind list returned error:\n{output}"
-        )
-
-
-class TestDisconnect:
-    """Verify ``disconnect`` when not connected."""
-
-    def test_disconnect_when_idle(self, console: Console) -> None:
-        """``disconnect`` when not connected must not crash."""
-        output = console.send_command("disconnect")
-        # May say "not connected" or similar – that's fine
-        assert "error" not in output.lower() or "not connected" in output.lower(), (
-            f"disconnect produced unexpected error:\n{output}"
-        )
-
-
 class TestTrim:
     """Verify ``trim`` subcommands."""
 
@@ -75,7 +43,6 @@ def test_trim_set_get_roundtrip(self, console: Console) -> None:
         assert "50" in output, (
             f"trim value 50 not found in trim get:\n{output}"
         )
-        # Reset trim
         console.send_command("trim set 0 0")
 
     def test_trim_set_invalid_range(self, console: Console) -> None:
@@ -87,6 +54,17 @@ def test_trim_set_invalid_range(self, console: Console) -> None:
         )
 
 
+class TestTrimGetNotList:
+    """Verify old ``trim list`` syntax is rejected."""
+
+    def test_trim_list_rejected(self, console: Console) -> None:
+        output = console.send_command("trim list")
+        out_lower = output.lower()
+        assert "unknown" in out_lower or "usage" in out_lower or "error" in out_lower, (
+            f"Expected error for old 'trim list' syntax:\n{output}"
+        )
+
+
 class TestModule:
     """Verify ``module list`` command."""
 
@@ -153,31 +131,3 @@ def test_rescan(self, console: Console) -> None:
         assert "error" not in output.lower(), (
             f"rescan returned error:\n{output}"
         )
-
-
-class TestTrimGetNotList:
-    """Verify old ``trim list`` syntax is rejected."""
-
-    def test_trim_list_rejected(self, console: Console) -> None:
-        output = console.send_command("trim list")
-        out_lower = output.lower()
-        assert "unknown" in out_lower or "usage" in out_lower or "error" in out_lower, (
-            f"Expected error for old 'trim list' syntax:\n{output}"
-        )
-
-
-class TestBindHelp:
-    """Verify ``bind help`` shows sub-commands."""
-
-    def test_bind_help(self, console: Console) -> None:
-        output = console.send_command("bind help")
-        out_lower = output.lower()
-        assert "scan" in out_lower, (
-            f"bind help missing 'scan':\n{output}"
-        )
-        assert "list" in out_lower, (
-            f"bind help missing 'list':\n{output}"
-        )
-        assert "connect" in out_lower, (
-            f"bind help missing 'connect':\n{output}"
-        )

From 1e48ea0da5e3e806940c8c1c94bf88ad65ed1be8 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Fri, 13 Mar 2026 19:22:07 +0000
Subject: [PATCH 05/11] Initial plan


From 31c615b6c361fdb19b2407dbf3151995d8dc7849 Mon Sep 17 00:00:00 2001
From: Peter Buchegger <peter.buchegger7@gmail.com>
Date: Fri, 13 Mar 2026 20:25:47 +0100
Subject: [PATCH 06/11] fix: correct cppcheck suppression and add missing
 include paths to CI

- Change cppcheck-suppress from constParameterCallback to
  constParameterPointer in cmd_io.cpp (txCmdModule)
- Add -I firmware/lib/odh-shell and -I firmware/lib/odh-channel
  to cppcheck CI job
---
 .github/workflows/ci.yml                  | 2 ++
 firmware/src/transmitter/shell/cmd_io.cpp | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 22ada61..df5c74f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -270,6 +270,8 @@ jobs:
             -I firmware/lib/odh-radio \
             -I firmware/lib/odh-telemetry \
             -I firmware/lib/odh-web \
+            -I firmware/lib/odh-shell \
+            -I firmware/lib/odh-channel \
             firmware/src \
             firmware/lib
 
diff --git a/firmware/src/transmitter/shell/cmd_io.cpp b/firmware/src/transmitter/shell/cmd_io.cpp
index 6df9cb3..48514c7 100644
--- a/firmware/src/transmitter/shell/cmd_io.cpp
+++ b/firmware/src/transmitter/shell/cmd_io.cpp
@@ -85,7 +85,7 @@ int txCmdTrim(Shell &shell, int argc, const char *const *argv, void *ctx) {
 
 // ── module ──────────────────────────────────────────────────────────────
 
-// cppcheck-suppress constParameterCallback
+// cppcheck-suppress constParameterPointer
 int txCmdModule(Shell &shell, int argc, const char *const *argv, void *ctx) {
     if (argc < 2) {
         shell.println("Usage: module <list>");

From b33d8249f2b4ab651213855f6dac2d5977f748b4 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Fri, 13 Mar 2026 19:36:50 +0000
Subject: [PATCH 07/11] fix: address review comments - dangling callback ref,
 UDP multicast fan-out, thread-safe channel switch

Co-authored-by: peterus <1764325+peterus@users.noreply.github.com>
---
 firmware/sim/src/sim_espnow.cpp           | 75 +++++++++++++++++++----
 firmware/src/receiver/ReceiverApp.cpp     | 10 ++-
 firmware/src/transmitter/shell/cmd_io.cpp |  2 +-
 3 files changed, 74 insertions(+), 13 deletions(-)

diff --git a/firmware/sim/src/sim_espnow.cpp b/firmware/sim/src/sim_espnow.cpp
index 4c6c289..d7cc6e4 100644
--- a/firmware/sim/src/sim_espnow.cpp
+++ b/firmware/sim/src/sim_espnow.cpp
@@ -20,10 +20,18 @@
  */
 
 /**
- * sim_espnow.cpp – ESP-NOW over UDP sockets.
+ * sim_espnow.cpp – ESP-NOW over UDP multicast sockets.
+ *
+ * Each WiFi channel maps to a UDP multicast group and port:
+ *   channel 1  → 239.0.0.1:7001
+ *   channel 6  → 239.0.0.6:7006
+ *   channel 11 → 239.0.0.11:7011
+ *
+ * Using multicast ensures that every process on the same channel receives
+ * every packet (fan-out), unlike SO_REUSEPORT unicast which only delivers
+ * to one socket.  The receive thread is stopped and restarted whenever the
+ * channel changes so the socket is never accessed concurrently with rebind.
  *
- * Each WiFi channel maps to a shared UDP port (port = 7000 + channel).
- * All devices on the same channel listen and send on the same port.
  * Packets include a 6-byte source MAC header prepended to the original
  * payload so the receive callback gets the sender's address.
  * Self-packets are filtered by comparing the source MAC.
@@ -61,6 +69,15 @@ static std::mutex s_peerMutex;
 static uint8_t s_localMac[6]    = {};
 static uint8_t s_currentChannel = 1;
 
+/* ── Multicast helper ───────────────────────────────────────────────────── */
+
+/// Returns the multicast group IPv4 address for the given channel in host
+/// byte order: channel ch → 239.0.0.ch.
+/// Valid input channels are 1, 6, and 11 (see channel::kCandidateChannels).
+static inline uint32_t channelMulticastIp(uint8_t ch) {
+    return (239u << 24) | static_cast<uint32_t>(ch);
+}
+
 /* ── Socket helper ──────────────────────────────────────────────────────── */
 
 static void rebindSocket() {
@@ -77,14 +94,14 @@ static void rebindSocket() {
 
     int opt = 1;
     setsockopt(s_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
-    setsockopt(s_sock, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
 
     uint16_t port = odh::channel::channelToSimPort(s_currentChannel);
 
-    struct sockaddr_in addr{};
+    // Bind to INADDR_ANY so multicast packets addressed to the group are received.
+    struct sockaddr_in addr {};
     addr.sin_family      = AF_INET;
     addr.sin_port        = htons(port);
-    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
     if (bind(s_sock, reinterpret_cast<sockaddr *>(&addr), sizeof(addr)) < 0) {
         perror("[SIM] bind");
@@ -93,10 +110,25 @@ static void rebindSocket() {
         return;
     }
 
-    struct timeval tv{.tv_sec = 0, .tv_usec = 100000};
+    // Join the multicast group for this channel on the loopback interface.
+    struct ip_mreq mreq {};
+    mreq.imr_multiaddr.s_addr = htonl(channelMulticastIp(s_currentChannel));
+    mreq.imr_interface.s_addr = htonl(INADDR_LOOPBACK);
+    if (setsockopt(s_sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
+        perror("[SIM] IP_ADD_MEMBERSHIP");
+    }
+
+    // Ensure multicast packets are sent via the loopback interface.
+    struct in_addr iface {};
+    iface.s_addr = htonl(INADDR_LOOPBACK);
+    setsockopt(s_sock, IPPROTO_IP, IP_MULTICAST_IF, &iface, sizeof(iface));
+
+    struct timeval tv {
+        .tv_sec = 0, .tv_usec = 100000
+    };
     setsockopt(s_sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 
-    printf("[SIM] Channel %u → UDP port %u\n", s_currentChannel, port);
+    printf("[SIM] Channel %u → UDP multicast 239.0.0.%u:%u\n", s_currentChannel, s_currentChannel, port);
 }
 
 /* ── Listener thread ────────────────────────────────────────────────────── */
@@ -160,10 +192,11 @@ int esp_now_send(const uint8_t *peer_addr, const uint8_t *data, int len) {
     int copyLen = len < ESP_NOW_MAX_DATA_LEN ? len : ESP_NOW_MAX_DATA_LEN;
     memcpy(buf + 6, data, copyLen);
 
-    struct sockaddr_in dest{};
+    // Send to the multicast group for the current channel.
+    struct sockaddr_in dest {};
     dest.sin_family      = AF_INET;
     dest.sin_port        = htons(odh::channel::channelToSimPort(s_currentChannel));
-    dest.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+    dest.sin_addr.s_addr = htonl(channelMulticastIp(s_currentChannel));
 
     ssize_t sent = sendto(s_sock, buf, 6 + copyLen, 0, reinterpret_cast<sockaddr *>(&dest), sizeof(dest));
 
@@ -215,9 +248,29 @@ bool esp_now_is_peer_exist(const uint8_t *peer_addr) {
 /* ── Channel switching ──────────────────────────────────────────────────── */
 
 void sim_set_wifi_channel(uint8_t channel) {
+    if (s_currentChannel == channel)
+        return;
+
+    // If the recv thread is running, stop it before touching the socket.
+    // pthread_join guarantees the thread has exited before we rebind.
+    const bool wasRunning = s_running;
+    if (wasRunning) {
+        s_running = false;
+        if (pthread_join(s_recvThread, nullptr) != 0) {
+            perror("[SIM] pthread_join failed during channel switch");
+        }
+    }
+
     s_currentChannel = channel;
-    if (s_running) {
+
+    if (wasRunning) {
         rebindSocket();
+        if (s_sock >= 0) {
+            s_running = true;
+            pthread_create(&s_recvThread, nullptr, recvLoop, nullptr);
+        } else {
+            fprintf(stderr, "[SIM] rebindSocket failed during channel switch to %u\n", channel);
+        }
     }
 }
 
diff --git a/firmware/src/receiver/ReceiverApp.cpp b/firmware/src/receiver/ReceiverApp.cpp
index 4c3c57b..a256c39 100644
--- a/firmware/src/receiver/ReceiverApp.cpp
+++ b/firmware/src/receiver/ReceiverApp.cpp
@@ -232,8 +232,16 @@ void ReceiverApp::runChannelDiscovery() {
     // Wire up the ChannelScanner callbacks to our radio layer
     ChannelScanner scanner([this](uint8_t ch) -> bool { return _radio.setChannel(ch); }, [this](uint8_t /*ch*/) -> bool { return _radio.sendDiscoveryRequest(); }, [](uint32_t ms) { delay(ms); });
 
-    // Forward DiscoveryResponse to the scanner
+    // Forward DiscoveryResponse to the scanner.
+    // The RAII guard below clears this callback when the function returns,
+    // preventing a dangling reference to the stack-local scanner.
     _radio.onDiscoveryResponse([&scanner](uint8_t ch, int8_t rssi, uint8_t devCount) { scanner.onDiscoveryResponse(ch, rssi, devCount); });
+    struct DiscoveryResponseGuard {
+        ReceiverRadioLink &radio;
+        ~DiscoveryResponseGuard() {
+            radio.onDiscoveryResponse(nullptr);
+        }
+    } cbGuard{_radio};
 
     // Step 1: Try last known channel from NVS
     uint8_t lastCh = loadChannel();
diff --git a/firmware/src/transmitter/shell/cmd_io.cpp b/firmware/src/transmitter/shell/cmd_io.cpp
index 6df9cb3..48514c7 100644
--- a/firmware/src/transmitter/shell/cmd_io.cpp
+++ b/firmware/src/transmitter/shell/cmd_io.cpp
@@ -85,7 +85,7 @@ int txCmdTrim(Shell &shell, int argc, const char *const *argv, void *ctx) {
 
 // ── module ──────────────────────────────────────────────────────────────
 
-// cppcheck-suppress constParameterCallback
+// cppcheck-suppress constParameterPointer
 int txCmdModule(Shell &shell, int argc, const char *const *argv, void *ctx) {
     if (argc < 2) {
         shell.println("Usage: module <list>");

From 46ad75da55c7fd12d97b0f006dc443d7839d6556 Mon Sep 17 00:00:00 2001
From: Peter Buchegger <peter.buchegger7@gmail.com>
Date: Fri, 13 Mar 2026 21:15:42 +0100
Subject: [PATCH 08/11] fix: prevent RX discovery loop by adding periodic
 heartbeat requests

The receiver was stuck in a discovery loop every 3 seconds because:
1. runChannelDiscovery()'s RAII guard clears the onDiscoveryResponse
   callback to avoid dangling stack references
2. No DiscoveryResponse packets arrive during presence mode (the TX only
   replies to DiscoveryRequests, which are only sent during scanning)
3. _lastTransmitterActivityMs was never updated, so checkTransmitterLoss
   repeatedly triggered, causing unnecessary channel re-scans

Fix: the RX now sends periodic DiscoveryRequest heartbeats while in
presence mode (not bound). The TX auto-replies with DiscoveryResponse,
keeping the activity tracker alive and preventing spurious transmitter
loss detection. The heartbeat interval is kTransmitterLossTimeoutMs/2
(1.5s), ensuring the 3s loss timeout never fires unnecessarily.

Also re-register the onDiscoveryResponse callback after runChannelDiscovery()
in checkTransmitterLoss() so the callback remains active between rounds.
---
 firmware/src/receiver/ReceiverApp.cpp | 21 ++++++++++++++++++++-
 firmware/src/receiver/ReceiverApp.h   |  1 +
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/firmware/src/receiver/ReceiverApp.cpp b/firmware/src/receiver/ReceiverApp.cpp
index a256c39..5944f66 100644
--- a/firmware/src/receiver/ReceiverApp.cpp
+++ b/firmware/src/receiver/ReceiverApp.cpp
@@ -209,6 +209,16 @@ void ReceiverApp::runTelemetryLoop() {
             _radio.sendTelemetry(_battery.voltageMv(), _radio.lastRssi(), linkState, static_cast<uint8_t>(_output.modelType()), 0, nullptr, 0);
         } else {
             _radio.tickPresence(channel::kPresenceIntervalMs);
+
+            // Periodically send a DiscoveryRequest as a heartbeat so the TX
+            // replies with DiscoveryResponse, keeping our activity tracker
+            // alive and preventing spurious transmitter-loss detection.
+            const uint32_t now = millis();
+            if (_discoveryComplete && (now - _lastHeartbeatMs) >= channel::kTransmitterLossTimeoutMs / 2) {
+                _radio.sendDiscoveryRequest();
+                _lastHeartbeatMs = now;
+            }
+
             checkTransmitterLoss();
         }
 
@@ -323,13 +333,22 @@ void ReceiverApp::checkTransmitterLoss() {
 
     // If we haven't heard from any transmitter in a while, re-enter discovery
     if (_discoveryComplete && (millis() - _lastTransmitterActivityMs) > channel::kTransmitterLossTimeoutMs) {
-        Serial.println(F("[ODH-RX] Transmitter lost – re-entering discovery"));
+        Serial.println(F("[ODH-RX] Transmitter lost \xe2\x80\x93 re-entering discovery"));
         _discoveryComplete = false;
     }
 
     // If not discovery complete, periodically retry discovery
     if (!_discoveryComplete) {
         runChannelDiscovery();
+
+        // runChannelDiscovery's RAII guard clears the onDiscoveryResponse
+        // callback (to avoid dangling references to the stack-local scanner).
+        // Re-register the persistent callback so TX activity continues to
+        // be tracked between discovery rounds.
+        _radio.onDiscoveryResponse([this](uint8_t /*ch*/, int8_t /*rssi*/, uint8_t /*devCount*/) {
+            _lastTransmitterActivityMs = millis();
+            _discoveryComplete         = true;
+        });
     }
 }
 
diff --git a/firmware/src/receiver/ReceiverApp.h b/firmware/src/receiver/ReceiverApp.h
index 17140ce..bfe3d9a 100644
--- a/firmware/src/receiver/ReceiverApp.h
+++ b/firmware/src/receiver/ReceiverApp.h
@@ -97,6 +97,7 @@ class ReceiverApp {
     uint8_t _currentChannel             = 0;
     bool _discoveryComplete             = false;
     uint32_t _lastTransmitterActivityMs = 0;
+    uint32_t _lastHeartbeatMs           = 0;
 
     // Vehicle config (loaded from NVS).
     char _vehicleName[kVehicleNameMax] = {};

From 9c5e827cada371ad21c55a38b8bc2f90da81f57d Mon Sep 17 00:00:00 2001
From: Peter Buchegger <peter.buchegger7@gmail.com>
Date: Fri, 13 Mar 2026 21:29:29 +0100
Subject: [PATCH 09/11] fix: clean up DiscoveryRequest callback in
 TransmitterApp

---
 firmware/lib/odh-shell/library.json         | 14 ++++++++------
 firmware/src/transmitter/TransmitterApp.cpp |  2 +-
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/firmware/lib/odh-shell/library.json b/firmware/lib/odh-shell/library.json
index db6bcc7..5489929 100644
--- a/firmware/lib/odh-shell/library.json
+++ b/firmware/lib/odh-shell/library.json
@@ -1,8 +1,10 @@
 {
-    "name": "odh-shell",
-    "version": "1.0.0",
-    "description": "OpenDriveHub interactive shell (command registration, line editing, helpers)",
-    "dependencies": [
-        {"name": "odh-protocol"}
-    ]
+  "name": "odh-shell",
+  "version": "1.0.0",
+  "description": "OpenDriveHub interactive shell (command registration, line editing, helpers)",
+  "dependencies": [
+    {
+      "name": "odh-protocol"
+    }
+  ]
 }
diff --git a/firmware/src/transmitter/TransmitterApp.cpp b/firmware/src/transmitter/TransmitterApp.cpp
index 08c3c95..d02ab8c 100644
--- a/firmware/src/transmitter/TransmitterApp.cpp
+++ b/firmware/src/transmitter/TransmitterApp.cpp
@@ -293,7 +293,7 @@ void TransmitterApp::runChannelAcquisition() {
 
 void TransmitterApp::setupActiveTransmitter() {
     // Register DiscoveryRequest callback – auto-reply is handled by radio layer
-    _radio.onDiscoveryRequest([](const uint8_t * /*mac*/, DeviceRole /*role*/) { Serial.println(F("[ODH] Answered DiscoveryRequest")); });
+    _radio.onDiscoveryRequest([](const uint8_t * /*mac*/, DeviceRole /*role*/) {});
 
     // Register DiscoveryResponse callback for ongoing awareness
     _radio.onDiscoveryResponse([](uint8_t /*ch*/, int8_t /*rssi*/, uint8_t /*devCount*/) {});

From 1ddbdb8da279ab91f591dd211055d88e7fc6677d Mon Sep 17 00:00:00 2001
From: Peter Buchegger <peter.buchegger7@gmail.com>
Date: Fri, 13 Mar 2026 21:39:23 +0100
Subject: [PATCH 10/11] fix: generate unique MAC address for multiple
 simulation instances

---
 firmware/sim/src/sim_arduino.cpp | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/firmware/sim/src/sim_arduino.cpp b/firmware/sim/src/sim_arduino.cpp
index 00ce06d..65de2d3 100644
--- a/firmware/sim/src/sim_arduino.cpp
+++ b/firmware/sim/src/sim_arduino.cpp
@@ -166,12 +166,29 @@ int analogRead(uint8_t) {
 
 /* ── MAC address ────────────────────────────────────────────────────────── */
 
+/// Generate a per-process unique MAC address so that multiple simulation
+/// instances of the same role (e.g. two sim_tx) are distinguishable.
+/// The last two bytes are derived from the process ID.
 void esp_read_mac(uint8_t *mac, esp_mac_type_t) {
+    static uint8_t fakeMac[6] = {};
+    static bool initialised   = false;
+    if (!initialised) {
+        uint16_t pid = static_cast<uint16_t>(getpid());
 #ifdef SIM_TX
-    static const uint8_t fakeMac[6] = {0xAA, 0xBB, 0xCC, 0xDD, 0x01, 0x01};
+        fakeMac[0] = 0xAA;
+        fakeMac[1] = 0xBB;
+        fakeMac[2] = 0xCC;
+        fakeMac[3] = 0xDD;
 #else
-    static const uint8_t fakeMac[6] = {0xAA, 0xBB, 0xCC, 0xDD, 0x02, 0x01};
+        fakeMac[0] = 0xAA;
+        fakeMac[1] = 0xBB;
+        fakeMac[2] = 0xCC;
+        fakeMac[3] = 0xDE;
 #endif
+        fakeMac[4]  = static_cast<uint8_t>(pid >> 8);
+        fakeMac[5]  = static_cast<uint8_t>(pid & 0xFF);
+        initialised = true;
+    }
     memcpy(mac, fakeMac, 6);
 }
 

From 78207cf46c2b88119c63ce1df5d7106d5efdfa2b Mon Sep 17 00:00:00 2001
From: Peter Buchegger <peter.buchegger7@gmail.com>
Date: Sat, 14 Mar 2026 10:47:57 +0100
Subject: [PATCH 11/11] feat: implement channel activation and transmitter
 detection logic

---
 firmware/lib/odh-channel/ChannelScanner.cpp   |  8 +++
 firmware/lib/odh-channel/ChannelScanner.h     |  3 +
 firmware/lib/odh-radio/ReceiverRadioLink.cpp  |  8 ---
 .../lib/odh-radio/TransmitterRadioLink.cpp    |  4 --
 firmware/sim/include/WiFi.h                   | 30 +++++++++
 firmware/sim/include/esp_now.h                |  4 ++
 firmware/sim/src/sim_arduino.cpp              | 29 ++++++++-
 firmware/sim/src/sim_espnow.cpp               | 48 ++++++++++++--
 firmware/src/transmitter/TransmitterApp.cpp   | 64 ++++++++-----------
 firmware/src/transmitter/TransmitterApp.h     |  1 +
 10 files changed, 141 insertions(+), 58 deletions(-)

diff --git a/firmware/lib/odh-channel/ChannelScanner.cpp b/firmware/lib/odh-channel/ChannelScanner.cpp
index 14d36cb..31da70a 100644
--- a/firmware/lib/odh-channel/ChannelScanner.cpp
+++ b/firmware/lib/odh-channel/ChannelScanner.cpp
@@ -88,6 +88,14 @@ uint8_t ChannelScanner::bestChannel(const ScanResult results[channel::kCandidate
     return channel::kCandidateChannels[0];
 }
 
+bool ChannelScanner::anyTransmitterFound(const ScanResult results[channel::kCandidateChannelCount]) {
+    for (uint8_t i = 0; i < channel::kCandidateChannelCount; ++i) {
+        if (results[i].foundTransmitter)
+            return true;
+    }
+    return false;
+}
+
 void ChannelScanner::onDiscoveryResponse(uint8_t /*channel*/, int8_t rssi, uint8_t deviceCount) {
     _responseRssi        = rssi;
     _responseDeviceCount = deviceCount;
diff --git a/firmware/lib/odh-channel/ChannelScanner.h b/firmware/lib/odh-channel/ChannelScanner.h
index 186c1dc..57ebf8b 100644
--- a/firmware/lib/odh-channel/ChannelScanner.h
+++ b/firmware/lib/odh-channel/ChannelScanner.h
@@ -63,6 +63,9 @@ class ChannelScanner {
     /// If none have a transmitter, returns the channel that appears quietest.
     static uint8_t bestChannel(const ScanResult results[channel::kCandidateChannelCount]);
 
+    /// Returns true if any candidate channel has an active transmitter.
+    static bool anyTransmitterFound(const ScanResult results[channel::kCandidateChannelCount]);
+
     /// Called by the radio layer when a DiscoveryResponse is received.
     /// Thread-safe: sets internal flag for the current scan wait.
     void onDiscoveryResponse(uint8_t channel, int8_t rssi, uint8_t deviceCount);
diff --git a/firmware/lib/odh-radio/ReceiverRadioLink.cpp b/firmware/lib/odh-radio/ReceiverRadioLink.cpp
index 8672f32..108453e 100644
--- a/firmware/lib/odh-radio/ReceiverRadioLink.cpp
+++ b/firmware/lib/odh-radio/ReceiverRadioLink.cpp
@@ -36,13 +36,11 @@ namespace odh {
 
 static volatile int8_t sPromiscRssi = 0;
 
-#ifndef NATIVE_SIM
 // cppcheck-suppress constParameterCallback
 static void promiscRxCb(void *buf, wifi_promiscuous_pkt_type_t /*type*/) {
     const auto *pkt = static_cast<const wifi_promiscuous_pkt_t *>(buf);
     sPromiscRssi    = pkt->rx_ctrl.rssi;
 }
-#endif
 
 ReceiverRadioLink *ReceiverRadioLink::sInstance = nullptr;
 
@@ -68,10 +66,8 @@ bool ReceiverRadioLink::begin(ControlCallback callback) {
     esp_now_register_recv_cb(onReceive);
     esp_now_register_send_cb(onSent);
 
-#ifndef NATIVE_SIM
     esp_wifi_set_promiscuous(true);
     esp_wifi_set_promiscuous_rx_cb(promiscRxCb);
-#endif
 
     _ready = true;
     return true;
@@ -81,11 +77,7 @@ bool ReceiverRadioLink::begin(ControlCallback callback) {
 
 bool ReceiverRadioLink::setChannel(uint8_t channel) {
     _wifiChannel = channel;
-#ifdef NATIVE_SIM
-    sim_set_wifi_channel(channel);
-#else
     esp_wifi_set_channel(channel, WIFI_SECOND_CHAN_NONE);
-#endif
     return true;
 }
 
diff --git a/firmware/lib/odh-radio/TransmitterRadioLink.cpp b/firmware/lib/odh-radio/TransmitterRadioLink.cpp
index 4adea84..98dff1d 100644
--- a/firmware/lib/odh-radio/TransmitterRadioLink.cpp
+++ b/firmware/lib/odh-radio/TransmitterRadioLink.cpp
@@ -65,11 +65,7 @@ bool TransmitterRadioLink::begin(TelemetryCallback callback) {
 
 bool TransmitterRadioLink::setChannel(uint8_t channel) {
     _wifiChannel = channel;
-#ifdef NATIVE_SIM
-    sim_set_wifi_channel(channel);
-#else
     esp_wifi_set_channel(channel, WIFI_SECOND_CHAN_NONE);
-#endif
     return true;
 }
 
diff --git a/firmware/sim/include/WiFi.h b/firmware/sim/include/WiFi.h
index a7b8536..f1ddd10 100644
--- a/firmware/sim/include/WiFi.h
+++ b/firmware/sim/include/WiFi.h
@@ -31,6 +31,8 @@
 
 #include <cstdint>
 
+/* ── esp_wifi types (matching ESP-IDF) ──────────────────────────────────── */
+
 typedef enum {
     WIFI_STA,
     WIFI_AP,
@@ -38,6 +40,34 @@ typedef enum {
     WIFI_OFF,
 } wifi_mode_t;
 
+typedef enum {
+    WIFI_SECOND_CHAN_NONE = 0,
+} wifi_second_chan_t;
+
+typedef struct {
+    int8_t rssi;
+} wifi_pkt_rx_ctrl_t;
+
+typedef struct {
+    wifi_pkt_rx_ctrl_t rx_ctrl;
+    uint8_t payload[0];
+} wifi_promiscuous_pkt_t;
+
+typedef enum {
+    WIFI_PKT_MGMT = 0,
+    WIFI_PKT_CTRL,
+    WIFI_PKT_DATA,
+    WIFI_PKT_MISC,
+} wifi_promiscuous_pkt_type_t;
+
+typedef void (*wifi_promiscuous_cb_t)(void *buf, wifi_promiscuous_pkt_type_t type);
+
+/* ── esp_wifi API shim ──────────────────────────────────────────────────── */
+
+void esp_wifi_set_channel(uint8_t channel, wifi_second_chan_t secondary);
+void esp_wifi_set_promiscuous(bool enable);
+void esp_wifi_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb);
+
 class IPAddress {
     uint32_t _addr;
 
diff --git a/firmware/sim/include/esp_now.h b/firmware/sim/include/esp_now.h
index a8863ca..edd3e81 100644
--- a/firmware/sim/include/esp_now.h
+++ b/firmware/sim/include/esp_now.h
@@ -70,4 +70,8 @@ void sim_set_wifi_channel(uint8_t channel);
 /// Get the current simulated WiFi channel.
 uint8_t sim_get_wifi_channel();
 
+/// Set the simulated RSSI (dBm) for a specific WiFi channel.
+/// Use this to influence which channel the scanner prefers.
+void sim_set_channel_rssi(uint8_t channel, int8_t rssi);
+
 #endif /* SIM_ESP_NOW_H */
diff --git a/firmware/sim/src/sim_arduino.cpp b/firmware/sim/src/sim_arduino.cpp
index 65de2d3..d31e660 100644
--- a/firmware/sim/src/sim_arduino.cpp
+++ b/firmware/sim/src/sim_arduino.cpp
@@ -23,11 +23,14 @@
  * sim_arduino.cpp – Arduino API implementation for Linux simulation.
  */
 
+#include <esp_now.h>
+
 #include "Arduino.h"
 
 #include <chrono>
 #include <cstdio>
 #include <cstdlib>
+#include <cstring>
 #include <thread>
 #include <unistd.h>
 
@@ -245,12 +248,36 @@ static void stdinReaderThread(int fd) {
     }
 }
 
-int main(int, char **) {
+/// Parse command-line arguments:
+///   --rssi <ch>:<dBm>[,<ch>:<dBm>]   Set simulated RSSI per channel
+static void parseArgs(int argc, char **argv) {
+    for (int i = 1; i < argc; ++i) {
+        if (std::strcmp(argv[i], "--rssi") == 0 && i + 1 < argc) {
+            ++i;
+            // Parse "ch:rssi" pairs, e.g. "6:-30" or "1:-45,6:-30,11:-70"
+            char *arg = argv[i];
+            while (arg && *arg) {
+                int ch = 0, rssi = 0;
+                if (std::sscanf(arg, "%d:%d", &ch, &rssi) == 2) {
+                    sim_set_channel_rssi(static_cast<uint8_t>(ch), static_cast<int8_t>(rssi));
+                    printf("[SIM] Channel %d RSSI set to %d dBm\n", ch, rssi);
+                }
+                // Advance to next comma-separated pair
+                char *comma = std::strchr(arg, ',');
+                arg         = comma ? comma + 1 : nullptr;
+            }
+        }
+    }
+}
+
+int main(int argc, char **argv) {
     /* Disable buffering on both stdout and stdin so the interactive shell
      * prompt, character echo and input are immediate. */
     setvbuf(stdout, nullptr, _IONBF, 0);
     setvbuf(stdin, nullptr, _IONBF, 0);
 
+    parseArgs(argc, argv);
+
     int inputFd = STDIN_FILENO;
 #ifdef HAS_TERMIOS
     inputFd = openTerminalInput();
diff --git a/firmware/sim/src/sim_espnow.cpp b/firmware/sim/src/sim_espnow.cpp
index d7cc6e4..3f0f815 100644
--- a/firmware/sim/src/sim_espnow.cpp
+++ b/firmware/sim/src/sim_espnow.cpp
@@ -39,6 +39,7 @@
 
 #include "Arduino.h"
 #include "Channel.h"
+#include "WiFi.h"
 #include "esp_now.h"
 
 #include <arpa/inet.h>
@@ -69,6 +70,13 @@ static std::mutex s_peerMutex;
 static uint8_t s_localMac[6]    = {};
 static uint8_t s_currentChannel = 1;
 
+/// Per-channel simulated RSSI values (indexed by channel number).
+/// Default is -50 dBm for all channels.
+static int8_t s_channelRssi[16] = {-50, -50, -50, -50, -50, -50, -50, -50, -50, -50, -50, -50, -50, -50, -50, -50};
+
+static wifi_promiscuous_cb_t s_promiscCb = nullptr;
+static bool s_promiscEnabled             = false;
+
 /* ── Multicast helper ───────────────────────────────────────────────────── */
 
 /// Returns the multicast group IPv4 address for the given channel in host
@@ -98,7 +106,7 @@ static void rebindSocket() {
     uint16_t port = odh::channel::channelToSimPort(s_currentChannel);
 
     // Bind to INADDR_ANY so multicast packets addressed to the group are received.
-    struct sockaddr_in addr {};
+    struct sockaddr_in addr{};
     addr.sin_family      = AF_INET;
     addr.sin_port        = htons(port);
     addr.sin_addr.s_addr = htonl(INADDR_ANY);
@@ -111,7 +119,7 @@ static void rebindSocket() {
     }
 
     // Join the multicast group for this channel on the loopback interface.
-    struct ip_mreq mreq {};
+    struct ip_mreq mreq{};
     mreq.imr_multiaddr.s_addr = htonl(channelMulticastIp(s_currentChannel));
     mreq.imr_interface.s_addr = htonl(INADDR_LOOPBACK);
     if (setsockopt(s_sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
@@ -119,13 +127,11 @@ static void rebindSocket() {
     }
 
     // Ensure multicast packets are sent via the loopback interface.
-    struct in_addr iface {};
+    struct in_addr iface{};
     iface.s_addr = htonl(INADDR_LOOPBACK);
     setsockopt(s_sock, IPPROTO_IP, IP_MULTICAST_IF, &iface, sizeof(iface));
 
-    struct timeval tv {
-        .tv_sec = 0, .tv_usec = 100000
-    };
+    struct timeval tv{.tv_sec = 0, .tv_usec = 100000};
     setsockopt(s_sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
 
     printf("[SIM] Channel %u → UDP multicast 239.0.0.%u:%u\n", s_currentChannel, s_currentChannel, port);
@@ -140,6 +146,14 @@ static void *recvLoop(void *) {
         if (n > 6 && s_recvCb) {
             if (memcmp(buf, s_localMac, 6) == 0)
                 continue;
+            // Fire the promiscuous callback before the ESP-NOW callback,
+            // exactly mirroring real ESP32 behaviour.  This lets the
+            // radio layer read RSSI via the normal promiscRxCb path.
+            if (s_promiscEnabled && s_promiscCb) {
+                wifi_promiscuous_pkt_t pkt{};
+                pkt.rx_ctrl.rssi = s_channelRssi[s_currentChannel];
+                s_promiscCb(&pkt, WIFI_PKT_DATA);
+            }
             s_recvCb(buf, buf + 6, static_cast<int>(n - 6));
         }
     }
@@ -193,7 +207,7 @@ int esp_now_send(const uint8_t *peer_addr, const uint8_t *data, int len) {
     memcpy(buf + 6, data, copyLen);
 
     // Send to the multicast group for the current channel.
-    struct sockaddr_in dest {};
+    struct sockaddr_in dest{};
     dest.sin_family      = AF_INET;
     dest.sin_port        = htons(odh::channel::channelToSimPort(s_currentChannel));
     dest.sin_addr.s_addr = htonl(channelMulticastIp(s_currentChannel));
@@ -277,3 +291,23 @@ void sim_set_wifi_channel(uint8_t channel) {
 uint8_t sim_get_wifi_channel() {
     return s_currentChannel;
 }
+
+void sim_set_channel_rssi(uint8_t channel, int8_t rssi) {
+    if (channel < 16) {
+        s_channelRssi[channel] = rssi;
+    }
+}
+
+/* ── esp_wifi API shim ───────────────────────────────────────────────────── */
+
+void esp_wifi_set_channel(uint8_t channel, wifi_second_chan_t /*secondary*/) {
+    sim_set_wifi_channel(channel);
+}
+
+void esp_wifi_set_promiscuous(bool enable) {
+    s_promiscEnabled = enable;
+}
+
+void esp_wifi_set_promiscuous_rx_cb(wifi_promiscuous_cb_t cb) {
+    s_promiscCb = cb;
+}
diff --git a/firmware/src/transmitter/TransmitterApp.cpp b/firmware/src/transmitter/TransmitterApp.cpp
index d02ab8c..543cc87 100644
--- a/firmware/src/transmitter/TransmitterApp.cpp
+++ b/firmware/src/transmitter/TransmitterApp.cpp
@@ -221,6 +221,14 @@ void TransmitterApp::saveChannel(uint8_t ch) {
 
 /* ── Channel acquisition ─────────────────────────────────────────────────── */
 
+void TransmitterApp::activateChannel(uint8_t ch) {
+    _currentChannel = ch;
+    _radio.setChannel(ch);
+    saveChannel(ch);
+    _channelActive = true;
+    setupActiveTransmitter();
+}
+
 void TransmitterApp::runChannelAcquisition() {
     // Wire up the ChannelScanner callbacks
     ChannelScanner scanner([this](uint8_t ch) -> bool { return _radio.setChannel(ch); }, [this](uint8_t /*ch*/) -> bool { return _radio.sendDiscoveryRequest(); }, [](uint32_t ms) { delay(ms); });
@@ -228,67 +236,47 @@ void TransmitterApp::runChannelAcquisition() {
     // Forward DiscoveryResponse to the scanner
     _radio.onDiscoveryResponse([&scanner](uint8_t ch, int8_t rssi, uint8_t devCount) { scanner.onDiscoveryResponse(ch, rssi, devCount); });
 
-    // Step 1: Try last known good channel from NVS
     uint8_t lastCh = loadChannel();
-    ScanResult results[channel::kCandidateChannelCount];
 
+    // Step 1: Quick-check the last known channel from NVS
     if (channel::isValidChannel(lastCh)) {
         Serial.printf("[ODH] Trying last known channel %u...\n", lastCh);
-        ScanResult result = scanner.scanChannel(lastCh);
-        if (result.foundTransmitter) {
-            _currentChannel = lastCh;
-            _radio.setChannel(lastCh);
-            _channelActive = true;
+        if (scanner.scanChannel(lastCh).foundTransmitter) {
             Serial.printf("[ODH] Joined existing transmitter on channel %u\n", lastCh);
-            setupActiveTransmitter();
+            activateChannel(lastCh);
             return;
         }
     }
 
     // Step 2: Scan all candidate channels
     Serial.println(F("[ODH] Scanning channels 1, 6, 11..."));
+    ScanResult results[channel::kCandidateChannelCount];
     scanner.scanAllChannels(results);
 
-    // Check if any channel has an active transmitter
-    for (uint8_t i = 0; i < channel::kCandidateChannelCount; ++i) {
-        if (results[i].foundTransmitter) {
-            _currentChannel = results[i].channel;
-            _radio.setChannel(results[i].channel);
-            saveChannel(results[i].channel);
-            _channelActive = true;
-            Serial.printf("[ODH] Joined existing transmitter on channel %u\n", results[i].channel);
-            setupActiveTransmitter();
-            return;
-        }
+    uint8_t bestCh = ChannelScanner::bestChannel(results);
+
+    if (ChannelScanner::anyTransmitterFound(results)) {
+        Serial.printf("[ODH] Joined existing transmitter on channel %u\n", bestCh);
+        activateChannel(bestCh);
+        return;
     }
 
-    // Step 3: No other transmitter found – found a channel
-    uint8_t bestCh = ChannelScanner::bestChannel(results);
+    // Step 3: No other transmitter found – prefer stored channel, then
+    // back off before claiming.
+    if (channel::isValidChannel(lastCh))
+        bestCh = lastCh;
 
-    // Random backoff before claiming
     uint32_t backoff = channel::kFoundingBackoffMinMs + (std::rand() % (channel::kFoundingBackoffMaxMs - channel::kFoundingBackoffMinMs));
     Serial.printf("[ODH] No TX found – backing off %lu ms before claiming channel %u\n", static_cast<unsigned long>(backoff), bestCh);
     delay(backoff);
 
     // One final discovery pass after backoff
-    ScanResult finalCheck = scanner.scanChannel(bestCh);
-    if (finalCheck.foundTransmitter) {
-        _currentChannel = bestCh;
-        _radio.setChannel(bestCh);
-        saveChannel(bestCh);
-        _channelActive = true;
+    if (scanner.scanChannel(bestCh).foundTransmitter) {
         Serial.printf("[ODH] Late discovery – joined transmitter on channel %u\n", bestCh);
-        setupActiveTransmitter();
-        return;
+    } else {
+        Serial.printf("[ODH] Founded channel %u\n", bestCh);
     }
-
-    // Claim the channel
-    _currentChannel = bestCh;
-    _radio.setChannel(bestCh);
-    saveChannel(bestCh);
-    _channelActive = true;
-    Serial.printf("[ODH] Founded channel %u\n", bestCh);
-    setupActiveTransmitter();
+    activateChannel(bestCh);
 }
 
 void TransmitterApp::setupActiveTransmitter() {
diff --git a/firmware/src/transmitter/TransmitterApp.h b/firmware/src/transmitter/TransmitterApp.h
index 8d52d0e..748aeae 100644
--- a/firmware/src/transmitter/TransmitterApp.h
+++ b/firmware/src/transmitter/TransmitterApp.h
@@ -129,6 +129,7 @@ class TransmitterApp {
 
     // Channel discovery
     void runChannelAcquisition();
+    void activateChannel(uint8_t ch);
     void setupActiveTransmitter();
     void saveChannel(uint8_t channel);
     uint8_t loadChannel();