Merge branch 'develop' into serialHal

and fix it on esp32 again
2026-10-09 13:32:18 +10:00 · 2026-05-04 22:10:48 -05:00 · 2026-05-04 13:09:22 -05:00 · 2026-04-30 16:03:35 -05:00 · 2026-04-30 15:45:36 -05:00 · 2026-04-30 15:21:42 -05:00
150 changed files with 2005 additions and 2548 deletions
@@ -8,7 +8,7 @@
  "features": {
    "ghcr.io/devcontainers/features/python:1": {
      "installTools": true,
-      "version": "3.13"
+      "version": "3.14"
    }
  },
  "customizations": {
@@ -1,10 +1,10 @@
 {
+    // See http://go.microsoft.com/fwlink/?LinkId=827846
+    // for the documentation about the extensions.json format
    "recommendations": [
-        "Jason2866.esp-decoder",
-        "pioarduino.pioarduino-ide"
+        "platformio.platformio-ide"
    ],
    "unwantedRecommendations": [
-        "ms-vscode.cpptools-extension-pack",
-        "platformio.platformio-ide"
+        "ms-vscode.cpptools-extension-pack"
    ]
 }
@@ -38,4 +38,4 @@ cp bin/device-install.* $OUTDIR/
 cp bin/device-update.* $OUTDIR/

 echo "Copying manifest"
-cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json
+cp $BUILDDIR/$basename.mt.json $OUTDIR/$basename.mt.json || true
@@ -293,12 +293,9 @@ if ("HAS_TFT", 1) in env.get("CPPDEFINES", []):
 board_arch = infer_architecture(env.BoardConfig())
 should_skip_manifest = board_arch is None

-# Most platforms can generate the manifest as part of the default 'buildprog' target.
-# Typically this passes success/failure properly.
-mtjson_deps = ["buildprog"]
-if platform.name == "espressif32":
-    # On ESP32, we need to explicitly depend upon the binary to prevent fake-success upon failure.
-    mtjson_deps = ["$BUILD_DIR/${PROGNAME}.bin"]
+# For host/native envs, avoid depending on 'buildprog' (some targets don't define it)
+mtjson_deps = [] if should_skip_manifest else ["buildprog"]
+if not should_skip_manifest and platform.name == "espressif32":
    # Build littlefs image as part of mtjson target
    # Equivalent to `pio run -t buildfs`
    target_lfs = env.DataToBin(
@@ -312,8 +309,7 @@ if should_skip_manifest:

    env.AddCustomTarget(
        name="mtjson",
-        # For host/native envs, avoid depending on 'buildprog' (some targets don't define it)
-        dependencies=[],
+        dependencies=mtjson_deps,
        actions=[skip_manifest],
        title="Meshtastic Manifest (skipped)",
        description="mtjson generation is skipped for native environments",
@@ -7,7 +7,7 @@
    "extra_flags": [
      "-D CDEBYTE_EORA_S3",
      "-D ARDUINO_USB_CDC_ON_BOOT=1",
-      "-D ARDUINO_USB_MODE=1",
+      "-D ARDUINO_USB_MODE=0",
      "-D ARDUINO_RUNNING_CORE=1",
      "-D ARDUINO_EVENT_RUNNING_CORE=1",
      "-D BOARD_HAS_PSRAM"
@@ -6,7 +6,7 @@
    "core": "esp32",
    "extra_flags": [
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1",
      "-DBOARD_HAS_PSRAM"
@@ -1,32 +0,0 @@
-{
-  "build": {
-    "core": "esp32",
-    "extra_flags": ["-DBOARD_HAS_PSRAM"],
-    "f_cpu": "360000000L",
-    "f_flash": "80000000L",
-    "f_psram": "200000000L",
-    "flash_mode": "qio",
-    "hwids": [["0x1A86", "0x7522"]],
-    "mcu": "esp32p4",
-    "chip_variant": "esp32p4",
-    "variant": "esp32p4"
-  },
-  "arduino": {
-    "partitions": "default_16MB.csv"
-  },
-  "connectivity": ["bluetooth", "openthread"],
-  "debug": {
-    "openocd_target": "esp32p4.cfg"
-  },
-  "frameworks": ["arduino", "espidf"],
-  "name": "CrowPanel Advanced ESP32-P4 HMI AI Display",
-  "upload": {
-    "flash_size": "16MB",
-    "maximum_ram_size": 512000,
-    "maximum_size": 16777216,
-    "require_upload_port": true,
-    "speed": 1500000
-  },
-  "url": "https://www.elecrow.com/crowpanel-advanced-5inch-esp32-p4-hmi-ai-display-800x480-ips-touch-screen-with-wifi-6.html",
-  "vendor": "Elecrow"
-}
@@ -8,7 +8,7 @@
    "extra_flags": [
      "-DBOARD_HAS_PSRAM",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1"
    ],
@@ -9,7 +9,7 @@
    "extra_flags": [
      "-DBOARD_HAS_PSRAM",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1"
    ],
@@ -9,7 +9,7 @@
    "extra_flags": [
      "-DBOARD_HAS_PSRAM",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1"
    ],
@@ -9,7 +9,7 @@
    "extra_flags": [
      "-DBOARD_HAS_PSRAM",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1"
    ],
@@ -8,7 +8,7 @@
    "extra_flags": [
      "-DHELTEC_WIRELESS_TRACKER",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1"
    ],
@@ -7,7 +7,7 @@
    "core": "esp32",
    "extra_flags": [
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1"
    ],
@@ -8,7 +8,7 @@
    "extra_flags": [
      "-DBOARD_HAS_PSRAM",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=0"
    ],
@@ -9,7 +9,7 @@
      "-DBOARD_HAS_PSRAM",
      "-DLILYGO_TBEAM_1W",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1"
    ],
@@ -8,7 +8,7 @@
    "extra_flags": [
      "-DBOARD_HAS_PSRAM",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1"
    ],
@@ -8,7 +8,7 @@
      "-DBOARD_HAS_PSRAM",
      "-DLILYGO_TBEAM_S3_CORE",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1"
    ],
@@ -7,7 +7,7 @@
    "extra_flags": [
      "-DLILYGO_T3S3_V1",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1",
      "-DBOARD_HAS_PSRAM"
@@ -10,7 +10,7 @@
      "-DBOARD_HAS_PSRAM",
      "-DUNPHONE_SPIN=9",
      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
+      "-DARDUINO_USB_MODE=0",
      "-DARDUINO_RUNNING_CORE=1",
      "-DARDUINO_EVENT_RUNNING_CORE=1"
    ],
@@ -1,7 +0,0 @@
-# Name,   Type, SubType, Offset,  Size, Flags
-nvs,      data, nvs,     0x9000,  0x5000,
-otadata,  data, ota,     0xe000,  0x2000,
-app0,     app,  ota_0,   0x10000, 0x640000,
-app1,     app,  ota_1,   0x650000,0x640000,
-spiffs,   data, spiffs,  0xc90000,0x360000,
-coredump, data, coredump,0xFF0000,0x10000,
@@ -1,7 +0,0 @@
-# Name,   Type, SubType, Offset,  Size, Flags
-nvs,      data, nvs,     0x9000,  0x5000,
-otadata,  data, ota,     0xe000,  0x2000,
-app0,     app,  ota_0,   0x10000, 0x330000,
-app1,     app,  ota_1,   0x340000,0x330000,
-spiffs,   data, spiffs,  0x670000,0x180000,
-coredump, data, coredump,0x7F0000,0x10000,
@@ -70,6 +70,17 @@ def esp32_create_combined_bin(source, target, env):

 env.AddPostAction("$BUILD_DIR/${PROGNAME}.bin", esp32_create_combined_bin)

-# Enable Newlib Nano formatting to save space
-# ...but allow printf float support (compromise)
-env.Append(LINKFLAGS=["--specs=nano.specs", "-u", "_printf_float"])
+esp32_kind = env.GetProjectOption("custom_esp32_kind")
+if esp32_kind == "esp32":
+    # Free up some IRAM by removing auxiliary SPI flash chip drivers.
+    # Wrapped stub symbols are defined in src/platform/esp32/iram-quirk.c.
+    env.Append(
+        LINKFLAGS=[
+            "-Wl,--wrap=esp_flash_chip_gd",
+            "-Wl,--wrap=esp_flash_chip_issi",
+            "-Wl,--wrap=esp_flash_chip_winbond",
+        ]
+    )
+else:
+    # For newer ESP32 targets, using newlib nano works better.
+    env.Append(LINKFLAGS=["--specs=nano.specs", "-u", "_printf_float"])
@@ -1,23 +0,0 @@
-#!/usr/bin/env python3
-# trunk-ignore-all(ruff/F821)
-# trunk-ignore-all(flake8/F821): For SConstruct imports
-
-# force linker response file instead of command line arguments
-
-Import("env")
-
-
-def wrap_with_tempfile(command_key):
-    command = env.get(command_key)
-    if not command or not isinstance(command, str):
-        return
-    if "TEMPFILE(" in command:
-        return
-    env.Replace(**{command_key: "${TEMPFILE('%s')}" % command})
-
-
-# Force SCons to spill long commands into response files on this target.
-env.Replace(MAXLINELENGTH=8192)
-
-for key in ("LINKCOM", "CXXLINKCOM", "SHLINKCOM", "SHCXXLINKCOM"):
-    wrap_with_tempfile(key)
@@ -2,7 +2,7 @@
 ; https://docs.platformio.org/page/projectconf.html

 [platformio]
-default_envs = heltec-v3
+default_envs = tbeam

 extra_configs =
 	variants/*/*.ini
@@ -170,8 +170,8 @@ lib_deps =
 	https://github.com/EmotiBit/EmotiBit_MLX90632/archive/refs/tags/v1.0.8.zip
 	# renovate: datasource=github-tags depName=Adafruit MLX90614 packageName=adafruit/Adafruit_MLX90614
 	https://github.com/adafruit/Adafruit-MLX90614-Library/archive/refs/tags/2.1.6.zip
-	# renovate: datasource=github-tags depName=INA3221_RT packageName=RobTillaart/INA3221_RT
-	https://github.com/RobTillaart/INA3221_RT/archive/refs/tags/0.4.2.zip
+	# renovate: datasource=git-refs depName=INA3221 packageName=https://github.com/sgtwilko/INA3221 gitBranch=FixOverflow
+	https://github.com/sgtwilko/INA3221/archive/bb03d7e9bfcc74fc798838a54f4f99738f29fc6a.zip
 	# renovate: datasource=github-tags depName=QMC5883L Compass packageName=mprograms/QMC5883LCompass
 	https://github.com/mprograms/QMC5883LCompass/archive/refs/tags/v1.2.3.zip
 	# renovate: datasource=github-tags depName=DFRobot_RTU packageName=dfrobot/DFRobot_RTU
@@ -14,28 +14,4 @@ const uint8_t FROMNUM_UUID_16[16u] = {0x53, 0x44, 0xe3, 0x47, 0x75, 0xaa, 0x70,
 const uint8_t LEGACY_LOGRADIO_UUID_16[16u] = {0xe2, 0xf2, 0x1e, 0xbe, 0xc5, 0x15, 0xcf, 0xaa,
                                              0x6b, 0x43, 0xfa, 0x78, 0x38, 0xd2, 0x6f, 0x6c};
 const uint8_t LOGRADIO_UUID_16[16u] = {0x47, 0x95, 0xDF, 0x8C, 0xDE, 0xE9, 0x44, 0x99,
-                                       0x23, 0x44, 0xE6, 0x06, 0x49, 0x6E, 0x3D, 0x5A};
-
-void BluetoothApi::setup() {}
-void BluetoothApi::shutdown() {}
-void BluetoothApi::deinit() {}
-void BluetoothApi::clearBonds() {}
-bool BluetoothApi::isActive()
-{
-    return false;
-}
-bool BluetoothApi::isConnected()
-{
-    return false;
-}
-void BluetoothApi::sendLog(const uint8_t *logMessage, size_t length)
-{
-    (void)logMessage;
-    (void)length;
-}
-
-void updateBatteryLevel(uint8_t level) __attribute__((weak));
-void updateBatteryLevel(uint8_t level)
-{
-    (void)level;
-}
+                                       0x23, 0x44, 0xE6, 0x06, 0x49, 0x6E, 0x3D, 0x5A};
@@ -24,14 +24,9 @@ void updateBatteryLevel(uint8_t level);
 class BluetoothApi
 {
  public:
-    virtual ~BluetoothApi() = default;
-
    virtual void setup();
    virtual void shutdown();
-    virtual void deinit();
    virtual void clearBonds();
-    virtual bool isActive();
    virtual bool isConnected();
    virtual int getRssi() = 0;
-    virtual void sendLog(const uint8_t *logMessage, size_t length);
 };
@@ -151,8 +151,9 @@ extern "C" void logLegacy(const char *level, const char *fmt, ...);
 #include <RAK13800_W5100S.h>
 #endif // HAS_ETHERNET

-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET

 #if HAS_WIFI
@@ -277,7 +277,7 @@ void fsInit()
 */
 void setupSDCard()
 {
-#if defined(HAS_SDCARD) && !defined(SDCARD_USE_SOFT_SPI) && !defined(HAS_SD_MMC)
+#if defined(HAS_SDCARD) && !defined(SDCARD_USE_SOFT_SPI)
    concurrency::LockGuard g(spiLock);
    SDHandler.begin(SPI_SCK, SPI_MISO, SPI_MOSI);
    if (!SD.begin(SDCARD_CS, SDHandler, SD_SPI_FREQUENCY)) {
@@ -24,13 +24,6 @@
 #include "meshUtils.h"
 #include "power/PowerHAL.h"
 #include "sleep.h"
-#ifdef ARCH_ESP32
-// #include <driver/adc.h>
-#include <esp_adc/adc_cali.h>
-#include <esp_adc/adc_cali_scheme.h>
-#include <esp_adc/adc_oneshot.h>
-#include <esp_err.h>
-#endif

 #if defined(ARCH_PORTDUINO)
 #include "api/WiFiServerAPI.h"
@@ -70,8 +63,9 @@
 #include <WiFi.h>
 #endif

-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET

 #endif
@@ -83,86 +77,21 @@
 #if defined(BATTERY_PIN) && defined(ARCH_ESP32)

 #ifndef BAT_MEASURE_ADC_UNIT // ADC1 is default
-static const adc_channel_t adc_channel = ADC_CHANNEL;
+static const adc1_channel_t adc_channel = ADC_CHANNEL;
 static const adc_unit_t unit = ADC_UNIT_1;
-#else  // ADC2
-static const adc_channel_t adc_channel = ADC_CHANNEL;
+#else // ADC2
+static const adc2_channel_t adc_channel = ADC_CHANNEL;
 static const adc_unit_t unit = ADC_UNIT_2;
+RTC_NOINIT_ATTR uint64_t RTC_reg_b;
+
 #endif // BAT_MEASURE_ADC_UNIT

-static adc_oneshot_unit_handle_t adc_handle = nullptr;
-static adc_cali_handle_t adc_cali_handle = nullptr;
-static bool adc_calibrated = false;
+esp_adc_cal_characteristics_t *adc_characs = (esp_adc_cal_characteristics_t *)calloc(1, sizeof(esp_adc_cal_characteristics_t));
 #ifndef ADC_ATTENUATION
 static const adc_atten_t atten = ADC_ATTEN_DB_12;
 #else
 static const adc_atten_t atten = ADC_ATTENUATION;
 #endif
-#ifdef ADC_BITWIDTH
-static const adc_bitwidth_t adc_width = ADC_BITWIDTH;
-#else
-static const adc_bitwidth_t adc_width = ADC_BITWIDTH_DEFAULT;
-#endif
-
-static int adcBitWidthToBits(adc_bitwidth_t width)
-{
-    switch (width) {
-    case ADC_BITWIDTH_9:
-        return 9;
-    case ADC_BITWIDTH_10:
-        return 10;
-    case ADC_BITWIDTH_11:
-        return 11;
-    case ADC_BITWIDTH_12:
-        return 12;
-#ifdef ADC_BITWIDTH_13
-    case ADC_BITWIDTH_13:
-        return 13;
-#endif
-    default:
-        return 12;
-    }
-}
-
-static bool initAdcCalibration()
-{
-#if ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
-    adc_cali_curve_fitting_config_t cali_config = {
-        .unit_id = unit,
-        .atten = atten,
-        .bitwidth = adc_width,
-    };
-    esp_err_t ret = adc_cali_create_scheme_curve_fitting(&cali_config, &adc_cali_handle);
-    if (ret == ESP_OK) {
-        LOG_INFO("ADC calibration: curve fitting enabled");
-        return true;
-    }
-    if (ret != ESP_ERR_NOT_SUPPORTED) {
-        LOG_WARN("ADC calibration: curve fitting failed: %s", esp_err_to_name(ret));
-    }
-#endif
-
-#if ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED
-    adc_cali_line_fitting_config_t cali_config = {
-        .unit_id = unit,
-        .atten = atten,
-        .bitwidth = adc_width,
-        .default_vref = DEFAULT_VREF,
-    };
-    esp_err_t ret = adc_cali_create_scheme_line_fitting(&cali_config, &adc_cali_handle);
-    if (ret == ESP_OK) {
-        LOG_INFO("ADC calibration: line fitting enabled");
-        return true;
-    }
-    if (ret != ESP_ERR_NOT_SUPPORTED) {
-        LOG_WARN("ADC calibration: line fitting failed: %s", esp_err_to_name(ret));
-    }
-#endif
-
-    LOG_INFO("ADC calibration not supported; using approximate scaling");
-    return false;
-}
-
 #endif // BATTERY_PIN && ARCH_ESP32

 #ifdef EXT_PWR_DETECT
@@ -438,20 +367,8 @@ class AnalogBatteryLevel : public HasBatteryLevel
            scaled *= operativeAdcMultiplier;
 #elif defined(ARCH_ESP32) // ADC block for espressif platforms
            raw = espAdcRead();
-            int voltage_mv = 0;
-            if (adc_calibrated && adc_cali_handle) {
-                if (adc_cali_raw_to_voltage(adc_cali_handle, raw, &voltage_mv) != ESP_OK) {
-                    LOG_WARN("ADC calibration read failed; using raw value");
-                    voltage_mv = 0;
-                }
-            }
-            if (voltage_mv == 0) {
-                // Fallback approximate conversion without calibration
-                const int bits = adcBitWidthToBits(adc_width);
-                const float max_code = powf(2.0f, bits) - 1.0f;
-                voltage_mv = (int)((raw / max_code) * DEFAULT_VREF);
-            }
-            scaled = voltage_mv * operativeAdcMultiplier;
+            scaled = esp_adc_cal_raw_to_voltage(raw, adc_characs);
+            scaled *= operativeAdcMultiplier;
 #else                     // block for all other platforms
 #ifdef ARCH_NRF52
            concurrency::LockGuard saadcGuard(concurrency::nrf52SaadcLock);
@@ -493,22 +410,51 @@ class AnalogBatteryLevel : public HasBatteryLevel
        uint32_t raw = 0;
        uint8_t raw_c = 0; // raw reading counter

-        if (!adc_handle) {
-            LOG_ERROR("ADC oneshot handle not initialized");
-            return 0;
-        }
-
+#ifndef BAT_MEASURE_ADC_UNIT // ADC1
        for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
-            int val = 0;
-            esp_err_t err = adc_oneshot_read(adc_handle, adc_channel, &val);
-            if (err == ESP_OK) {
-                raw += val;
+            int val_ = adc1_get_raw(adc_channel);
+            if (val_ >= 0) { // save only valid readings
+                raw += val_;
                raw_c++;
+            }
+            // delayMicroseconds(100);
+        }
+#else                            // ADC2
+#ifdef CONFIG_IDF_TARGET_ESP32S3 // ESP32S3
+        // ADC2 wifi bug workaround not required, breaks compile
+        // On ESP32S3, ADC2 can take turns with Wifi (?)
+
+        int32_t adc_buf;
+        esp_err_t read_result;
+
+        // Multiple samples
+        for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
+            adc_buf = 0;
+            read_result = -1;
+
+            read_result = adc2_get_raw(adc_channel, ADC_WIDTH_BIT_12, &adc_buf);
+            if (read_result == ESP_OK) {
+                raw += adc_buf;
+                raw_c++; // Count valid samples
            } else {
-                LOG_DEBUG("ADC read failed: %s", esp_err_to_name(err));
+                LOG_DEBUG("An attempt to sample ADC2 failed");
            }
        }

+#else  // Other ESP32
+        int32_t adc_buf = 0;
+        for (int i = 0; i < BATTERY_SENSE_SAMPLES; i++) {
+            // ADC2 wifi bug workaround, see
+            // https://github.com/espressif/arduino-esp32/issues/102
+            WRITE_PERI_REG(SENS_SAR_READ_CTRL2_REG, RTC_reg_b);
+            SET_PERI_REG_MASK(SENS_SAR_READ_CTRL2_REG, SENS_SAR2_DATA_INV);
+            adc2_get_raw(adc_channel, ADC_WIDTH_BIT_12, &adc_buf);
+            raw += adc_buf;
+            raw_c++;
+        }
+#endif // BAT_MEASURE_ADC_UNIT
+
+#endif // End BAT_MEASURE_ADC_UNIT
        return (raw / (raw_c < 1 ? 1 : raw_c));
    }
 #endif
@@ -720,31 +666,42 @@ bool Power::analogInit()
 #ifdef ARCH_STM32WL
    analogReadResolution(BATTERY_SENSE_RESOLUTION_BITS);
 #elif defined(ARCH_ESP32) // ESP32 needs special analog stuff
-    adc_oneshot_unit_init_cfg_t init_config = {
-        .unit_id = unit,
-    };

-    if (!adc_handle) {
-        esp_err_t err = adc_oneshot_new_unit(&init_config, &adc_handle);
-        if (err != ESP_OK) {
-            LOG_ERROR("ADC oneshot init failed: %s", esp_err_to_name(err));
-            return false;
-        }
+#ifndef ADC_WIDTH // max resolution by default
+    static const adc_bits_width_t width = ADC_WIDTH_BIT_12;
+#else
+    static const adc_bits_width_t width = ADC_WIDTH;
+#endif
+#ifndef BAT_MEASURE_ADC_UNIT // ADC1
+    adc1_config_width(width);
+    adc1_config_channel_atten(adc_channel, atten);
+#else                        // ADC2
+    adc2_config_channel_atten(adc_channel, atten);
+#ifndef CONFIG_IDF_TARGET_ESP32S3
+    // ADC2 wifi bug workaround
+    // Not required with ESP32S3, breaks compile
+    RTC_reg_b = READ_PERI_REG(SENS_SAR_READ_CTRL2_REG);
+#endif
+#endif
+    // calibrate ADC
+    esp_adc_cal_value_t val_type = esp_adc_cal_characterize(unit, atten, width, DEFAULT_VREF, adc_characs);
+    // show ADC characterization base
+    if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP) {
+        LOG_INFO("ADC config based on Two Point values stored in eFuse");
+    } else if (val_type == ESP_ADC_CAL_VAL_EFUSE_VREF) {
+        LOG_INFO("ADC config based on reference voltage stored in eFuse");
    }
-
-    adc_oneshot_chan_cfg_t chan_cfg = {
-        .atten = atten,
-        .bitwidth = adc_width,
-    };
-
-    esp_err_t err = adc_oneshot_config_channel(adc_handle, adc_channel, &chan_cfg);
-    if (err != ESP_OK) {
-        LOG_ERROR("ADC channel config failed: %s", esp_err_to_name(err));
-        return false;
+#ifdef CONFIG_IDF_TARGET_ESP32S3
+    // ESP32S3
+    else if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP_FIT) {
+        LOG_INFO("ADC config based on Two Point values and fitting curve "
+                 "coefficients stored in eFuse");
    }
-
-    adc_calibrated = initAdcCalibration();
-#endif                    // ARCH_ESP32
+#endif
+    else {
+        LOG_INFO("ADC config based on default reference voltage");
+    }
+#endif // ARCH_ESP32

    // NRF52 ADC init moved to powerHAL_init in nrf52 platform

@@ -7,6 +7,7 @@
 #include "memGet.h"
 #include "mesh/generated/meshtastic/mesh.pb.h"
 #include <assert.h>
+#include <atomic>
 #include <cstring>
 #include <memory>
 #include <stdexcept>
@@ -20,6 +21,22 @@
 #if HAS_NETWORKING
 extern meshtastic::Syslog syslog;
 #endif
+
+namespace
+{
+std::atomic<bool> serialHalLogSuppressed{false};
+}
+
+void RedirectablePrint::setSerialHalLogSuppressed(bool suppressed)
+{
+    serialHalLogSuppressed.store(suppressed);
+}
+
+bool RedirectablePrint::isSerialHalLogSuppressed()
+{
+    return serialHalLogSuppressed.load();
+}
+
 void RedirectablePrint::rpInit()
 {
 #ifdef HAS_FREE_RTOS
@@ -222,7 +239,7 @@ void RedirectablePrint::log_to_ble(const char *logLevel, const char *format, va_
    if (config.security.debug_log_api_enabled && !pauseBluetoothLogging) {
        bool isBleConnected = false;
 #ifdef ARCH_ESP32
-        isBleConnected = bluetoothApi && bluetoothApi->isActive() && bluetoothApi->isConnected();
+        isBleConnected = nimbleBluetooth && nimbleBluetooth->isActive() && nimbleBluetooth->isConnected();
 #elif defined(ARCH_NRF52)
        isBleConnected = nrf52Bluetooth != nullptr && nrf52Bluetooth->isConnected();
 #endif
@@ -238,7 +255,7 @@ void RedirectablePrint::log_to_ble(const char *logLevel, const char *format, va_
            auto buffer = std::unique_ptr<uint8_t[]>(new uint8_t[meshtastic_LogRecord_size]);
            size_t size = pb_encode_to_bytes(buffer.get(), meshtastic_LogRecord_size, meshtastic_LogRecord_fields, &logRecord);
 #ifdef ARCH_ESP32
-            bluetoothApi->sendLog(buffer.get(), size);
+            nimbleBluetooth->sendLog(buffer.get(), size);
 #elif defined(ARCH_NRF52)
            nrf52Bluetooth->sendLog(buffer.get(), size);
 #endif
@@ -277,6 +294,10 @@ meshtastic_LogRecord_Level RedirectablePrint::getLogLevel(const char *logLevel)
 void RedirectablePrint::log(const char *logLevel, const char *format, ...)
 {

+    if (isSerialHalLogSuppressed()) {
+        return;
+    }
+
    // append \n to format
    size_t len = strlen(format);
    auto newFormat = std::unique_ptr<char[]>(new char[len + 2]);
@@ -24,6 +24,11 @@ class RedirectablePrint : public Print
  public:
    explicit RedirectablePrint(Print *_dest) : dest(_dest) {}

+    /// Suppress all log output while a SerialHal transaction is in progress.
+    // Unclear if this is necessary, but it seems to help with response speeds.
+    static void setSerialHalLogSuppressed(bool suppressed);
+    static bool isSerialHalLogSuppressed();
+
    /**
     * Set a new destination
     */
@@ -1,762 +0,0 @@
-#include "configuration.h"
-
-#if defined(CONFIG_IDF_TARGET_ESP32P4) && defined(CONFIG_ESP_HOSTED_ENABLED) && !MESHTASTIC_EXCLUDE_BLUETOOTH
-#include "BluetoothStatus.h"
-#include "PowerFSM.h"
-#include "bluetooth/HostedBluetooth.h"
-#include "concurrency/OSThread.h"
-#include "esp32-hal-hosted.h"
-#include "esp_err.h"
-#include "esp_event.h"
-#include "esp_hosted.h"
-#include "esp_hosted_event.h"
-#include "main.h"
-#include "mesh/PhoneAPI.h"
-#include "mesh/mesh-pb-constants.h"
-#include <BLEAdvertising.h>
-#include <BLEDevice.h>
-#include <BLESecurity.h>
-#include <BLEServer.h>
-#include <BLEUtils.h>
-#include <array>
-#include <atomic>
-#include <climits>
-#include <cstring>
-#include <driver/gpio.h>
-#include <mutex>
-
-#include "host/ble_gap.h"
-#include "host/ble_store.h"
-
-namespace
-{
-/*
- * Maintainer note: HostedBluetooth intentionally stays close to NimbleBluetooth
- * but is not a strict drop-in equivalent.
- *
- * Intentional differences from NimbleBluetooth include:
- * - ESP-Hosted transport lifecycle handling (event callbacks + CP reset GPIO control).
- * - Data-length update behavior (Hosted currently requests ble_gap_set_data_len on connect).
- * - No Battery Service exposure here.
- *
- * If you modify common BLE flow in one class, review and likely mirror in both:
- * - PhoneAPI queueing/synchronization between BLE callbacks and runOnce().
- * - Security/pairing config and passkey UX/status updates.
- * - Mesh GATT characteristics, permissions, and advertising setup.
- * - Connection parameter tuning and reconnect/disconnect cleanup paths.
- */
-constexpr uint16_t kPreferredBleMtu = 517;
-constexpr uint16_t kPreferredBleTxOctets = 251;
-constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
-constexpr size_t kBluetoothToPhoneQueueSize = 3;
-constexpr size_t kBluetoothFromPhoneQueueSize = 3;
-
-BLECharacteristic *fromNumCharacteristic = nullptr;
-BLECharacteristic *logRadioCharacteristic = nullptr;
-BLEServer *bleServer = nullptr;
-
-static bool passkeyShowing = false;
-std::atomic<uint16_t> hostedConnHandle{BLE_HS_CONN_HANDLE_NONE};
-
-void clearPairingDisplay()
-{
-    if (!passkeyShowing) {
-        return;
-    }
-
-    passkeyShowing = false;
-#if HAS_SCREEN
-    if (screen) {
-        screen->endAlert();
-    }
-#endif
-}
-
-class HostedBluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
-{
-  public:
-    HostedBluetoothPhoneAPI() : concurrency::OSThread("HostedBluetooth") { api_type = TYPE_BLE; }
-
-    std::mutex fromPhoneMutex;
-    std::atomic<size_t> fromPhoneQueueSize{0};
-    std::array<BLEValue, kBluetoothFromPhoneQueueSize> fromPhoneQueue{};
-
-    std::mutex toPhoneMutex;
-    std::atomic<size_t> toPhoneQueueSize{0};
-    std::array<std::array<uint8_t, meshtastic_FromRadio_size>, kBluetoothToPhoneQueueSize> toPhoneQueue{};
-    std::array<size_t, kBluetoothToPhoneQueueSize> toPhoneQueueByteSizes{};
-    std::atomic<bool> onReadCallbackIsWaitingForData{false};
-
-  protected:
-    int32_t runOnce() override
-    {
-        while (fromPhoneQueueSize > 0 || onReadCallbackIsWaitingForData) {
-            runOnceHandleFromPhoneQueue();
-            runOnceHandleToPhoneQueue();
-        }
-        return INT32_MAX;
-    }
-
-    void onNowHasData(uint32_t fromRadioNum) override
-    {
-        PhoneAPI::onNowHasData(fromRadioNum);
-
-        if (!fromNumCharacteristic || !bleServer || bleServer->getConnectedCount() == 0) {
-            return;
-        }
-
-        uint8_t val[4];
-        put_le32(val, fromRadioNum);
-        fromNumCharacteristic->setValue(val, sizeof(val));
-        fromNumCharacteristic->notify();
-    }
-
-    bool checkIsConnected() override { return bleServer && bleServer->getConnectedCount() > 0; }
-
-  private:
-    void runOnceHandleToPhoneQueue()
-    {
-        if (!onReadCallbackIsWaitingForData) {
-            return;
-        }
-
-        uint8_t fromRadioBytes[meshtastic_FromRadio_size] = {0};
-        size_t numBytes = getFromRadio(fromRadioBytes);
-
-        if (numBytes > 0 && toPhoneQueueSize < kBluetoothToPhoneQueueSize) {
-            std::lock_guard<std::mutex> guard(toPhoneMutex);
-            const size_t storeAtIndex = toPhoneQueueSize.load();
-            memcpy(toPhoneQueue[storeAtIndex].data(), fromRadioBytes, numBytes);
-            toPhoneQueueByteSizes[storeAtIndex] = numBytes;
-            toPhoneQueueSize++;
-        }
-
-        onReadCallbackIsWaitingForData = false;
-    }
-
-    void runOnceHandleFromPhoneQueue()
-    {
-        if (fromPhoneQueueSize == 0) {
-            return;
-        }
-
-        BLEValue val;
-        {
-            std::lock_guard<std::mutex> guard(fromPhoneMutex);
-            val = fromPhoneQueue[0];
-            for (size_t i = 1; i < fromPhoneQueueSize; ++i) {
-                fromPhoneQueue[i - 1] = fromPhoneQueue[i];
-            }
-            fromPhoneQueueSize--;
-        }
-
-        handleToRadio(val.getData(), val.getLength());
-    }
-};
-
-static HostedBluetoothPhoneAPI *bluetoothPhoneAPI = nullptr;
-uint8_t lastToRadio[MAX_TO_FROM_RADIO_SIZE] = {0};
-
-class HostedBluetoothToRadioCallback : public BLECharacteristicCallbacks
-{
-  public:
-    void onWrite(BLECharacteristic *pCharacteristic) override
-    {
-        if (!bluetoothPhoneAPI) {
-            return;
-        }
-
-        BLEValue val;
-        val.setValue(pCharacteristic->getData(), pCharacteristic->getLength());
-
-        if (memcmp(lastToRadio, val.getData(), val.getLength()) == 0) {
-            return;
-        }
-
-        if (bluetoothPhoneAPI->fromPhoneQueueSize >= kBluetoothFromPhoneQueueSize) {
-            LOG_WARN("Hosted BLE onWrite drop: queue full (%u bytes)", val.getLength());
-            return;
-        }
-
-        memcpy(lastToRadio, val.getData(), val.getLength());
-
-        {
-            std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->fromPhoneMutex);
-            bluetoothPhoneAPI->fromPhoneQueue.at(bluetoothPhoneAPI->fromPhoneQueueSize) = val;
-            bluetoothPhoneAPI->fromPhoneQueueSize++;
-        }
-
-        bluetoothPhoneAPI->setIntervalFromNow(0);
-        concurrency::mainDelay.interrupt();
-    }
-};
-
-class HostedBluetoothFromRadioCallback : public BLECharacteristicCallbacks
-{
-  public:
-    void onRead(BLECharacteristic *pCharacteristic) override
-    {
-        if (!bluetoothPhoneAPI) {
-            return;
-        }
-
-        if (bluetoothPhoneAPI->toPhoneQueueSize == 0) {
-            bluetoothPhoneAPI->onReadCallbackIsWaitingForData = true;
-            bluetoothPhoneAPI->setIntervalFromNow(0);
-            concurrency::mainDelay.interrupt();
-
-            int tries = 0;
-            while (bluetoothPhoneAPI->onReadCallbackIsWaitingForData && tries < 4000) {
-                delay(tries < 20 ? 1 : 5);
-                tries++;
-                if (tries == 4000) {
-                    LOG_WARN("BLE onRead: timeout waiting for data after %d tries, giving up and returning 0-size response",
-                             tries);
-                }
-            }
-        }
-
-        uint8_t fromRadioBytes[meshtastic_FromRadio_size] = {0};
-        size_t numBytes = 0;
-
-        {
-            std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->toPhoneMutex);
-            size_t pending = bluetoothPhoneAPI->toPhoneQueueSize.load();
-            if (pending > 0) {
-                numBytes = bluetoothPhoneAPI->toPhoneQueueByteSizes[0];
-                memcpy(fromRadioBytes, bluetoothPhoneAPI->toPhoneQueue[0].data(), numBytes);
-
-                for (size_t i = 1; i < pending; ++i) {
-                    memcpy(bluetoothPhoneAPI->toPhoneQueue[i - 1].data(), bluetoothPhoneAPI->toPhoneQueue[i].data(),
-                           bluetoothPhoneAPI->toPhoneQueueByteSizes[i]);
-                    bluetoothPhoneAPI->toPhoneQueueByteSizes[i - 1] = bluetoothPhoneAPI->toPhoneQueueByteSizes[i];
-                }
-
-                bluetoothPhoneAPI->toPhoneQueueSize--;
-            }
-        }
-
-        pCharacteristic->setValue(fromRadioBytes, numBytes);
-    }
-};
-
-class HostedBluetoothServerCallback : public BLEServerCallbacks
-{
-  public:
-    explicit HostedBluetoothServerCallback(HostedBluetooth *owner) : owner(owner) {}
-
-  private:
-    HostedBluetooth *owner;
-
-    void onConnect(BLEServer *pServer, struct ble_gap_conn_desc *desc) override
-    {
-        BLEAddress peerAddr(desc->peer_id_addr);
-        LOG_INFO("Hosted BLE incoming connection %s", peerAddr.toString().c_str());
-        owner->setConnected(true);
-        hostedConnHandle = desc->conn_handle;
-
-        const int dataLenResult = ble_gap_set_data_len(desc->conn_handle, kPreferredBleTxOctets, kPreferredBleTxTimeUs);
-        if (dataLenResult != 0) {
-            LOG_WARN("Hosted BLE failed to raise data length rc=%d", dataLenResult);
-        }
-
-        pServer->updateConnParams(desc->conn_handle, 6, 12, 0, 200);
-    }
-
-    void onDisconnect(BLEServer *pServer, struct ble_gap_conn_desc *desc) override
-    {
-        (void)pServer;
-        (void)desc;
-        LOG_INFO("Hosted BLE disconnected");
-        owner->setConnected(false);
-        meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED);
-        bluetoothStatus->updateStatus(&newStatus);
-        clearPairingDisplay();
-        hostedConnHandle = BLE_HS_CONN_HANDLE_NONE;
-        memset(lastToRadio, 0, sizeof(lastToRadio));
-
-        if (bluetoothPhoneAPI) {
-            bluetoothPhoneAPI->close();
-            {
-                std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->fromPhoneMutex);
-                bluetoothPhoneAPI->fromPhoneQueueSize = 0;
-            }
-            {
-                std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->toPhoneMutex);
-                bluetoothPhoneAPI->toPhoneQueueSize = 0;
-            }
-            bluetoothPhoneAPI->onReadCallbackIsWaitingForData = false;
-        }
-
-        owner->startAdvertising();
-    }
-};
-
-class HostedBluetoothSecurityCallback : public BLESecurityCallbacks
-{
-  public:
-    void onPassKeyNotify(uint32_t passkey) override
-    {
-        LOG_INFO("*** Enter passkey %06u on the peer side ***", passkey);
-        powerFSM.trigger(EVENT_BLUETOOTH_PAIR);
-
-        meshtastic::BluetoothStatus newStatus(std::to_string(passkey));
-        bluetoothStatus->updateStatus(&newStatus);
-
-#if HAS_SCREEN
-        if (screen) {
-            screen->startAlert([passkey](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
-                char btPIN[16] = "888888";
-                snprintf(btPIN, sizeof(btPIN), "%06u", passkey);
-                int x_offset = display->width() / 2;
-                int y_offset = display->height() <= 80 ? 0 : 12;
-                display->setTextAlignment(TEXT_ALIGN_CENTER);
-                display->setFont(FONT_MEDIUM);
-                display->drawString(x_offset + x, y_offset + y, "Bluetooth");
-#if !defined(M5STACK_UNITC6L)
-                display->setFont(FONT_SMALL);
-                y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_MEDIUM - 4 : y_offset + FONT_HEIGHT_MEDIUM + 5;
-                display->drawString(x_offset + x, y_offset + y, "Enter this code");
-#endif
-                display->setFont(FONT_LARGE);
-                char pin[8];
-                snprintf(pin, sizeof(pin), "%.3s %.3s", btPIN, btPIN + 3);
-                y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_SMALL - 5 : y_offset + FONT_HEIGHT_SMALL + 5;
-                display->drawString(x_offset + x, y_offset + y, pin);
-
-                display->setFont(FONT_SMALL);
-                char deviceName[64];
-                snprintf(deviceName, sizeof(deviceName), "Name: %s", getDeviceName());
-                y_offset = display->height() == 64 ? y_offset + FONT_HEIGHT_LARGE - 6 : y_offset + FONT_HEIGHT_LARGE + 5;
-                display->drawString(x_offset + x, y_offset + y, deviceName);
-            });
-        }
-#endif
-
-        passkeyShowing = true;
-    }
-
-    void onAuthenticationComplete(ble_gap_conn_desc *desc) override
-    {
-        (void)desc;
-        LOG_INFO("Hosted BLE authentication complete");
-
-        meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::CONNECTED);
-        bluetoothStatus->updateStatus(&newStatus);
-        clearPairingDisplay();
-    }
-};
-
-HostedBluetoothToRadioCallback *toRadioCallbacks = nullptr;
-HostedBluetoothFromRadioCallback *fromRadioCallbacks = nullptr;
-HostedBluetoothSecurityCallback *securityCallbacks = nullptr;
-
-gpio_num_t getSlaveResetGpio()
-{
-#if defined(CONFIG_ESP_HOSTED_GPIO_SLAVE_RESET_SLAVE)
-    return static_cast<gpio_num_t>(CONFIG_ESP_HOSTED_GPIO_SLAVE_RESET_SLAVE);
-#elif defined(CONFIG_ESP_HOSTED_SDIO_GPIO_RESET_SLAVE)
-    return static_cast<gpio_num_t>(CONFIG_ESP_HOSTED_SDIO_GPIO_RESET_SLAVE);
-#else
-    return GPIO_NUM_NC;
-#endif
-}
-
-void setSlaveResetLine(bool assertReset)
-{
-    const gpio_num_t gpioNum = getSlaveResetGpio();
-    if (gpioNum == GPIO_NUM_NC || gpioNum < 0) {
-        return;
-    }
-
-    if (gpio_reset_pin(gpioNum) != ESP_OK) {
-        return;
-    }
-    if (gpio_set_direction(gpioNum, GPIO_MODE_OUTPUT) != ESP_OK) {
-        return;
-    }
-
-    const int activeLevel =
-#if defined(CONFIG_ESP_HOSTED_SDIO_RESET_ACTIVE_HIGH)
-        1;
-#else
-        0;
-#endif
-    const int inactiveLevel = activeLevel ? 0 : 1;
-
-    gpio_set_level(gpioNum, assertReset ? activeLevel : inactiveLevel);
-    LOG_DEBUG("[HostedBluetooth] setSlaveResetLine: GPIO[%d] -> %d (assertReset=%d, activeLevel=%d)", gpioNum,
-              assertReset ? activeLevel : inactiveLevel, assertReset, activeLevel);
-}
-
-void hostedEventHandler(void *arg, esp_event_base_t eventBase, int32_t eventId, void *eventData)
-{
-    (void)eventData;
-
-    auto *self = static_cast<HostedBluetooth *>(arg);
-    if (!self || eventBase != ESP_HOSTED_EVENT) {
-        return;
-    }
-
-    switch (eventId) {
-    case ESP_HOSTED_EVENT_TRANSPORT_UP:
-        LOG_INFO("ESP-Hosted transport is up");
-        self->setConnected(true);
-        break;
-    case ESP_HOSTED_EVENT_TRANSPORT_DOWN:
-        LOG_WARN("ESP-Hosted transport is down");
-        [[fallthrough]];
-    case ESP_HOSTED_EVENT_TRANSPORT_FAILURE:
-        if (eventId == ESP_HOSTED_EVENT_TRANSPORT_FAILURE) {
-            LOG_ERROR("ESP-Hosted transport failure");
-        }
-        self->setConnected(false);
-        break;
-    case ESP_HOSTED_EVENT_CP_INIT:
-    case ESP_HOSTED_EVENT_CP_HEARTBEAT:
-    default:
-        break;
-    }
-}
-} // namespace
-
-HostedBluetooth::HostedBluetooth() {}
-
-HostedBluetooth::~HostedBluetooth()
-{
-    deinit();
-}
-
-bool HostedBluetooth::registerCallbacks()
-{
-    if (callbacksRegistered) {
-        return true;
-    }
-
-    // Defensive cleanup in case setup() is called again after an incomplete/early previous init.
-    // esp_event_handler_unregister can safely fail if the handler wasn't present.
-    esp_event_handler_unregister(ESP_HOSTED_EVENT, ESP_EVENT_ANY_ID, hostedEventHandler);
-
-    esp_err_t err = esp_event_handler_register(ESP_HOSTED_EVENT, ESP_EVENT_ANY_ID, hostedEventHandler, this);
-    if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) {
-        LOG_ERROR("Failed to register hosted event handler: %s", esp_err_to_name(err));
-        return false;
-    }
-    if (err == ESP_ERR_INVALID_STATE) {
-        LOG_WARN("Hosted event handler already registered, continuing");
-    }
-
-    callbacksRegistered = true;
-    return true;
-}
-
-void HostedBluetooth::unregisterCallbacks()
-{
-    if (!callbacksRegistered) {
-        return;
-    }
-
-    esp_event_handler_unregister(ESP_HOSTED_EVENT, ESP_EVENT_ANY_ID, hostedEventHandler);
-
-    callbacksRegistered = false;
-}
-
-void HostedBluetooth::setup()
-{
-    if (active) {
-        return;
-    }
-
-    // Ensure co-processor is released from reset before bringing transport back up.
-    setSlaveResetLine(false);
-    LOG_DEBUG("[HostedBluetooth] setup(): Released co-processor from reset");
-
-    if (!registerCallbacks()) {
-        return;
-    }
-
-    active = setupGatt();
-    firstRssiLogged.store(false);
-    if (active) {
-        LOG_INFO("ESP-Hosted Bluetooth ready");
-    } else {
-        LOG_ERROR("Hosted BLE setup failed in hosted mode");
-        deinit();
-    }
-}
-
-void HostedBluetooth::shutdown()
-{
-    deinit();
-}
-
-void HostedBluetooth::deinit()
-{
-    if (!active && !callbacksRegistered) {
-        return;
-    }
-
-    shutdownGatt();
-    if (BLEDevice::getInitialized()) {
-        BLEDevice::deinit(false);
-    } else {
-        hostedDeinitBLE();
-    }
-
-    // Hold co-processor in reset when hosted transport is disabled to reduce idle draw.
-    setSlaveResetLine(true);
-
-    unregisterCallbacks();
-
-    connected.store(false);
-    active = false;
-    rssi.store(0);
-    firstRssiLogged.store(false);
-}
-
-void HostedBluetooth::clearBonds()
-{
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_PEER_SEC, nullptr);
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_CCCD, nullptr);
-}
-
-bool HostedBluetooth::isActive()
-{
-    return active;
-}
-
-bool HostedBluetooth::isConnected()
-{
-    if (!connected.load()) {
-        return false;
-    }
-    return bleServer && bleServer->getConnectedCount() > 0;
-}
-
-int HostedBluetooth::getRssi()
-{
-    if (!bleServer || !isConnected()) {
-        return 0;
-    }
-
-    uint16_t connHandle = hostedConnHandle.load();
-    if (connHandle == BLE_HS_CONN_HANDLE_NONE) {
-        const auto peers = bleServer->getPeerDevices(true);
-        if (!peers.empty()) {
-            connHandle = peers.begin()->first;
-            hostedConnHandle = connHandle;
-        }
-    }
-    if (connHandle == BLE_HS_CONN_HANDLE_NONE) {
-        return 0;
-    }
-
-    int8_t currentRssi = 0;
-    const int rc = ble_gap_conn_rssi(connHandle, &currentRssi);
-    if (rc == 0) {
-        setRssi(currentRssi);
-        return currentRssi;
-    }
-
-    return rssi.load();
-}
-
-void HostedBluetooth::sendLog(const uint8_t *logMessage, size_t length)
-{
-    if (!logRadioCharacteristic || !isConnected() || length > 512) {
-        return;
-    }
-
-    logRadioCharacteristic->setValue(logMessage, length);
-    logRadioCharacteristic->notify();
-}
-
-void HostedBluetooth::setConnected(bool value)
-{
-    connected.store(value);
-}
-
-void HostedBluetooth::setRssi(int value)
-{
-    rssi.store(value);
-    maybeLogFirstRssi(value);
-}
-
-void HostedBluetooth::maybeLogFirstRssi(int value)
-{
-    bool expected = false;
-    if (firstRssiLogged.compare_exchange_strong(expected, true)) {
-        LOG_INFO("ESP-Hosted first RSSI update: %d dBm", value);
-    }
-}
-
-bool HostedBluetooth::setupGatt()
-{
-    memset(lastToRadio, 0, sizeof(lastToRadio));
-    hostedConnHandle = BLE_HS_CONN_HANDLE_NONE;
-
-    if (!BLEDevice::init(getDeviceName())) {
-        LOG_ERROR("Hosted BLE init failed");
-        return false;
-    }
-#ifdef ESP_PWR_LVL_P9
-    BLEDevice::setPower(ESP_PWR_LVL_P9);
-#endif
-
-    BLESecurity *security = new BLESecurity();
-    security->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
-    security->setRespEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
-    if (config.bluetooth.mode != meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
-        security->setCapability(ESP_IO_CAP_OUT);
-        if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN) {
-            LOG_INFO("Hosted BLE using random passkey");
-            security->setPassKey(false);
-        } else {
-            LOG_INFO("Hosted BLE using fixed passkey");
-            security->setPassKey(true, config.bluetooth.fixed_pin);
-        }
-        // Enable authorization requirements:
-        // - bonding: true (for persistent storage of the keys)
-        // - MITM: true (enables Man-In-The-Middle protection for password prompts)
-        // - secure connection: true (enables secure connection for encryption)
-        security->setAuthenticationMode(true, true, true);
-    } else {
-        security->setCapability(ESP_IO_CAP_NONE);
-        security->setAuthenticationMode(true, false, false);
-    }
-
-    if (!securityCallbacks) {
-        securityCallbacks = new HostedBluetoothSecurityCallback();
-    }
-    BLEDevice::setSecurityCallbacks(securityCallbacks);
-
-    const int mtuResult = BLEDevice::setMTU(kPreferredBleMtu);
-    if (mtuResult == 0) {
-        LOG_INFO("Hosted BLE MTU request set to %u", kPreferredBleMtu);
-    } else {
-        LOG_WARN("Hosted BLE unable to request MTU %u, rc=%d", kPreferredBleMtu, mtuResult);
-    }
-
-    bleServer = BLEDevice::createServer();
-    if (!bleServer) {
-        LOG_ERROR("Hosted BLE createServer failed");
-        return false;
-    }
-
-    const int nameRc = ble_svc_gap_device_name_set(BLEDevice::getDeviceName().c_str());
-    if (nameRc != 0) {
-        LOG_WARN("Hosted BLE device_name_set rc=%d %s", nameRc, BLEUtils::returnCodeToString(nameRc));
-    }
-
-    bleServer->setCallbacks(new HostedBluetoothServerCallback(this));
-
-    BLEService *meshService = bleServer->createService(MESH_SERVICE_UUID);
-    if (!meshService) {
-        LOG_ERROR("Hosted BLE mesh service creation failed");
-        return false;
-    }
-
-    BLECharacteristic *toRadioCharacteristic = nullptr;
-    BLECharacteristic *fromRadioCharacteristic = nullptr;
-    if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
-        toRadioCharacteristic = meshService->createCharacteristic(TORADIO_UUID, BLECharacteristic::PROPERTY_WRITE);
-        fromRadioCharacteristic = meshService->createCharacteristic(FROMRADIO_UUID, BLECharacteristic::PROPERTY_READ);
-        fromNumCharacteristic = meshService->createCharacteristic(FROMNUM_UUID, BLECharacteristic::PROPERTY_NOTIFY |
-                                                                                    BLECharacteristic::PROPERTY_READ);
-        logRadioCharacteristic = meshService->createCharacteristic(LOGRADIO_UUID, BLECharacteristic::PROPERTY_NOTIFY |
-                                                                                      BLECharacteristic::PROPERTY_READ);
-    } else {
-        toRadioCharacteristic = meshService->createCharacteristic(TORADIO_UUID, BLECharacteristic::PROPERTY_WRITE |
-                                                                                    BLECharacteristic::PROPERTY_WRITE_AUTHEN |
-                                                                                    BLECharacteristic::PROPERTY_WRITE_ENC);
-        fromRadioCharacteristic = meshService->createCharacteristic(FROMRADIO_UUID, BLECharacteristic::PROPERTY_READ |
-                                                                                        BLECharacteristic::PROPERTY_READ_AUTHEN |
-                                                                                        BLECharacteristic::PROPERTY_READ_ENC);
-        fromNumCharacteristic = meshService->createCharacteristic(
-            FROMNUM_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ |
-                              BLECharacteristic::PROPERTY_READ_AUTHEN | BLECharacteristic::PROPERTY_READ_ENC);
-        logRadioCharacteristic = meshService->createCharacteristic(
-            LOGRADIO_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ |
-                               BLECharacteristic::PROPERTY_READ_AUTHEN | BLECharacteristic::PROPERTY_READ_ENC);
-    }
-
-    if (!toRadioCharacteristic || !fromRadioCharacteristic || !fromNumCharacteristic || !logRadioCharacteristic) {
-        LOG_ERROR("Hosted BLE characteristic creation failed");
-        return false;
-    }
-
-    if (!bluetoothPhoneAPI) {
-        bluetoothPhoneAPI = new HostedBluetoothPhoneAPI();
-    }
-
-    if (!toRadioCallbacks) {
-        toRadioCallbacks = new HostedBluetoothToRadioCallback();
-    }
-    if (!fromRadioCallbacks) {
-        fromRadioCallbacks = new HostedBluetoothFromRadioCallback();
-    }
-
-    toRadioCharacteristic->setCallbacks(toRadioCallbacks);
-    fromRadioCharacteristic->setCallbacks(fromRadioCallbacks);
-    meshService->start();
-
-    startAdvertising();
-    return true;
-}
-
-void HostedBluetooth::shutdownGatt()
-{
-    if (bluetoothPhoneAPI) {
-        bluetoothPhoneAPI->close();
-        delete bluetoothPhoneAPI;
-        bluetoothPhoneAPI = nullptr;
-    }
-
-    delete toRadioCallbacks;
-    toRadioCallbacks = nullptr;
-
-    delete fromRadioCallbacks;
-    fromRadioCallbacks = nullptr;
-
-    delete securityCallbacks;
-    securityCallbacks = nullptr;
-
-    if (bleServer) {
-        BLEAdvertising *advertising = BLEDevice::getAdvertising();
-        if (advertising) {
-            advertising->stop();
-        }
-    }
-
-    fromNumCharacteristic = nullptr;
-    logRadioCharacteristic = nullptr;
-    bleServer = nullptr;
-    hostedConnHandle = BLE_HS_CONN_HANDLE_NONE;
-}
-
-void HostedBluetooth::startAdvertising()
-{
-    BLEAdvertising *advertising = BLEDevice::getAdvertising();
-    if (!advertising) {
-        LOG_ERROR("Hosted BLE getAdvertising failed");
-        return;
-    }
-
-    advertising->stop();
-    advertising->reset();
-    advertising->addServiceUUID(MESH_SERVICE_UUID);
-
-    BLEAdvertisementData scan;
-    scan.setName(getDeviceName());
-    advertising->setScanResponseData(scan);
-    advertising->setMinPreferred(0x06);
-    advertising->setMaxPreferred(0x12);
-
-    if (!advertising->start(0)) {
-        LOG_ERROR("Hosted BLE failed to start advertising");
-    } else {
-        LOG_INFO("Hosted BLE advertising started");
-    }
-}
-
-#endif
@@ -1,43 +0,0 @@
-#pragma once
-
-#include "BluetoothCommon.h"
-#include <atomic>
-
-/**
- * Placeholder backend for ESP32-P4 + ESP-Hosted BLE transport.
- *
- * This intentionally mirrors the NimbleBluetooth surface used by the firmware,
- * so the caller side can stay stable while we implement esp-hosted internals.
- */
-class HostedBluetooth : public BluetoothApi
-{
-  public:
-    HostedBluetooth();
-    ~HostedBluetooth() override;
-
-    void setup() override;
-    void shutdown() override;
-    void deinit() override;
-    void clearBonds() override;
-    bool isActive() override;
-    bool isConnected() override;
-    int getRssi() override;
-    void sendLog(const uint8_t *logMessage, size_t length) override;
-    void startAdvertising();
-
-    void setConnected(bool value);
-    void setRssi(int value);
-
-  private:
-    bool setupGatt();
-    void shutdownGatt();
-    void maybeLogFirstRssi(int value);
-    bool registerCallbacks();
-    void unregisterCallbacks();
-
-    bool active = false;
-    std::atomic<bool> connected{false};
-    std::atomic<int> rssi{0};
-    std::atomic<bool> firstRssiLogged{false};
-    bool callbacksRegistered = false;
-};
@@ -53,11 +53,10 @@ void InkHUD::MessageStore::saveToFlash()
        f.write(reinterpret_cast<const uint8_t *>(&m.timestamp), sizeof(m.timestamp));       // Write timestamp. 4 bytes
        f.write(reinterpret_cast<const uint8_t *>(&m.sender), sizeof(m.sender));             // Write sender NodeId. 4 Bytes
        f.write(reinterpret_cast<const uint8_t *>(&m.channelIndex), sizeof(m.channelIndex)); // Write channel index. 1 Byte
-        f.write(reinterpret_cast<const uint8_t *>(m.text.c_str()),
-                min((size_t)MAX_MESSAGE_SIZE, m.text.size())); // Write message text
-        f.write('\0');                                         // Append null term
-        LOG_DEBUG("Wrote message %u, length %u, text \"%s\"", static_cast<uint32_t>(i),
-                  min((size_t)MAX_MESSAGE_SIZE, m.text.size()), m.text.c_str());
+        f.write(reinterpret_cast<const uint8_t *>(m.text.c_str()), min(MAX_MESSAGE_SIZE, m.text.size())); // Write message text
+        f.write('\0');                                                                                    // Append null term
+        LOG_DEBUG("Wrote message %u, length %u, text \"%s\"", static_cast<uint32_t>(i), min(MAX_MESSAGE_SIZE, m.text.size()),
+                  m.text.c_str());
    }

    // Release firmware's SPI lock, because SafeFile::close needs it
@@ -13,8 +13,6 @@

 #ifdef INPUTBROKER_EXPRESSLRSFIVEWAY_TYPE

-// REVISIT esp_adc_cal.h
-// "legacy adc calibration driver is deprecated, please migrate to use esp_adc/adc_cali.h and esp_adc/adc_cali_scheme.h"
 #include <esp_adc_cal.h>
 #include <soc/adc_channel.h>

@@ -68,7 +68,7 @@ TLoraPagerKeyboard::TLoraPagerKeyboard()
    : TCA8418KeyboardBase(_TCA8418_ROWS, _TCA8418_COLS), modifierFlag(0), last_modifier_time(0), last_key(UINT8_MAX),
      next_key(UINT8_MAX), last_tap(0L), char_idx(0), tap_interval(0)
 {
-#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
    ledcAttach(KB_BL_PIN, LEDC_BACKLIGHT_FREQ, LEDC_BACKLIGHT_BIT_WIDTH);
 #else
    ledcSetup(LEDC_BACKLIGHT_CHANNEL, LEDC_BACKLIGHT_FREQ, LEDC_BACKLIGHT_BIT_WIDTH);
@@ -108,7 +108,7 @@ void TLoraPagerKeyboard::setBacklight(bool on)
    uint32_t _brightness = 0;
    if (on)
        _brightness = brightness;
-#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
    ledcWrite(KB_BL_PIN, _brightness);
 #else
    ledcWrite(LEDC_BACKLIGHT_CHANNEL, _brightness);
@@ -49,7 +49,8 @@
 #include "mesh/http/WebServer.h"
 #endif
 #if !MESHTASTIC_EXCLUDE_BLUETOOTH
-BluetoothApi *bluetoothApi = nullptr;
+#include "nimble/NimbleBluetooth.h"
+NimbleBluetooth *nimbleBluetooth = nullptr;
 #endif
 #endif

@@ -950,8 +951,12 @@ void setup()
 #endif
 #endif

-    auto rIf = initLoRa();
-
+    std::unique_ptr<RadioInterface> rIf;
+    if (!config.lora.serial_hal_only) {
+        rIf = initLoRa();
+    } else {
+        LOG_INFO("skipping LoRa radio init, for serialHal");
+    }
    lateInitVariant(); // Do board specific init (see extra_variants/README.md for documentation)

 #if !MESHTASTIC_EXCLUDE_MQTT
@@ -995,10 +1000,9 @@ void setup()

    // Start airtime logger thread.
    airTime = new AirTime();
-
-    if (!rIf)
+    if (!rIf && !config.lora.serial_hal_only)
        RECORD_CRITICALERROR(meshtastic_CriticalErrorCode_NO_RADIO);
-    else {
+    else if (rIf) {
        // Log bit rate to debug output
        LOG_DEBUG("LoRA bitrate = %f bytes / sec", (float(meshtastic_Constants_DATA_PAYLOAD_LEN) /
                                                    (float(rIf->getPacketTime(meshtastic_Constants_DATA_PAYLOAD_LEN)))) *
@@ -12,8 +12,8 @@
 #include <SPI.h>
 #include <map>
 #if defined(ARCH_ESP32) && !defined(CONFIG_IDF_TARGET_ESP32S2)
-#include "BluetoothCommon.h"
-extern BluetoothApi *bluetoothApi;
+#include "nimble/NimbleBluetooth.h"
+extern NimbleBluetooth *nimbleBluetooth;
 #endif
 #ifdef ARCH_NRF52
 #include "NRF52Bluetooth.h"
@@ -25,6 +25,7 @@

 #ifdef ARCH_PORTDUINO
 #include "platform/portduino/PortduinoGlue.h"
+#include "platform/portduino/SerialHal.h"
 #include "platform/portduino/SimRadio.h"
 #include "platform/portduino/USBHal.h"
 #endif
@@ -292,6 +293,9 @@ std::unique_ptr<RadioInterface> initLoRa()
              portduino_config.lora_spi_dev.c_str());
    if (portduino_config.lora_spi_dev == "ch341") {
        RadioLibHAL = ch341Hal;
+    } else if (portduino_config.lora_spi_dev == "serial") {
+        RadioLibHAL = new SerialHal(portduino_config.lora_serial_device, portduino_config.lora_serial_baud,
+                                    (uint32_t)portduino_config.lora_serial_timeout_ms);
    } else {
        if (RadioLibHAL != nullptr) {
            delete RadioLibHAL;
@@ -0,0 +1,385 @@
+#include "mesh/SerialHalDevice.h"
+#include "NodeDB.h"
+#include "SPILock.h"
+#include "concurrency/Periodic.h"
+#include "configuration.h"
+#include "mesh/StreamAPI.h"
+#include "mesh/generated/meshtastic/config.pb.h"
+#include <Arduino.h>
+#include <SPI.h>
+#include <cstring>
+#include <stdint.h>
+
+#if defined(ARCH_ESP32)
+#if defined(HW_SPI1_DEVICE)
+extern SPIClass SPI1;
+#endif
+#endif
+
+namespace
+{
+constexpr uint32_t SERIAL_PI_RISING = 1;
+constexpr uint32_t SERIAL_PI_FALLING = 2;
+constexpr uint32_t SERIAL_PI_INPUT = 0;
+constexpr uint32_t SERIAL_PI_OUTPUT = 1;
+constexpr size_t MAX_INTERRUPT_SLOTS = 8;
+constexpr int32_t INTERRUPT_POLL_MS = 5;
+
+struct InterruptSlot {
+    bool used = false;
+    uint32_t pin = 0;
+    uint32_t mode = 0;
+    volatile bool pending = false;
+};
+
+concurrency::Lock interruptMutex;
+InterruptSlot interruptSlots[MAX_INTERRUPT_SLOTS];
+StreamAPI *interruptStreamApi = nullptr;
+concurrency::Periodic *interruptEmitter = nullptr;
+
+int findSlotByPinLocked(uint32_t pin)
+{
+    for (size_t i = 0; i < MAX_INTERRUPT_SLOTS; ++i) {
+        if (interruptSlots[i].used && interruptSlots[i].pin == pin) {
+            return (int)i;
+        }
+    }
+    return -1;
+}
+
+int allocateSlotLocked()
+{
+    for (size_t i = 0; i < MAX_INTERRUPT_SLOTS; ++i) {
+        if (!interruptSlots[i].used) {
+            return (int)i;
+        }
+    }
+    return -1;
+}
+
+#if defined(ARCH_PORTDUINO) || defined(ARCH_RP2040)
+PinStatus toInterruptMode(uint32_t serialMode)
+{
+    if (serialMode == SERIAL_PI_RISING) {
+        return PinStatus::RISING;
+    }
+    if (serialMode == SERIAL_PI_FALLING) {
+        return PinStatus::FALLING;
+    }
+    return PinStatus::CHANGE;
+}
+#else
+int toInterruptMode(uint32_t serialMode)
+{
+    if (serialMode == SERIAL_PI_RISING) {
+        return RISING;
+    }
+    if (serialMode == SERIAL_PI_FALLING) {
+        return FALLING;
+    }
+    return CHANGE;
+}
+#endif
+
+int32_t pumpInterruptEvents();
+
+void ensureInterruptEmitter()
+{
+    if (!interruptEmitter) {
+        interruptEmitter = new concurrency::Periodic("SerialHalIrqEmitter", pumpInterruptEvents);
+    }
+}
+
+void emitInterruptEvent(uint32_t pin, StreamAPI *streamApi)
+{
+    if (streamApi == nullptr) {
+        return;
+    }
+
+    meshtastic_SerialHalResponse event = meshtastic_SerialHalResponse_init_zero;
+    event.transaction_id = 0; // asynchronous interrupt notification
+    event.result = meshtastic_SerialHalResponse_Result_OK;
+    event.value = pin; // host-side SerialHal treats value as interrupt pin
+    SerialHalDevice::emitResponse(event, streamApi);
+}
+
+void markPendingBySlot(uint8_t slot)
+{
+    if (slot < MAX_INTERRUPT_SLOTS && interruptSlots[slot].used) {
+        interruptSlots[slot].pending = true;
+    }
+}
+
+void isr0()
+{
+    markPendingBySlot(0);
+}
+void isr1()
+{
+    markPendingBySlot(1);
+}
+void isr2()
+{
+    markPendingBySlot(2);
+}
+void isr3()
+{
+    markPendingBySlot(3);
+}
+void isr4()
+{
+    markPendingBySlot(4);
+}
+void isr5()
+{
+    markPendingBySlot(5);
+}
+void isr6()
+{
+    markPendingBySlot(6);
+}
+void isr7()
+{
+    markPendingBySlot(7);
+}
+
+void (*const isrTable[MAX_INTERRUPT_SLOTS])() = {isr0, isr1, isr2, isr3, isr4, isr5, isr6, isr7};
+
+int32_t pumpInterruptEvents()
+{
+    uint32_t toEmit[MAX_INTERRUPT_SLOTS] = {0};
+    size_t emitCount = 0;
+    StreamAPI *streamApi = nullptr;
+
+    {
+        concurrency::LockGuard lock(&interruptMutex);
+        streamApi = interruptStreamApi;
+        for (size_t i = 0; i < MAX_INTERRUPT_SLOTS; ++i) {
+            if (interruptSlots[i].used && interruptSlots[i].pending) {
+                interruptSlots[i].pending = false;
+                toEmit[emitCount++] = interruptSlots[i].pin;
+            }
+        }
+    }
+
+    for (size_t i = 0; i < emitCount; ++i) {
+        emitInterruptEvent(toEmit[i], streamApi);
+    }
+
+    return INTERRUPT_POLL_MS;
+}
+} // namespace
+
+// Helper to safely set response result
+static inline void setResponseError(meshtastic_SerialHalResponse &response, meshtastic_SerialHalResponse_Result result,
+                                    const char *error = nullptr)
+{
+    response.result = result;
+    if (error != nullptr) {
+        snprintf(response.error, sizeof(response.error), "%s", error);
+    }
+}
+
+void SerialHalDevice::handleCommand(const uint8_t *buf, size_t len, StreamAPI *streamApi)
+{
+    if (buf == nullptr || streamApi == nullptr) {
+        return;
+    }
+
+    // Validate role - SerialHal commands only handled when config.lora.serial_hal_only
+    if (!config.lora.serial_hal_only) {
+        meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+        response.result = meshtastic_SerialHalResponse_Result_UNSUPPORTED;
+        snprintf(response.error, sizeof(response.error), "SerialHal not enabled for this role");
+        emitResponse(response, streamApi);
+        return;
+    }
+
+    // Decode the command
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    if (!pb_decode_from_bytes(buf, len, &meshtastic_SerialHalCommand_msg, &cmd)) {
+        meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+        response.result = meshtastic_SerialHalResponse_Result_BAD_REQUEST;
+        snprintf(response.error, sizeof(response.error), "Failed to decode SerialHalCommand");
+        emitResponse(response, streamApi);
+        return;
+    }
+
+    // Initialize response with matching transaction_id
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    response.transaction_id = cmd.transaction_id;
+    response.result = meshtastic_SerialHalResponse_Result_OK;
+
+    // Dispatch to operation handler
+    switch (cmd.type) {
+    case meshtastic_SerialHalCommand_Type_PIN_MODE:
+        handlePinMode(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_DIGITAL_WRITE:
+        handleDigitalWrite(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_DIGITAL_READ:
+        handleDigitalRead(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_ATTACH_INTERRUPT:
+        handleAttachInterrupt(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_DETACH_INTERRUPT:
+        handleDetachInterrupt(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_SPI_TRANSFER:
+        handleSpiTransfer(cmd, response);
+        break;
+    case meshtastic_SerialHalCommand_Type_NOOP:
+        // NOOP: just return OK
+        break;
+    default:
+        response.result = meshtastic_SerialHalResponse_Result_UNSUPPORTED;
+        snprintf(response.error, sizeof(response.error), "Unknown SerialHal operation type");
+        break;
+    }
+
+    emitResponse(response, streamApi);
+}
+
+void SerialHalDevice::handlePinMode(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    // LOG_DEBUG("SerialHalDevice: pinMode pin=%u mode=%u", cmd.pin, cmd.mode);
+    if (cmd.mode == SERIAL_PI_INPUT) {
+        pinMode((int)cmd.pin, INPUT);
+    } else if (cmd.mode == SERIAL_PI_OUTPUT) {
+        pinMode((int)cmd.pin, OUTPUT);
+    } else {
+        setResponseError(response, meshtastic_SerialHalResponse_Result_BAD_REQUEST, "Unsupported pin mode");
+    }
+}
+
+void SerialHalDevice::handleDigitalWrite(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    // LOG_DEBUG("SerialHalDevice: digitalWrite pin=%u value=%u", cmd.pin, cmd.value);
+    digitalWrite((int)cmd.pin, cmd.value ? HIGH : LOW);
+}
+
+void SerialHalDevice::handleDigitalRead(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    // LOG_DEBUG("SerialHalDevice: digitalRead pin=%u", cmd.pin);
+    response.value = (uint32_t)digitalRead((int)cmd.pin);
+}
+
+void SerialHalDevice::handleAttachInterrupt(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    // LOG_DEBUG("SerialHalDevice: attachInterrupt pin=%u mode=%u", cmd.pin, cmd.mode);
+
+    ensureInterruptEmitter();
+
+    int slot = -1;
+    {
+        concurrency::LockGuard lock(&interruptMutex);
+        slot = findSlotByPinLocked(cmd.pin);
+        if (slot < 0) {
+            slot = allocateSlotLocked();
+        }
+
+        if (slot >= 0) {
+            interruptSlots[slot].used = true;
+            interruptSlots[slot].pin = cmd.pin;
+            interruptSlots[slot].mode = cmd.mode;
+            interruptSlots[slot].pending = false;
+        }
+    }
+
+    if (slot < 0) {
+        setResponseError(response, meshtastic_SerialHalResponse_Result_ERROR, "No interrupt slots available");
+        return;
+    }
+
+    ::attachInterrupt((int)cmd.pin, isrTable[slot], toInterruptMode(cmd.mode));
+}
+
+void SerialHalDevice::handleDetachInterrupt(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    // LOG_DEBUG("SerialHalDevice: detachInterrupt pin=%u", cmd.pin);
+
+    ::detachInterrupt((int)cmd.pin);
+
+    {
+        concurrency::LockGuard lock(&interruptMutex);
+        const int slot = findSlotByPinLocked(cmd.pin);
+        if (slot >= 0) {
+            interruptSlots[slot] = InterruptSlot{};
+        }
+    }
+}
+
+void SerialHalDevice::handleSpiTransfer(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response)
+{
+    if (cmd.data.size == 0) {
+        return;
+    }
+
+#if !ARCH_PORTDUINO
+    if (spiLock == nullptr) {
+        setResponseError(response, meshtastic_SerialHalResponse_Result_ERROR, "SPI lock not initialized");
+        return;
+    }
+
+#if defined(HW_SPI1_DEVICE)
+    SPIClass &spiBus = SPI1;
+#else
+    SPIClass &spiBus = SPI;
+#endif
+
+    response.data.size = cmd.data.size;
+
+    {
+        concurrency::LockGuard guard(spiLock);
+        spiBus.beginTransaction(SPISettings(4000000, MSBFIRST, SPI_MODE0));
+#ifdef ARCH_ESP32
+        spiBus.transferBytes(cmd.data.bytes, response.data.bytes, cmd.data.size);
+#else
+        spiBus.transfer(cmd.data.bytes, response.data.bytes, cmd.data.size);
+#endif
+        spiBus.endTransaction();
+    }
+#else
+    // SPI wiring is board/radio-specific; keep this explicit for now.
+    response.result = meshtastic_SerialHalResponse_Result_UNSUPPORTED;
+    snprintf(response.error, sizeof(response.error), "SPI not supported on this platform");
+#endif
+}
+
+void SerialHalDevice::emitResponse(const meshtastic_SerialHalResponse &response, StreamAPI *streamApi)
+{
+    if (streamApi == nullptr) {
+        return;
+    }
+
+    // Encode the response
+    uint8_t encoded[meshtastic_SerialHalResponse_size] = {0};
+    const size_t responseLen =
+        pb_encode_to_bytes(encoded, sizeof(encoded), &meshtastic_SerialHalResponse_msg, static_cast<const void *>(&response));
+
+    if (responseLen == 0 || responseLen > 0xFFFF) {
+        LOG_ERROR("SerialHalDevice: Failed to encode response (len=%zu)", responseLen);
+        return;
+    }
+
+    // Build frame with StreamAPI framing: START1 SERIALHAL_MAGIC LEN_H LEN_L [payload]
+    constexpr uint8_t START1 = 0x94;
+    constexpr uint8_t SERIALHAL_MAGIC = 0xA5;
+
+    uint8_t hdr[4];
+    hdr[0] = START1;
+    hdr[1] = SERIALHAL_MAGIC;
+    hdr[2] = (uint8_t)((responseLen >> 8) & 0xFF); // LEN_H
+    hdr[3] = (uint8_t)(responseLen & 0xFF);        // LEN_L
+
+    // Emit via StreamAPI (this uses the internal txBuf + framing)
+    streamApi->emitSerialHalResponse(hdr, sizeof(hdr), encoded, responseLen);
+
+    // Keep a recent stream instance so async interrupt events can be emitted.
+    {
+        concurrency::LockGuard lock(&interruptMutex);
+        interruptStreamApi = streamApi;
+    }
+}
@@ -0,0 +1,90 @@
+#pragma once
+
+#include "mesh/generated/meshtastic/serial_hal.pb.h"
+#include <cstdint>
+
+/**
+ * @brief Device-side handler for SerialHal GPIO/SPI operations over StreamAPI framing.
+ *
+ * This module decodes SerialHalCommand protobufs received from a host and executes
+ * the requested GPIO (pinMode, digitalWrite, digitalRead, attach/detachInterrupt) or
+ * SPI operations, then returns results via SerialHalResponse.
+ *
+ * Usage:
+ *  1. Override StreamAPI::handleSerialHalCommand() in a subclass
+ *  2. Call SerialHalDevice::handleCommand(buf, len, streamApi)
+ *  3. SerialHalDevice will decode, execute, and emit the response
+ *
+ * The handler is only active when config.lora.serial_hal_only is true.
+ */
+
+class StreamAPI; // forward declaration
+
+class SerialHalDevice
+{
+  public:
+    /**
+     * @brief Process a SerialHalCommand and emit a response.
+     *
+     * Decodes the protobuf, validates the operation, executes it on the device,
+     * and writes the response back via the StreamAPI instance.
+     *
+     * @param buf     Pointer to the encoded SerialHalCommand protobuf payload (not including framing)
+     * @param len     Length of the encoded payload
+     * @param streamApi Pointer to the StreamAPI instance (used for emitting responses)
+     */
+    static void handleCommand(const uint8_t *buf, size_t len, StreamAPI *streamApi);
+
+    /**
+     * @brief Emit a SerialHalResponse back to the host via StreamAPI framing.
+     *
+     * Encodes the response protobuf and sends it with proper framing (START1 SERIALHAL_MAGIC LEN_H LEN_L payload).
+     *
+     * @param response The response to send
+     * @param streamApi Pointer to the StreamAPI instance
+     */
+    static void emitResponse(const meshtastic_SerialHalResponse &response, StreamAPI *streamApi);
+
+  private:
+    /**
+     * @brief Execute a GPIO pinMode operation.
+     * @param cmd Decoded SerialHalCommand with PIN_MODE type
+     * @param response Response object to fill with result
+     */
+    static void handlePinMode(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+
+    /**
+     * @brief Execute a GPIO digitalWrite operation.
+     * @param cmd Decoded SerialHalCommand with DIGITAL_WRITE type
+     * @param response Response object to fill with result
+     */
+    static void handleDigitalWrite(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+
+    /**
+     * @brief Execute a GPIO digitalRead operation.
+     * @param cmd Decoded SerialHalCommand with DIGITAL_READ type
+     * @param response Response object to fill with result (value field contains read result)
+     */
+    static void handleDigitalRead(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+
+    /**
+     * @brief Execute an attachInterrupt operation.
+     * @param cmd Decoded SerialHalCommand with ATTACH_INTERRUPT type
+     * @param response Response object to fill with result
+     */
+    static void handleAttachInterrupt(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+
+    /**
+     * @brief Execute a detachInterrupt operation.
+     * @param cmd Decoded SerialHalCommand with DETACH_INTERRUPT type
+     * @param response Response object to fill with result
+     */
+    static void handleDetachInterrupt(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+
+    /**
+     * @brief Execute an SPI transfer operation.
+     * @param cmd Decoded SerialHalCommand with SPI_TRANSFER type and data to send
+     * @param response Response object to fill with result (data field contains received bytes)
+     */
+    static void handleSpiTransfer(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse &response);
+};
@@ -1,12 +1,15 @@
 #include "StreamAPI.h"
 #include "PowerFSM.h"
 #include "RTC.h"
+#include "RedirectablePrint.h"
+#include "SerialHalDevice.h"
 #include "Throttle.h"
 #include "concurrency/LockGuard.h"
 #include "configuration.h"

 #define START1 0x94
 #define START2 0xc3
+#define SERIALHAL_MAGIC 0xa5 // second framing byte for SerialHal frames (START1 SH_MAGIC LEN_H LEN_L PAYLOAD)
 #define HEADER_LEN 4

 int32_t StreamAPI::runOncePart()
@@ -79,18 +82,29 @@ int32_t StreamAPI::handleRecStream(const char *buf, uint16_t bufLen)
        if (ptr == 0) { // looking for START1
            if (c != START1)
                rxPtr = 0;     // failed to find framing
-        } else if (ptr == 1) { // looking for START2
-            if (c != START2)
-                rxPtr = 0;                             // failed to find framing
+        } else if (ptr == 1) { // discriminate frame type on second byte
+            if (c == START2) {
+                rxIsSerialHal = false; // standard ToRadio frame
+                serialHalRxActive.store(false);
+                RedirectablePrint::setSerialHalLogSuppressed(false);
+            } else if (c == SERIALHAL_MAGIC) {
+                rxIsSerialHal = true; // SerialHal command frame
+                serialHalRxActive.store(true);
+                RedirectablePrint::setSerialHalLogSuppressed(true);
+            } else {
+                rxPtr = 0; // unrecognised second byte — not our frame
+                serialHalRxActive.store(false);
+                RedirectablePrint::setSerialHalLogSuppressed(false);
+            }
        } else if (ptr >= HEADER_LEN - 1) {            // we have at least read our 4 byte framing
            uint32_t len = (rxBuf[2] << 8) + rxBuf[3]; // big endian 16 bit length follows framing

            // console->printf("len %d\n", len);

            if (ptr == HEADER_LEN - 1) {
-                // we _just_ finished our 4 byte header, validate length now (note: a length of zero is a valid
-                // protobuf also)
-                if (len > MAX_TO_FROM_RADIO_SIZE)
+                // we _just_ finished our 4 byte header, validate length now
+                uint32_t maxLen = rxIsSerialHal ? (uint32_t)meshtastic_SerialHalCommand_size : MAX_TO_FROM_RADIO_SIZE;
+                if (len > maxLen)
                    rxPtr = 0; // length is bogus, restart search for framing
            }

@@ -98,8 +112,16 @@ int32_t StreamAPI::handleRecStream(const char *buf, uint16_t bufLen)
                if (ptr + 1 >= len + HEADER_LEN) { // have we received all of the payload?
                    rxPtr = 0;                     // start over again on the next packet

-                    // If we didn't just fail the packet and we now have the right # of bytes, parse it
-                    handleToRadio(rxBuf + HEADER_LEN, len);
+                    // Dispatch based on which frame type we identified at byte 1
+                    if (rxIsSerialHal)
+                        handleSerialHalCommand(rxBuf + HEADER_LEN, len);
+                    else
+                        handleToRadio(rxBuf + HEADER_LEN, len);
+
+                    if (rxIsSerialHal)
+                        serialHalRxActive.store(false);
+                    if (rxIsSerialHal)
+                        RedirectablePrint::setSerialHalLogSuppressed(false);
                }
        }
    }
@@ -114,7 +136,12 @@ int32_t StreamAPI::readStream()
    if (!stream->available()) {
        // Nothing available this time, if the computer has talked to us recently, poll often, otherwise let CPU sleep a long time
        bool recentRx = Throttle::isWithinTimespanMs(lastRxMsec, 2000);
-        return recentRx ? 5 : 250;
+        if (!recentRx)
+            return 250; // Sleep a long time if we haven't heard from the computer in a while
+        if (serialHalRxActive.load())
+            return 0; // If we are in the middle of a SerialHal transaction, don't sleep at all because we want to be as
+                      // responsive as possible to incoming SerialHal bytes
+        return 5;     // Otherwise, poll frequently for new data
    } else {
        while (stream->available()) { // Currently we never want to block
            int cInt = stream->read();
@@ -135,18 +162,30 @@ int32_t StreamAPI::readStream()
            if (ptr == 0) { // looking for START1
                if (c != START1)
                    rxPtr = 0;     // failed to find framing
-            } else if (ptr == 1) { // looking for START2
-                if (c != START2)
-                    rxPtr = 0;                             // failed to find framing
+            } else if (ptr == 1) { // discriminate frame type on second byte
+                if (c == START2) {
+                    rxIsSerialHal = false; // standard ToRadio frame
+                    serialHalRxActive.store(false);
+                    RedirectablePrint::setSerialHalLogSuppressed(false);
+                } else if (c == SERIALHAL_MAGIC) {
+                    rxIsSerialHal = true; // SerialHal command frame
+                    serialHalRxActive.store(true);
+                    RedirectablePrint::setSerialHalLogSuppressed(true);
+                    LOG_WARN("StreamAPI: Detected SerialHal command frame");
+                } else {
+                    rxPtr = 0; // unrecognised second byte — not our frame
+                    serialHalRxActive.store(false);
+                    RedirectablePrint::setSerialHalLogSuppressed(false);
+                }
            } else if (ptr >= HEADER_LEN - 1) {            // we have at least read our 4 byte framing
                uint32_t len = (rxBuf[2] << 8) + rxBuf[3]; // big endian 16 bit length follows framing

                // console->printf("len %d\n", len);

                if (ptr == HEADER_LEN - 1) {
-                    // we _just_ finished our 4 byte header, validate length now (note: a length of zero is a valid
-                    // protobuf also)
-                    if (len > MAX_TO_FROM_RADIO_SIZE)
+                    // we _just_ finished our 4 byte header, validate length now
+                    uint32_t maxLen = rxIsSerialHal ? (uint32_t)meshtastic_SerialHalCommand_size : MAX_TO_FROM_RADIO_SIZE;
+                    if (len > maxLen)
                        rxPtr = 0; // length is bogus, restart search for framing
                }

@@ -154,8 +193,16 @@ int32_t StreamAPI::readStream()
                    if (ptr + 1 >= len + HEADER_LEN) { // have we received all of the payload?
                        rxPtr = 0;                     // start over again on the next packet

-                        // If we didn't just fail the packet and we now have the right # of bytes, parse it
-                        handleToRadio(rxBuf + HEADER_LEN, len);
+                        // Dispatch based on which frame type we identified at byte 1
+                        if (rxIsSerialHal)
+                            handleSerialHalCommand(rxBuf + HEADER_LEN, len);
+                        else
+                            handleToRadio(rxBuf + HEADER_LEN, len);
+
+                        if (rxIsSerialHal)
+                            serialHalRxActive.store(false);
+                        if (rxIsSerialHal)
+                            RedirectablePrint::setSerialHalLogSuppressed(false);
                    }
            }
        }
@@ -199,6 +246,10 @@ void StreamAPI::emitRebooted()

 void StreamAPI::emitLogRecord(meshtastic_LogRecord_Level level, const char *src, const char *format, va_list arg)
 {
+    if (serialHalRxActive.load()) {
+        return;
+    }
+
    // IMPORTANT: do NOT touch `fromRadioScratch` or `txBuf` here — those
    // belong to the main packet-emission path and a LOG_ firing during
    // `writeStream()` would corrupt an in-flight encode. We keep a
@@ -249,4 +300,31 @@ void StreamAPI::onConnectionChanged(bool connected)
        // received a packet in a while
        powerFSM.trigger(EVENT_SERIAL_DISCONNECTED);
    }
+}
+
+void StreamAPI::handleSerialHalCommand(const uint8_t *buf, size_t len)
+{
+    // Default implementation: dispatch to SerialHalDevice for GPIO/SPI handling
+    SerialHalDevice::handleCommand(buf, len, this);
+}
+
+void StreamAPI::emitSerialHalResponse(const uint8_t *hdr, size_t hdrLen, const uint8_t *payload, size_t payloadLen)
+{
+    if (hdr == nullptr || hdrLen != 4 || payload == nullptr || payloadLen > meshtastic_SerialHalResponse_size) {
+        LOG_ERROR("StreamAPI: Invalid SerialHal response parameters");
+        return;
+    }
+
+    // Build complete frame in a temporary buffer
+    uint8_t frame[4 + meshtastic_SerialHalResponse_size];
+    memcpy(frame, hdr, hdrLen);
+    memcpy(frame + hdrLen, payload, payloadLen);
+
+    size_t totalLen = hdrLen + payloadLen;
+
+    // Serialize stream writes against other emit operations via streamLock
+    concurrency::LockGuard guard(&streamLock);
+    stream->write(frame, totalLen);
+    stream->flush();
+    LOG_WARN("StreamAPI: Emitted SerialHal response frame (len=%zu)", totalLen);
 }
@@ -4,10 +4,15 @@
 #include "Stream.h"
 #include "concurrency/Lock.h"
 #include "concurrency/OSThread.h"
+#include "generated/meshtastic/serial_hal.pb.h"
+#include <atomic>
 #include <cstdarg>

-// A To/FromRadio packet + our 32 bit header
-#define MAX_STREAM_BUF_SIZE (MAX_TO_FROM_RADIO_SIZE + sizeof(uint32_t))
+// Buffer sized for the larger of a full ToRadio/FromRadio payload or a full SerialHalCommand payload, plus header.
+#define MAX_STREAM_PAYLOAD_SIZE                                                                                                  \
+    (MAX_TO_FROM_RADIO_SIZE > (int)meshtastic_SerialHalCommand_size ? MAX_TO_FROM_RADIO_SIZE                                     \
+                                                                    : (int)meshtastic_SerialHalCommand_size)
+#define MAX_STREAM_BUF_SIZE (MAX_STREAM_PAYLOAD_SIZE + (int)sizeof(uint32_t))

 /**
 * A version of our 'phone' API that talks over a Stream.  So therefore well suited to use with serial links
@@ -39,6 +44,8 @@ class StreamAPI : public PhoneAPI

    uint8_t rxBuf[MAX_STREAM_BUF_SIZE] = {0};
    size_t rxPtr = 0;
+    bool rxIsSerialHal = false; ///< true when the current in-progress frame is a SerialHal frame (START1 SH_MAGIC ...)
+    std::atomic<bool> serialHalRxActive{false};

    /// time of last rx, used, to slow down our polling if we haven't heard from anyone
    uint32_t lastRxMsec = 0;
@@ -56,6 +63,17 @@ class StreamAPI : public PhoneAPI
    /// Check the current underlying physical link to see if the client is currently connected
    virtual bool checkIsConnected() override = 0;

+    /**
+     * Emit a SerialHal response frame with proper framing (START1 SERIALHAL_MAGIC LEN_H LEN_L payload).
+     * Called by SerialHalDevice to send responses back to the host.
+     *
+     * @param hdr     4-byte header (START1 SERIALHAL_MAGIC LEN_H LEN_L)
+     * @param hdrLen  Length of header (should be 4)
+     * @param payload Encoded SerialHalResponse protobuf payload
+     * @param payloadLen Length of payload
+     */
+    void emitSerialHalResponse(const uint8_t *hdr, size_t hdrLen, const uint8_t *payload, size_t payloadLen);
+
  private:
    /**
     * Read any rx chars from the link and call handleToRadio
@@ -75,6 +93,12 @@ class StreamAPI : public PhoneAPI
     */
    void emitRebooted();

+    /**
+     * Called when a complete SerialHal-framed packet has been received.
+     * Default implementation dispatches to SerialHalDevice for GPIO/SPI handling.
+     */
+    virtual void handleSerialHalCommand(const uint8_t *buf, size_t len);
+
    virtual void onConnectionChanged(bool connected) override;

    /**
@@ -3,8 +3,9 @@
 #include "ServerAPI.h"
 #include <WiFi.h>

-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET

 /**
@@ -13,8 +13,9 @@
 #include <WebServer.h>
 #include <WiFi.h>

-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET

 #ifdef ARCH_ESP32
@@ -12,8 +12,9 @@

 #include <AsyncUDP.h>

-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET

 #define UDP_MULTICAST_DEFAUL_PORT 4403 // Default port for UDP multicast is same as TCP api server
@@ -10,8 +10,9 @@
 #include "target_specific.h"
 #include <WiFi.h>

-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET

 #include <WiFiUdp.h>
@@ -9,8 +9,9 @@
 #include <WiFi.h>
 #endif

-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET

 extern bool needReconnect;
@@ -262,7 +262,7 @@ bool AdminModule::handleReceivedProtobuf(const meshtastic_MeshPacket &mp, meshta
        break;
    }
    case meshtastic_AdminMessage_ota_request_tag: {
-#if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_WIFI
+#if defined(ARCH_ESP32)
        LOG_INFO("OTA Requested");

        if (r->ota_request.ota_hash.size != 32) {
@@ -1336,9 +1336,9 @@ void AdminModule::handleGetDeviceConnectionStatus(const meshtastic_MeshPacket &r
    conn.has_bluetooth = true;
    conn.bluetooth.pin = config.bluetooth.fixed_pin;
 #ifdef ARCH_ESP32
-    if (config.bluetooth.enabled && bluetoothApi) {
-        conn.bluetooth.is_connected = bluetoothApi->isConnected();
-        conn.bluetooth.rssi = bluetoothApi->getRssi();
+    if (config.bluetooth.enabled && nimbleBluetooth) {
+        conn.bluetooth.is_connected = nimbleBluetooth->isConnected();
+        conn.bluetooth.rssi = nimbleBluetooth->getRssi();
    }
 #elif defined(ARCH_NRF52)
    if (config.bluetooth.enabled && nrf52Bluetooth) {
@@ -1599,8 +1599,8 @@ void disableBluetooth()
 {
 #if HAS_BLUETOOTH
 #ifdef ARCH_ESP32
-    if (bluetoothApi)
-        bluetoothApi->deinit();
+    if (nimbleBluetooth)
+        nimbleBluetooth->deinit();
 #elif defined(ARCH_NRF52)
    if (nrf52Bluetooth)
        nrf52Bluetooth->shutdown();
@@ -16,28 +16,10 @@ int32_t INA3221Sensor::runOnce()
        return DEFAULT_SENSOR_MINIMUM_WAIT_TIME_BETWEEN_READS;
    }
    if (!status) {
-        // Re-initialise with the address and Wire bus from the telemetry sensors map.
-        // (Rob Tillaart INA3221_RT takes address + TwoWire*, unlike sgtwilko which took Wire in begin().)
-        ina3221 = INA3221(nodeTelemetrySensorsMap[sensorType].first, nodeTelemetrySensorsMap[sensorType].second);
-        status = ina3221.begin();
-        if (status) {
-            // Default all three channels to a 0.1 Ω shunt resistor.
-            // Override per-variant by defining INA3221_SHUNT_R_CH1/CH2/CH3 (in Ohms) in variant.h.
-#ifndef INA3221_SHUNT_R_CH1
-#define INA3221_SHUNT_R_CH1 0.1f
-#endif
-#ifndef INA3221_SHUNT_R_CH2
-#define INA3221_SHUNT_R_CH2 0.1f
-#endif
-#ifndef INA3221_SHUNT_R_CH3
-#define INA3221_SHUNT_R_CH3 0.1f
-#endif
-            ina3221.setShuntR(0, INA3221_SHUNT_R_CH1);
-            ina3221.setShuntR(1, INA3221_SHUNT_R_CH2);
-            ina3221.setShuntR(2, INA3221_SHUNT_R_CH3);
-        }
+        ina3221.begin(nodeTelemetrySensorsMap[sensorType].second);
+        ina3221.setShuntRes(100, 100, 100); // 0.1 Ohm shunt resistors
+        status = true;
    } else {
-        // Already initialised; status stays true and initI2CSensor() returns next poll interval.
        status = true;
    }
    return initI2CSensor();
@@ -45,14 +27,12 @@ int32_t INA3221Sensor::runOnce()

 void INA3221Sensor::setup() {}

-struct _INA3221Measurement INA3221Sensor::getMeasurement(uint8_t ch)
+struct _INA3221Measurement INA3221Sensor::getMeasurement(ina3221_ch_t ch)
 {
    struct _INA3221Measurement measurement;

-    measurement.voltage = ina3221.getBusVoltage(ch); // Volts
-    // getCurrent_mA() is used instead of getCurrent() because Rob Tillaart's getCurrent()
-    // returns Amperes; the telemetry proto and VoltageSensor/CurrentSensor interfaces expect mA.
-    measurement.current = ina3221.getCurrent_mA(ch); // milliAmps
+    measurement.voltage = ina3221.getVoltage(ch);
+    measurement.current = ina3221.getCurrent(ch);

    return measurement;
 }
@@ -63,7 +43,7 @@ struct _INA3221Measurements INA3221Sensor::getMeasurements()

    // INA3221 has 3 channels starting from 0
    for (int i = 0; i < 3; i++) {
-        measurements.measurements[i] = getMeasurement((uint8_t)i);
+        measurements.measurements[i] = getMeasurement((ina3221_ch_t)i);
    }

    return measurements;
@@ -107,41 +87,24 @@ bool INA3221Sensor::getPowerMetrics(meshtastic_Telemetry *measurement)
    measurement->variant.power_metrics.has_ch3_voltage = true;
    measurement->variant.power_metrics.has_ch3_current = true;

-    // INA3221 channel indices are zero-based (0=CH1, 1=CH2, 2=CH3).
-    measurement->variant.power_metrics.ch1_voltage = m.measurements[0].voltage;
-    measurement->variant.power_metrics.ch1_current = m.measurements[0].current;
-    measurement->variant.power_metrics.ch2_voltage = m.measurements[1].voltage;
-    measurement->variant.power_metrics.ch2_current = m.measurements[1].current;
-    measurement->variant.power_metrics.ch3_voltage = m.measurements[2].voltage;
-    measurement->variant.power_metrics.ch3_current = m.measurements[2].current;
+    measurement->variant.power_metrics.ch1_voltage = m.measurements[INA3221_CH1].voltage;
+    measurement->variant.power_metrics.ch1_current = m.measurements[INA3221_CH1].current;
+    measurement->variant.power_metrics.ch2_voltage = m.measurements[INA3221_CH2].voltage;
+    measurement->variant.power_metrics.ch2_current = m.measurements[INA3221_CH2].current;
+    measurement->variant.power_metrics.ch3_voltage = m.measurements[INA3221_CH3].voltage;
+    measurement->variant.power_metrics.ch3_current = m.measurements[INA3221_CH3].current;

    return true;
 }

 uint16_t INA3221Sensor::getBusVoltageMv()
 {
-    return lround(ina3221.getBusVoltage_mV(BAT_CH));
+    return lround(ina3221.getVoltage(BAT_CH) * 1000);
 }

 int16_t INA3221Sensor::getCurrentMa()
 {
-    return lround(ina3221.getCurrent_mA(BAT_CH));
-}
-
-// Bus voltage register (0x02 + ch*2): bits [15:3] unsigned, 1 LSB = 8 mV (datasheet p.6).
-// Voltage raw units: 1 count = 8 mV, so V_mV = raw * 8.
-int16_t INA3221Sensor::getRawBusVoltage(uint8_t ch)
-{
-    return (int16_t)(ina3221.getRegister(0x02 + ch * 2) >> 3);
-}
-
-// Shunt voltage register (0x01 + ch*2): bits [15:3] signed two's complement, 1 LSB = 40 µV (datasheet p.6).
-// Current raw units are shunt-voltage counts: 1 count = 40 uV, signed.
-// I_mA = (raw * 40 uV) / R_mOhm, because uV / mOhm = mA.
-// Example for 100 mOhm shunt: I_mA = raw * 40 / 100 = raw * 0.4.
-int16_t INA3221Sensor::getRawShuntCurrent(uint8_t ch)
-{
-    return (int16_t)(ina3221.getRegister(0x01 + ch * 2) >> 3);
+    return lround(ina3221.getCurrent(BAT_CH));
 }

 #endif
@@ -1,9 +1,3 @@
-// INA3221 channel aliases (zero-based: 0 = CH1, 1 = CH2, 2 = CH3).
-// Defined before configuration.h so variant.h can use them in INA3221_ENV_CH / INA3221_BAT_CH.
-#define INA3221_CH1 0
-#define INA3221_CH2 1
-#define INA3221_CH3 2
-
 #include "configuration.h"

 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR && __has_include(<INA3221.h>)
@@ -15,29 +9,26 @@
 #include <INA3221.h>

 #ifndef INA3221_ENV_CH
-#define INA3221_ENV_CH INA3221_CH1 // channel to report in environment metrics (default: CH1)
+#define INA3221_ENV_CH INA3221_CH1
 #endif

 #ifndef INA3221_BAT_CH
-#define INA3221_BAT_CH INA3221_CH1 // channel for device_battery_ina_address (default: CH1)
+#define INA3221_BAT_CH INA3221_CH1
 #endif

 class INA3221Sensor : public TelemetrySensor, VoltageSensor, CurrentSensor
 {
  private:
-    // Placeholder constructor; re-initialised with correct address and Wire in runOnce().
-    INA3221 ina3221 = INA3221(INA3221_ADDR);
+    INA3221 ina3221 = INA3221(INA3221_ADDR42_SDA);

    // channel to report voltage/current for environment metrics
-    static const uint8_t ENV_CH = INA3221_ENV_CH;
-    static_assert(INA3221_ENV_CH >= 0 && INA3221_ENV_CH <= 2, "INA3221_ENV_CH must be 0, 1, or 2");
+    static const ina3221_ch_t ENV_CH = INA3221_ENV_CH;

    // channel to report battery voltage for device_battery_ina_address
-    static const uint8_t BAT_CH = INA3221_BAT_CH;
-    static_assert(INA3221_BAT_CH >= 0 && INA3221_BAT_CH <= 2, "INA3221_BAT_CH must be 0, 1, or 2");
+    static const ina3221_ch_t BAT_CH = INA3221_BAT_CH;

    // get a single measurement for a channel
-    struct _INA3221Measurement getMeasurement(uint8_t ch);
+    struct _INA3221Measurement getMeasurement(ina3221_ch_t ch);

    // get all measurements for all channels
    struct _INA3221Measurements getMeasurements();
@@ -54,10 +45,6 @@ class INA3221Sensor : public TelemetrySensor, VoltageSensor, CurrentSensor
    bool getMetrics(meshtastic_Telemetry *measurement) override;
    virtual uint16_t getBusVoltageMv() override;
    virtual int16_t getCurrentMa() override;
-
-    // Raw register reads (bits [15:3] right-shifted), no conversion applied.
-    int16_t getRawBusVoltage(uint8_t ch);
-    int16_t getRawShuntCurrent(uint8_t ch);
 };

 struct _INA3221Measurement {
@@ -90,8 +90,8 @@ int32_t PaxcounterModule::runOnce()
            configuration.blecounter = 1;
            configuration.blescantime = 0; // infinite
            configuration.wificounter = 1;
-            // configuration.wifi_channel_map = WIFI_CHANNEL_ALL;
-            // configuration.wifi_channel_switch_interval = 50;
+            configuration.wifi_channel_map = WIFI_CHANNEL_ALL;
+            configuration.wifi_channel_switch_interval = 50;
            configuration.wifi_rssi_threshold = Default::getConfiguredOrDefault(moduleConfig.paxcounter.wifi_threshold, -80);
            configuration.ble_rssi_threshold = Default::getConfiguredOrDefault(moduleConfig.paxcounter.ble_threshold, -80);
            libpax_update_config(&configuration);
@@ -19,8 +19,9 @@
 #include "mesh/wifi/WiFiAPClient.h"
 #include <WiFi.h>
 #endif
-#if HAS_ETHERNET && defined(ARCH_ESP32)
-#include <ETH.h>
+#if HAS_ETHERNET && defined(USE_WS5500)
+#include <ETHClass2.h>
+#define ETH ETH2
 #endif // HAS_ETHERNET
 #include "Default.h"
 #if !defined(ARCH_NRF52) || NRF52_USE_JSON
@@ -1,5 +1,5 @@
 #include "configuration.h"
-#if !MESHTASTIC_EXCLUDE_BLUETOOTH && !defined(CONFIG_IDF_TARGET_ESP32P4)
+#if !MESHTASTIC_EXCLUDE_BLUETOOTH
 #include "BluetoothCommon.h"
 #include "NimbleBluetooth.h"
 #include "PowerFSM.h"
@@ -10,28 +10,31 @@
 #include "mesh/PhoneAPI.h"
 #include "mesh/mesh-pb-constants.h"
 #include "sleep.h"
-#include <BLE2904.h>
-#include <BLEAdvertising.h>
-#include <BLEDevice.h>
-#include <BLESecurity.h>
-#include <BLEUtils.h>
+#include <NimBLEDevice.h>
 #include <atomic>
 #include <mutex>

+#ifdef NIMBLE_TWO
+#include "NimBLEAdvertising.h"
+#include "NimBLEExtAdvertising.h"
 #include "PowerStatus.h"
+#endif

+#if defined(CONFIG_NIMBLE_CPP_IDF)
 #include "host/ble_gap.h"
-#include "host/ble_store.h"
+#else
+#include "nimble/nimble/host/include/host/ble_gap.h"
+#endif
+
+#if defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6)

 namespace
 {
-// Maintainer note: this backend intentionally diverges from HostedBluetooth in a few platform-specific areas.
-// If you change shared BLE flow here (PhoneAPI queue/sync, security/pairing, mesh GATT/advertising,
-// connect/disconnect handling), review and update HostedBluetooth.cpp as needed.
 constexpr uint16_t kPreferredBleMtu = 517;
 constexpr uint16_t kPreferredBleTxOctets = 251;
 constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
 } // namespace
+#endif

 // Debugging options: careful, they slow things down quite a bit!
 // #define DEBUG_NIMBLE_ON_READ_TIMING  // uncomment to time onRead duration
@@ -41,10 +44,10 @@ constexpr uint16_t kPreferredBleTxTimeUs = (kPreferredBleTxOctets + 14) * 8;
 #define NIMBLE_BLUETOOTH_TO_PHONE_QUEUE_SIZE 3
 #define NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE 3

-BLECharacteristic *fromNumCharacteristic;
-BLECharacteristic *BatteryCharacteristic;
-BLECharacteristic *logRadioCharacteristic;
-BLEServer *bleServer;
+NimBLECharacteristic *fromNumCharacteristic;
+NimBLECharacteristic *BatteryCharacteristic;
+NimBLECharacteristic *logRadioCharacteristic;
+NimBLEServer *bleServer;

 static bool passkeyShowing;
 static std::atomic<uint16_t> nimbleBluetoothConnHandle{BLE_HS_CONN_HANDLE_NONE}; // BLE_HS_CONN_HANDLE_NONE means "no connection"
@@ -115,8 +118,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
        - Yes, we have to do some copy operations on pop because of this, but it's worth it to avoid cross-task memory management.

      NOTIFY IS BROKEN:
-        - Adding BLECharacteristic::PROPERTY_NOTIFY to FromRadioCharacteristic appears to break things. It is NOT backwards
-      compatible.
+        - Adding NIMBLE_PROPERTY::NOTIFY to FromRadioCharacteristic appears to break things. It is NOT backwards compatible.

      ZERO-SIZE READS:
        - Returning a zero-size read from onRead breaks some clients during the config phase. So we have to block onRead until we
@@ -137,7 +139,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
    std::mutex fromPhoneMutex;
    std::atomic<size_t> fromPhoneQueueSize{0};
    // We use array here (and pay the cost of memcpy) to avoid dynamic memory allocations and frees across FreeRTOS tasks.
-    std::array<BLEValue, NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE> fromPhoneQueue{};
+    std::array<NimBLEAttValue, NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE> fromPhoneQueue{};

    /* Packets to phone (BLE onRead callback) */
    std::mutex toPhoneMutex;
@@ -299,7 +301,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
            LOG_DEBUG("NimbleBluetooth: handling ToRadio packet, fromPhoneQueueSize=%u", fromPhoneQueueSize.load());

            // Pop the front of fromPhoneQueue, holding the mutex only briefly while we pop.
-            BLEValue val;
+            NimBLEAttValue val;
            { // scope for fromPhoneMutex mutex
                std::lock_guard<std::mutex> guard(fromPhoneMutex);
                val = fromPhoneQueue[0];
@@ -314,7 +316,7 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
                    fromPhoneQueueSize--;
            }

-            handleToRadio(val.getData(), val.getLength());
+            handleToRadio(val.data(), val.length());
        }
    }

@@ -326,7 +328,9 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
        PhoneAPI::onNowHasData(fromRadioNum);

 #ifdef DEBUG_NIMBLE_NOTIFY
+
        int currentNotifyCount = notifyCount.fetch_add(1);
+
        uint8_t cc = bleServer->getConnectedCount();
        // This logging slows things down when there are lots of packets going to the phone, like initial connection:
        LOG_DEBUG("BLE notify(%d) fromNum: %d connections: %d", currentNotifyCount, fromRadioNum, cc);
@@ -336,7 +340,13 @@ class BluetoothPhoneAPI : public PhoneAPI, public concurrency::OSThread
        put_le32(val, fromRadioNum);

        fromNumCharacteristic->setValue(val, sizeof(val));
+#ifdef NIMBLE_TWO
+        // NOTE: I don't have any NIMBLE_TWO devices, but this line makes me suspicious, and I suspect it needs to just be
+        // notify().
+        fromNumCharacteristic->notify(val, sizeof(val), BLE_HS_CONN_HANDLE_NONE);
+#else
        fromNumCharacteristic->notify();
+#endif
    }

    /// Check the current underlying physical link to see if the client is currently connected
@@ -399,9 +409,14 @@ static BluetoothPhoneAPI *bluetoothPhoneAPI;
 // Last ToRadio value received from the phone
 static uint8_t lastToRadio[MAX_TO_FROM_RADIO_SIZE];

-class NimbleBluetoothToRadioCallback : public BLECharacteristicCallbacks
+class NimbleBluetoothToRadioCallback : public NimBLECharacteristicCallbacks
 {
-    void onWrite(BLECharacteristic *pCharacteristic) override
+#ifdef NIMBLE_TWO
+    virtual void onWrite(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &connInfo) override
+#else
+    virtual void onWrite(NimBLECharacteristic *pCharacteristic) override
+
+#endif
    {
        // CAUTION: This callback runs in the NimBLE task!!! Don't do anything except communicate with the main task's runOnce.
        // Assumption: onWrite is serialized by NimBLE, so we don't need to lock here against multiple concurrent onWrite calls.
@@ -413,17 +428,15 @@ class NimbleBluetoothToRadioCallback : public BLECharacteristicCallbacks
        LOG_DEBUG("BLE onWrite(%d): start millis=%d", currentWriteCount, startMillis);
 #endif

-        // Create a BLEValue and populate it with the received data
-        BLEValue val;
-        val.setValue(pCharacteristic->getData(), pCharacteristic->getLength());
+        auto val = pCharacteristic->getValue();

-        if (memcmp(lastToRadio, val.getData(), val.getLength()) != 0) {
+        if (memcmp(lastToRadio, val.data(), val.length()) != 0) {
            if (bluetoothPhoneAPI->fromPhoneQueueSize < NIMBLE_BLUETOOTH_FROM_PHONE_QUEUE_SIZE) {
                // Note: the comparison above is safe without a mutex because we are the only method that *increases*
                // fromPhoneQueueSize. (It's okay if fromPhoneQueueSize *decreases* in the main task meanwhile.)
-                memcpy(lastToRadio, val.getData(), val.getLength());
+                memcpy(lastToRadio, val.data(), val.length());

-                { // scope for fromPhoneMutex mutexv, pCharacteristic->getLen
+                { // scope for fromPhoneMutex mutex
                    // Append to fromPhoneQueue, protected by fromPhoneMutex. Hold the mutex as briefly as possible.
                    std::lock_guard<std::mutex> guard(bluetoothPhoneAPI->fromPhoneMutex);
                    bluetoothPhoneAPI->fromPhoneQueue.at(bluetoothPhoneAPI->fromPhoneQueueSize) = val;
@@ -437,21 +450,24 @@ class NimbleBluetoothToRadioCallback : public BLECharacteristicCallbacks
 #ifdef DEBUG_NIMBLE_ON_WRITE_TIMING
                int finishMillis = millis();
                LOG_DEBUG("BLE onWrite(%d): append to fromPhoneQueue took %u ms. numBytes=%d", currentWriteCount,
-                          finishMillis - startMillis, val.getLength());
+                          finishMillis - startMillis, val.length());
 #endif
            } else {
-                LOG_WARN("BLE onWrite(%d): Drop ToRadio packet, fromPhoneQueue full (%u bytes)", currentWriteCount,
-                         val.getLength());
+                LOG_WARN("BLE onWrite(%d): Drop ToRadio packet, fromPhoneQueue full (%u bytes)", currentWriteCount, val.length());
            }
        } else {
-            LOG_DEBUG("BLE onWrite(%d): Drop duplicate ToRadio packet (%u bytes)", currentWriteCount, val.getLength());
+            LOG_DEBUG("BLE onWrite(%d): Drop duplicate ToRadio packet (%u bytes)", currentWriteCount, val.length());
        }
    }
 };

-class NimbleBluetoothFromRadioCallback : public BLECharacteristicCallbacks
+class NimbleBluetoothFromRadioCallback : public NimBLECharacteristicCallbacks
 {
-    void onRead(BLECharacteristic *pCharacteristic) override
+#ifdef NIMBLE_TWO
+    virtual void onRead(NimBLECharacteristic *pCharacteristic, NimBLEConnInfo &connInfo) override
+#else
+    virtual void onRead(NimBLECharacteristic *pCharacteristic) override
+#endif
    {
        // CAUTION: This callback runs in the NimBLE task!!! Don't do anything except communicate with the main task's runOnce.

@@ -557,15 +573,34 @@ class NimbleBluetoothFromRadioCallback : public BLECharacteristicCallbacks
    }
 };

-class NimbleBluetoothSecurityCallback : public BLESecurityCallbacks
+class NimbleBluetoothServerCallback : public NimBLEServerCallbacks
 {
-    void onPassKeyNotify(uint32_t passkey) override
+#ifdef NIMBLE_TWO
+  public:
+    NimbleBluetoothServerCallback(NimbleBluetooth *ble) { this->ble = ble; }
+
+  private:
+    NimbleBluetooth *ble;
+
+    virtual uint32_t onPassKeyDisplay() override
+#else
+    virtual uint32_t onPassKeyRequest() override
+#endif
    {
-        LOG_INFO("*** Enter passkey %06u on the peer side ***", passkey);
+        uint32_t passkey = config.bluetooth.fixed_pin;
+
+        if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN) {
+            LOG_INFO("Use random passkey");
+            // This is the passkey to be entered on peer - we pick a number >100,000 to ensure 6 digits
+            passkey = random(100000, 999999);
+        }
+        LOG_INFO("*** Enter passkey %d on the peer side ***", passkey);
+
        powerFSM.trigger(EVENT_BLUETOOTH_PAIR);
        meshtastic::BluetoothStatus newStatus(std::to_string(passkey));
        bluetoothStatus->updateStatus(&newStatus);
-#if HAS_SCREEN
+
+#if HAS_SCREEN // Todo: migrate this display code back into Screen class, and observe bluetoothStatus
        if (screen) {
            screen->startAlert([passkey](OLEDDisplay *display, OLEDDisplayUiState *state, int16_t x, int16_t y) -> void {
                char btPIN[16] = "888888";
@@ -595,8 +630,15 @@ class NimbleBluetoothSecurityCallback : public BLESecurityCallbacks
        }
 #endif
        passkeyShowing = true;
+
+        return passkey;
    }
-    void onAuthenticationComplete(ble_gap_conn_desc *desc) override
+
+#ifdef NIMBLE_TWO
+    virtual void onAuthenticationComplete(NimBLEConnInfo &connInfo) override
+#else
+    virtual void onAuthenticationComplete(ble_gap_conn_desc *desc) override
+#endif
    {
        LOG_INFO("BLE authentication complete");

@@ -604,47 +646,58 @@ class NimbleBluetoothSecurityCallback : public BLESecurityCallbacks
        bluetoothStatus->updateStatus(&newStatus);
        clearPairingDisplay();

+        // Store the connection handle for future use
+#ifdef NIMBLE_TWO
+        nimbleBluetoothConnHandle = connInfo.getConnHandle();
+#else
        nimbleBluetoothConnHandle = desc->conn_handle;
+#endif
    }
-};

-class NimbleBluetoothServerCallback : public BLEServerCallbacks
-{
-  public:
-    explicit NimbleBluetoothServerCallback(NimbleBluetooth *ble) : ble(ble) {}
-
-  private:
-    NimbleBluetooth *ble;
-
-    void onConnect(BLEServer *pServer, struct ble_gap_conn_desc *desc)
+#ifdef NIMBLE_TWO
+    virtual void onConnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo) override
    {
-        BLEAddress peer_addr(desc->peer_id_addr);
-        LOG_INFO("BLE incoming connection %s", peer_addr.toString().c_str());
+        LOG_INFO("BLE incoming connection %s", connInfo.getAddress().toString().c_str());

-        const uint16_t connHandle = desc->conn_handle;
+        const uint16_t connHandle = connInfo.getConnHandle();
+#if NIMBLE_ENABLE_2M_PHY && (defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6))
+        int phyResult =
+            ble_gap_set_prefered_le_phy(connHandle, BLE_GAP_LE_PHY_2M_MASK, BLE_GAP_LE_PHY_2M_MASK, BLE_GAP_LE_PHY_CODED_ANY);
+        if (phyResult == 0) {
+            LOG_INFO("BLE conn %u requested 2M PHY", connHandle);
+        } else {
+            LOG_WARN("Failed to prefer 2M PHY for conn %u, rc=%d", connHandle, phyResult);
+        }
+#endif

-        // With Google Pixel 8 Android devices, this causes ESP32 device crash
-        // when phone reconnects. Disable this to make progress on the
-        // Arduino v3 migration while we investigate the Android compatibility
-        // issue.
-#if 0
        int dataLenResult = ble_gap_set_data_len(connHandle, kPreferredBleTxOctets, kPreferredBleTxTimeUs);
        if (dataLenResult == 0) {
            LOG_INFO("BLE conn %u requested data length %u bytes", connHandle, kPreferredBleTxOctets);
        } else {
            LOG_WARN("Failed to raise data length for conn %u, rc=%d", connHandle, dataLenResult);
        }
-#endif

-        LOG_INFO("BLE conn %u peer MTU %u (target %u)", connHandle, pServer->getPeerMTU(connHandle), kPreferredBleMtu);
+        LOG_INFO("BLE conn %u initial MTU %u (target %u)", connHandle, connInfo.getMTU(), kPreferredBleMtu);
        pServer->updateConnParams(connHandle, 6, 12, 0, 200);
    }
+#endif

-    void onDisconnect(BLEServer *pServer, struct ble_gap_conn_desc *desc)
+#ifdef NIMBLE_TWO
+    virtual void onDisconnect(NimBLEServer *pServer, NimBLEConnInfo &connInfo, int reason) override
    {
-        LOG_INFO("BLE disconnected");
+        LOG_INFO("BLE disconnect reason: %d", reason);
+#else
+    virtual void onDisconnect(NimBLEServer *pServer, ble_gap_conn_desc *desc) override
+    {
+        LOG_INFO("BLE disconnect");
+#endif
+#ifdef NIMBLE_TWO
        if (ble->isDeInit)
            return;
+#else
+        if (nimbleBluetooth && nimbleBluetooth->isDeInit)
+            return;
+#endif

        meshtastic::BluetoothStatus newStatus(meshtastic::BluetoothStatus::ConnectionState::DISCONNECTED);
        bluetoothStatus->updateStatus(&newStatus);
@@ -669,51 +722,43 @@ class NimbleBluetoothServerCallback : public BLEServerCallbacks
            bluetoothPhoneAPI->writeCount = 0;
        }

+        // Clear the last ToRadio packet buffer to avoid rejecting first packet from new connection
        memset(lastToRadio, 0, sizeof(lastToRadio));

-        nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE;
+        nimbleBluetoothConnHandle = BLE_HS_CONN_HANDLE_NONE; // BLE_HS_CONN_HANDLE_NONE means "no connection"

+#ifdef NIMBLE_TWO
+        // Restart Advertising
        ble->startAdvertising();
+#else
+        NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+        if (!pAdvertising->start(0)) {
+            if (pAdvertising->isAdvertising()) {
+                LOG_DEBUG("BLE advertising already running");
+            } else {
+                LOG_ERROR("BLE failed to restart advertising");
+            }
+        }
+#endif
    }
 };

 static NimbleBluetoothToRadioCallback *toRadioCallbacks;
 static NimbleBluetoothFromRadioCallback *fromRadioCallbacks;

-void NimbleBluetooth::startAdvertising()
-{
-    BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
-    pAdvertising->stop();
-    pAdvertising->reset();
-
-    pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
-    // if (powerStatus->getHasBattery() == 1) {
-    //     pAdvertising->addServiceUUID(BLEUUID((uint16_t)0x180f));
-    // }
-
-    BLEAdvertisementData scan = BLEAdvertisementData();
-    scan.setName(getDeviceName());
-    pAdvertising->setScanResponseData(scan);
-    pAdvertising->setMinPreferred(0x06); // functions that help with iPhone connections issue
-    pAdvertising->setMaxPreferred(0x12);
-
-    if (!pAdvertising->start(0)) {
-        LOG_ERROR("BLE failed to start advertising");
-    } else {
-        LOG_DEBUG("BLE Advertising started");
-    }
-}
-
 void NimbleBluetooth::shutdown()
 {
+    // No measurable power saving for ESP32 during light-sleep(?)
 #ifndef ARCH_ESP32
+    // Shutdown bluetooth for minimum power draw
    LOG_INFO("Disable bluetooth");
-    BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();
+    NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
    pAdvertising->reset();
    pAdvertising->stop();
 #endif
 }

+// Proper shutdown for ESP32. Needs reboot to reverse.
 void NimbleBluetooth::deinit()
 {
 #ifdef ARCH_ESP32
@@ -723,19 +768,21 @@ void NimbleBluetooth::deinit()
 #ifdef BLE_LED
    digitalWrite(BLE_LED, LED_STATE_OFF);
 #endif
-
-    BLEDevice::deinit(true);
+#ifndef NIMBLE_TWO
+    NimBLEDevice::deinit();
+#endif
 #endif
 }

+// Has initial setup been completed
 bool NimbleBluetooth::isActive()
 {
-    return bleServer != nullptr;
+    return bleServer;
 }

 bool NimbleBluetooth::isConnected()
 {
-    return bleServer && bleServer->getConnectedCount() > 0;
+    return bleServer->getConnectedCount() > 0;
 }

 int NimbleBluetooth::getRssi()
@@ -748,9 +795,9 @@ int NimbleBluetooth::getRssi()
    uint16_t connHandle = nimbleBluetoothConnHandle.load();

    if (connHandle == BLE_HS_CONN_HANDLE_NONE) {
-        const auto peers = bleServer->getPeerDevices(true);
+        const auto peers = bleServer->getPeerDevices();
        if (!peers.empty()) {
-            connHandle = peers.begin()->first;
+            connHandle = peers.front();
            nimbleBluetoothConnHandle = connHandle;
        }
    }
@@ -778,84 +825,74 @@ void NimbleBluetooth::setup()

    LOG_INFO("Init the NimBLE bluetooth module");

-    BLEDevice::init(getDeviceName());
-    BLEDevice::setPower(ESP_PWR_LVL_P9);
+    NimBLEDevice::init(getDeviceName());
+    NimBLEDevice::setPower(ESP_PWR_LVL_P9);

-    int mtuResult = BLEDevice::setMTU(kPreferredBleMtu);
+#if NIMBLE_ENABLE_2M_PHY && (defined(CONFIG_IDF_TARGET_ESP32S3) || defined(CONFIG_IDF_TARGET_ESP32C6))
+    int mtuResult = NimBLEDevice::setMTU(kPreferredBleMtu);
    if (mtuResult == 0) {
        LOG_INFO("BLE MTU request set to %u", kPreferredBleMtu);
    } else {
        LOG_WARN("Unable to request MTU %u, rc=%d", kPreferredBleMtu, mtuResult);
    }

-    BLESecurity *pSecurity = new BLESecurity();
-    pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
-    pSecurity->setRespEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
-    if (config.bluetooth.mode != meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
-        // Set IO capability to DisplayOnly for MITM authentication
-        pSecurity->setCapability(ESP_IO_CAP_OUT);
-        // Set the passkey
-        if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_RANDOM_PIN) {
-            LOG_INFO("Use random passkey");
-            pSecurity->setPassKey(false); // generate a random passkey
-        } else {
-            LOG_INFO("Use fixed passkey");
-            pSecurity->setPassKey(true, config.bluetooth.fixed_pin);
-        }
-        // Enable authorization requirements:
-        // - bonding: true (for persistent storage of the keys)
-        // - MITM: true (enables Man-In-The-Middle protection for password prompts)
-        // - secure connection: true (enables secure connection for encryption)
-        pSecurity->setAuthenticationMode(true, true, true);
+    int phyResult = ble_gap_set_prefered_default_le_phy(BLE_GAP_LE_PHY_2M_MASK, BLE_GAP_LE_PHY_2M_MASK);
+    if (phyResult == 0) {
+        LOG_INFO("BLE default PHY preference set to 2M");
    } else {
-        // No IO capability for no PIN mode
-        pSecurity->setCapability(ESP_IO_CAP_NONE);
-        // No PIN mode: no MITM protection
-        pSecurity->setAuthenticationMode(true, false, false);
-    }
-    // Set the security callbacks
-    BLEDevice::setSecurityCallbacks(new NimbleBluetoothSecurityCallback());
-    bleServer = BLEDevice::createServer();
-
-    // BLEDevice::createServer calls ble_svc_gap_init, which resets the device
-    // name to default, so set it again.
-    int nameRc = ble_svc_gap_device_name_set(BLEDevice::getDeviceName().c_str());
-    if (nameRc != 0) {
-        LOG_ERROR("ble_svc_gap_device_name_set: rc=%d %s", nameRc, BLEUtils::returnCodeToString(nameRc));
+        LOG_WARN("Failed to prefer 2M PHY by default, rc=%d", phyResult);
    }

-    bleServer->setCallbacks(new NimbleBluetoothServerCallback(this));
+    int dataLenResult = ble_gap_write_sugg_def_data_len(kPreferredBleTxOctets, kPreferredBleTxTimeUs);
+    if (dataLenResult == 0) {
+        LOG_INFO("BLE suggested data length set to %u bytes", kPreferredBleTxOctets);
+    } else {
+        LOG_WARN("Failed to raise suggested data length (%u/%u), rc=%d", kPreferredBleTxOctets, kPreferredBleTxTimeUs,
+                 dataLenResult);
+    }
+#endif
+
+    if (config.bluetooth.mode != meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
+        NimBLEDevice::setSecurityAuth(BLE_SM_PAIR_AUTHREQ_BOND | BLE_SM_PAIR_AUTHREQ_MITM | BLE_SM_PAIR_AUTHREQ_SC);
+        NimBLEDevice::setSecurityInitKey(BLE_SM_PAIR_KEY_DIST_ENC | BLE_SM_PAIR_KEY_DIST_ID);
+        NimBLEDevice::setSecurityRespKey(BLE_SM_PAIR_KEY_DIST_ENC | BLE_SM_PAIR_KEY_DIST_ID);
+        NimBLEDevice::setSecurityIOCap(BLE_HS_IO_DISPLAY_ONLY);
+    }
+    bleServer = NimBLEDevice::createServer();
+#ifdef NIMBLE_TWO
+    NimbleBluetoothServerCallback *serverCallbacks = new NimbleBluetoothServerCallback(this);
+#else
+    NimbleBluetoothServerCallback *serverCallbacks = new NimbleBluetoothServerCallback();
+#endif
+    bleServer->setCallbacks(serverCallbacks, true);
    setupService();
    startAdvertising();
 }

 void NimbleBluetooth::setupService()
 {
-    BLEService *bleService = bleServer->createService(MESH_SERVICE_UUID);
-    BLECharacteristic *ToRadioCharacteristic;
-    BLECharacteristic *FromRadioCharacteristic;
+    NimBLEService *bleService = bleServer->createService(MESH_SERVICE_UUID);
+    NimBLECharacteristic *ToRadioCharacteristic;
+    NimBLECharacteristic *FromRadioCharacteristic;
    // Define the characteristics that the app is looking for
    if (config.bluetooth.mode == meshtastic_Config_BluetoothConfig_PairingMode_NO_PIN) {
-        ToRadioCharacteristic = bleService->createCharacteristic(TORADIO_UUID, BLECharacteristic::PROPERTY_WRITE);
+        ToRadioCharacteristic = bleService->createCharacteristic(TORADIO_UUID, NIMBLE_PROPERTY::WRITE);
        // Allow notifications so phones can stream FromRadio without polling.
-        FromRadioCharacteristic = bleService->createCharacteristic(FROMRADIO_UUID, BLECharacteristic::PROPERTY_READ);
-        fromNumCharacteristic =
-            bleService->createCharacteristic(FROMNUM_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ);
-        logRadioCharacteristic = bleService->createCharacteristic(LOGRADIO_UUID, BLECharacteristic::PROPERTY_NOTIFY |
-                                                                                     BLECharacteristic::PROPERTY_READ);
+        FromRadioCharacteristic = bleService->createCharacteristic(FROMRADIO_UUID, NIMBLE_PROPERTY::READ);
+        fromNumCharacteristic = bleService->createCharacteristic(FROMNUM_UUID, NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ);
+        logRadioCharacteristic =
+            bleService->createCharacteristic(LOGRADIO_UUID, NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ, 512U);
    } else {
-        ToRadioCharacteristic = bleService->createCharacteristic(TORADIO_UUID, BLECharacteristic::PROPERTY_WRITE |
-                                                                                   BLECharacteristic::PROPERTY_WRITE_AUTHEN |
-                                                                                   BLECharacteristic::PROPERTY_WRITE_ENC);
-        FromRadioCharacteristic = bleService->createCharacteristic(FROMRADIO_UUID, BLECharacteristic::PROPERTY_READ |
-                                                                                       BLECharacteristic::PROPERTY_READ_AUTHEN |
-                                                                                       BLECharacteristic::PROPERTY_READ_ENC);
-        fromNumCharacteristic = bleService->createCharacteristic(
-            FROMNUM_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ |
-                              BLECharacteristic::PROPERTY_READ_AUTHEN | BLECharacteristic::PROPERTY_READ_ENC);
+        ToRadioCharacteristic = bleService->createCharacteristic(
+            TORADIO_UUID, NIMBLE_PROPERTY::WRITE | NIMBLE_PROPERTY::WRITE_AUTHEN | NIMBLE_PROPERTY::WRITE_ENC);
+        FromRadioCharacteristic = bleService->createCharacteristic(
+            FROMRADIO_UUID, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC);
+        fromNumCharacteristic =
+            bleService->createCharacteristic(FROMNUM_UUID, NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ |
+                                                               NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC);
        logRadioCharacteristic = bleService->createCharacteristic(
-            LOGRADIO_UUID, BLECharacteristic::PROPERTY_NOTIFY | BLECharacteristic::PROPERTY_READ |
-                               BLECharacteristic::PROPERTY_READ_AUTHEN | BLECharacteristic::PROPERTY_READ_ENC);
+            LOGRADIO_UUID,
+            NIMBLE_PROPERTY::NOTIFY | NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::READ_AUTHEN | NIMBLE_PROPERTY::READ_ENC, 512U);
    }
    bluetoothPhoneAPI = new BluetoothPhoneAPI();

@@ -868,31 +905,76 @@ void NimbleBluetooth::setupService()
    bleService->start();

    // Setup the battery service
-    BLEService *batteryService = bleServer->createService(BLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
-    BLE2904 *batteryLevelDescriptor = new BLE2904();
-    batteryLevelDescriptor->setFormat(BLE2904::FORMAT_UINT8);
+    NimBLEService *batteryService = bleServer->createService(NimBLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
+    BatteryCharacteristic = batteryService->createCharacteristic( // 0x2A19 is the Battery Level characteristic)
+        (uint16_t)0x2a19, NIMBLE_PROPERTY::READ | NIMBLE_PROPERTY::NOTIFY, 1);
+#ifdef NIMBLE_TWO
+    NimBLE2904 *batteryLevelDescriptor = BatteryCharacteristic->create2904();
+#else
+    NimBLE2904 *batteryLevelDescriptor = (NimBLE2904 *)BatteryCharacteristic->createDescriptor((uint16_t)0x2904);
+#endif
+    batteryLevelDescriptor->setFormat(NimBLE2904::FORMAT_UINT8);
    batteryLevelDescriptor->setNamespace(1);
    batteryLevelDescriptor->setUnit(0x27ad);
-    BatteryCharacteristic = batteryService->createCharacteristic( // 0x2A19 is the Battery Level characteristic)
-        (uint16_t)0x2a19, BLECharacteristic::PROPERTY_READ | BLECharacteristic::PROPERTY_NOTIFY);
-    BatteryCharacteristic->addDescriptor(batteryLevelDescriptor);
+
    batteryService->start();
 }

+void NimbleBluetooth::startAdvertising()
+{
+#ifdef NIMBLE_TWO
+    NimBLEExtAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+    NimBLEExtAdvertisement legacyAdvertising;
+
+    legacyAdvertising.setLegacyAdvertising(true);
+    legacyAdvertising.setScannable(true);
+    legacyAdvertising.setConnectable(true);
+    legacyAdvertising.setFlags(BLE_HS_ADV_F_DISC_GEN);
+    if (powerStatus->getHasBattery() == 1) {
+        legacyAdvertising.setCompleteServices(NimBLEUUID((uint16_t)0x180f));
+    }
+    legacyAdvertising.setCompleteServices(NimBLEUUID(MESH_SERVICE_UUID));
+    legacyAdvertising.setMinInterval(500);
+    legacyAdvertising.setMaxInterval(1000);
+
+    NimBLEExtAdvertisement legacyScanResponse;
+    legacyScanResponse.setLegacyAdvertising(true);
+    legacyScanResponse.setConnectable(true);
+    legacyScanResponse.setName(getDeviceName());
+
+    if (!pAdvertising->setInstanceData(0, legacyAdvertising)) {
+        LOG_ERROR("BLE failed to set legacyAdvertising");
+    } else if (!pAdvertising->setScanResponseData(0, legacyScanResponse)) {
+        LOG_ERROR("BLE failed to set legacyScanResponse");
+    } else if (!pAdvertising->start(0, 0, 0)) {
+        LOG_ERROR("BLE failed to start legacyAdvertising");
+    }
+#else
+    NimBLEAdvertising *pAdvertising = NimBLEDevice::getAdvertising();
+    pAdvertising->reset();
+    pAdvertising->addServiceUUID(MESH_SERVICE_UUID);
+    pAdvertising->addServiceUUID(NimBLEUUID((uint16_t)0x180f)); // 0x180F is the Battery Service
+    pAdvertising->start(0);
+#endif
+}
+
 /// Given a level between 0-100, update the BLE attribute
 void updateBatteryLevel(uint8_t level)
 {
-    if ((config.bluetooth.enabled == true) && bleServer && bluetoothApi && bluetoothApi->isConnected()) {
+    if ((config.bluetooth.enabled == true) && bleServer && nimbleBluetooth->isConnected()) {
        BatteryCharacteristic->setValue(&level, 1);
+#ifdef NIMBLE_TWO
+        BatteryCharacteristic->notify(&level, 1, BLE_HS_CONN_HANDLE_NONE);
+#else
        BatteryCharacteristic->notify();
+#endif
    }
 }

 void NimbleBluetooth::clearBonds()
 {
    LOG_INFO("Clearing bluetooth bonds!");
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_PEER_SEC, nullptr);
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_CCCD, nullptr);
+    NimBLEDevice::deleteAllBonds();
 }

 void NimbleBluetooth::sendLog(const uint8_t *logMessage, size_t length)
@@ -900,26 +982,11 @@ void NimbleBluetooth::sendLog(const uint8_t *logMessage, size_t length)
    if (!bleServer || !isConnected() || length > 512) {
        return;
    }
-    logRadioCharacteristic->setValue(logMessage, length);
-    logRadioCharacteristic->notify();
-}
-
-void clearNVS()
-{
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_PEER_SEC, nullptr);
-    ble_store_util_delete_all(BLE_STORE_OBJ_TYPE_CCCD, nullptr);
-#ifdef ARCH_ESP32
-    ESP.restart();
-#endif
-}
-
+#ifdef NIMBLE_TWO
+    logRadioCharacteristic->notify(logMessage, length, BLE_HS_CONN_HANDLE_NONE);
 #else
-
-void updateBatteryLevel(uint8_t level)
-{
-    (void)level;
+    logRadioCharacteristic->notify(logMessage, length, true);
+#endif
 }

-void clearNVS() {}
-
 #endif
@@ -1,24 +1,27 @@
 #pragma once
 #include "BluetoothCommon.h"

-class NimbleBluetooth : public BluetoothApi
+class NimbleBluetooth : BluetoothApi
 {
  public:
-    void setup() override;
-    void shutdown() override;
-    void deinit() override;
-    void clearBonds() override;
-    bool isActive() override;
-    bool isConnected() override;
-    int getRssi() override;
-    void sendLog(const uint8_t *logMessage, size_t length) override;
+    void setup();
+    void shutdown();
+    void deinit();
+    void clearBonds();
+    bool isActive();
+    bool isConnected();
+    int getRssi();
+    void sendLog(const uint8_t *logMessage, size_t length);
+#if defined(NIMBLE_TWO)
    void startAdvertising();
-    virtual ~NimbleBluetooth() {}
-
+#endif
    bool isDeInit = false;

  private:
    void setupService();
+#if !defined(NIMBLE_TWO)
+    void startAdvertising();
+#endif
 };

 void setBluetoothEnable(bool enable);
@@ -1,42 +0,0 @@
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "esp_attr.h"
-
-#ifdef ESP32_FORCE_IRAM_MEMSET
-
-/*
- * T-Beam/classic ESP32 boot workaround
- * ------------------------------------
- * During early flash operations the ESP32 disables cache, but some IRAM flash
- * code paths still reach libc memcpy/memset. If those resolve to flash-resident
- * implementations, startup can panic with cache-disabled access errors.
- *
- * We wrap memcpy/memset for the T-Beam environment. Fast path uses the
- * normal libc routines when cache is enabled; slow path uses IRAM-safe byte
- * loops when cache is disabled.
- */
-
-extern void *__real_memcpy(void *dst, const void *src, size_t n);
-
-static inline bool IRAM_ATTR cache_is_enabled(void)
-{
-    return (*(volatile uint32_t *)0x3FF00040u) & (1u << 3);
-}
-
-extern void *IRAM_ATTR __wrap_memcpy(void *dst, const void *src, size_t n)
-{
-    if (cache_is_enabled()) {
-        return __real_memcpy(dst, src, n);
-    }
-
-    uint8_t *d = (uint8_t *)dst;
-    const uint8_t *s = (const uint8_t *)src;
-    while (n--) {
-        *d++ = *s++;
-    }
-    return dst;
-}
-
-#endif
@@ -1,42 +0,0 @@
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "esp_attr.h"
-
-#ifdef ESP32_FORCE_IRAM_MEMSET
-
-/*
- * T-Beam/classic ESP32 boot workaround
- * ------------------------------------
- * During early flash operations the ESP32 disables cache, but some IRAM flash
- * code paths still reach libc memcpy/memset. If those resolve to flash-resident
- * implementations, startup can panic with cache-disabled access errors.
- *
- * We wrap memcpy/memset for the T-Beam environment. Fast path uses the
- * normal libc routines when cache is enabled; slow path uses IRAM-safe byte
- * loops when cache is disabled.
- */
-
-extern void *__real_memset(void *dst, int c, size_t n);
-
-static inline bool IRAM_ATTR cache_is_enabled(void)
-{
-    return (*(volatile uint32_t *)0x3FF00040u) & (1u << 3);
-}
-
-extern void *IRAM_ATTR __wrap_memset(void *dst, int c, size_t n)
-{
-    if (cache_is_enabled()) {
-        return __real_memset(dst, c, n);
-    }
-
-    uint8_t *ptr = (uint8_t *)dst;
-    const uint8_t fill = (uint8_t)c;
-    while (n--) {
-        *ptr++ = fill;
-    }
-    return dst;
-}
-
-#endif
@@ -1,11 +0,0 @@
-/* Arduino fix: catch esp_event's orphaned .text.handler_execute section and align to 4 bytes */
-SECTIONS
-{
-  .text.handler_execute ALIGN(4) :
-  {
-    KEEP(*(.text.handler_execute))
-    KEEP(*(.text.handler_execute.*))
-    . = ALIGN(4);
-  }
-}
-INSERT AFTER .flash.text;
@@ -4,13 +4,9 @@
 #include "esp_task_wdt.h"
 #include "main.h"

-#if !MESHTASTIC_EXCLUDE_BLUETOOTH
-#if defined(CONFIG_IDF_TARGET_ESP32P4)
-#include "bluetooth/HostedBluetooth.h"
-#elif !defined(CONFIG_IDF_TARGET_ESP32S2)
+#if !defined(CONFIG_IDF_TARGET_ESP32S2) && !MESHTASTIC_EXCLUDE_BLUETOOTH
 #include "nimble/NimbleBluetooth.h"
 #endif
-#endif

 #include <MeshtasticOTA.h>

@@ -44,30 +40,16 @@ void setBluetoothEnable(bool enable)
    if (config.bluetooth.enabled == true)
 #endif
    {
-#if defined(CONFIG_IDF_TARGET_ESP32P4)
-        if (!enable) {
-            if (bluetoothApi && bluetoothApi->isActive()) {
-                bluetoothApi->shutdown();
-                powerMon->clearState(meshtastic_PowerMon_State_BT_On);
-            }
-            return;
+        if (!nimbleBluetooth) {
+            nimbleBluetooth = new NimbleBluetooth();
        }
-#endif
-
-        if (!bluetoothApi) {
-#if defined(CONFIG_IDF_TARGET_ESP32P4)
-            bluetoothApi = new HostedBluetooth();
-#else
-            bluetoothApi = new NimbleBluetooth();
-#endif
-        }
-        if (enable && !bluetoothApi->isActive()) {
+        if (enable && !nimbleBluetooth->isActive()) {
            powerMon->setState(meshtastic_PowerMon_State_BT_On);
-            bluetoothApi->setup();
+            nimbleBluetooth->setup();
        }
        // For ESP32, no way to recover from bluetooth shutdown without reboot
        // BLE advertising automatically stops when MCU enters light-sleep(?)
-        // For deep-sleep, shutdown hardware with bluetoothApi->deinit(). Requires reboot to reverse
+        // For deep-sleep, shutdown hardware with nimbleBluetooth->deinit(). Requires reboot to reverse
    }
 }
 #else
@@ -183,30 +165,17 @@ void esp32Setup()
 // #define APP_WATCHDOG_SECS 45
 #define APP_WATCHDOG_SECS 90

-#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
-    const esp_task_wdt_config_t wdt_config = {
-        .timeout_ms = APP_WATCHDOG_SECS * 1000,
-        .idle_core_mask = (1U << CONFIG_FREERTOS_NUMBER_OF_CORES) - 1U,
-        .trigger_panic = true,
-    };
-    res = esp_task_wdt_init(&wdt_config);
-    if (res == ESP_ERR_INVALID_STATE) {
-        LOG_WARN("Task watchdog already initialized, reconfiguring existing instance");
-        res = esp_task_wdt_reconfigure(&wdt_config);
-    }
+#ifdef CONFIG_IDF_TARGET_ESP32C6
+    esp_task_wdt_config_t *wdt_config = (esp_task_wdt_config_t *)malloc(sizeof(esp_task_wdt_config_t));
+    wdt_config->timeout_ms = APP_WATCHDOG_SECS * 1000;
+    wdt_config->trigger_panic = true;
+    res = esp_task_wdt_init(wdt_config);
    assert(res == ESP_OK);
 #else
    res = esp_task_wdt_init(APP_WATCHDOG_SECS, true);
-    if (res == ESP_ERR_INVALID_STATE) {
-        LOG_WARN("Task watchdog already initialized, reusing existing instance");
-        res = ESP_OK;
-    }
    assert(res == ESP_OK);
 #endif
-    res = esp_task_wdt_status(NULL);
-    if (res == ESP_ERR_NOT_FOUND) {
-        res = esp_task_wdt_add(NULL);
-    }
+    res = esp_task_wdt_add(NULL);
    assert(res == ESP_OK);

 #if HAS_32768HZ
@@ -289,10 +258,8 @@ void cpuDeepSleep(uint32_t msecToWake)
 #endif
    variant_shutdown();

-#if SOC_PM_SUPPORT_RTC_PERIPH_PD
    // We want RTC peripherals to stay on
    esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
-#endif

    esp_sleep_enable_timer_wakeup(msecToWake * 1000ULL); // call expects usecs
    esp_deep_sleep_start();                              // TBD mA sleep current (battery)
@@ -598,7 +598,8 @@ void portduinoSetup()
    for (const auto *i : portduino_config.all_pins) {
        // In the case of a ch341 Lora device, we don't want to touch the system GPIO lines for Lora
        // Those GPIO are handled in our usermode driver instead.
-        if (i->config_section == "Lora" && portduino_config.lora_spi_dev == "ch341") {
+        if (i->config_section == "Lora" &&
+            (portduino_config.lora_spi_dev == "ch341" || portduino_config.lora_spi_dev == "serial")) {
            continue;
        }
        if (i->enabled) {
@@ -617,7 +618,8 @@ void portduinoSetup()
    for (auto i : portduino_config.extra_pins) {
        // In the case of a ch341 Lora device, we don't want to touch the system GPIO lines for Lora
        // Those GPIO are handled in our usermode driver instead.
-        if (i.config_section == "Lora" && portduino_config.lora_spi_dev == "ch341") {
+        if (i.config_section == "Lora" &&
+            (portduino_config.lora_spi_dev == "ch341" || portduino_config.lora_spi_dev == "serial")) {
            continue;
        }
        if (i.enabled) {
@@ -664,7 +666,8 @@ void portduinoSetup()
    for (auto i : portduino_config.extra_pins) {
        // In the case of a ch341 Lora device, we don't want to touch the system GPIO lines for Lora
        // Those GPIO are handled in our usermode driver instead.
-        if (i.config_section == "Lora" && portduino_config.lora_spi_dev == "ch341") {
+        if (i.config_section == "Lora" &&
+            (portduino_config.lora_spi_dev == "ch341" || portduino_config.lora_spi_dev == "serial")) {
            continue;
        }
        if (i.enabled && i.default_high) {
@@ -674,7 +677,8 @@ void portduinoSetup()
    }

    // Only initialize the radio pins when dealing with real, kernel controlled SPI hardware
-    if (portduino_config.lora_spi_dev != "" && portduino_config.lora_spi_dev != "ch341") {
+    if (portduino_config.lora_spi_dev != "" && portduino_config.lora_spi_dev != "ch341" &&
+        portduino_config.lora_spi_dev != "serial") {
        SPI.begin(portduino_config.lora_spi_dev.c_str());
    }

@@ -708,6 +712,7 @@ void portduinoSetup()
    }
    if (portduino_config.lora_spi_dev != "") {
        portduinoSetOptions({.realHardware = true});
+        LOG_DEBUG("Running with real hardware SPI device %s", portduino_config.lora_spi_dev.c_str());
    }
    return;
 }
@@ -844,12 +849,15 @@ bool loadConfig(const char *configPath)
            }

            portduino_config.spiSpeed = yamlConfig["Lora"]["spiSpeed"].as<int>(2000000);
+            portduino_config.lora_serial_device = yamlConfig["Lora"]["SerialDevice"].as<std::string>("");
+            portduino_config.lora_serial_baud = yamlConfig["Lora"]["SerialBaud"].as<int>(115200);
+            portduino_config.lora_serial_timeout_ms = yamlConfig["Lora"]["SerialTimeoutMs"].as<int>(500);
            portduino_config.lora_usb_serial_num = yamlConfig["Lora"]["USB_Serialnum"].as<std::string>("");
            portduino_config.lora_usb_pid = yamlConfig["Lora"]["USB_PID"].as<int>(0x5512);
            portduino_config.lora_usb_vid = yamlConfig["Lora"]["USB_VID"].as<int>(0x1A86);

            portduino_config.lora_spi_dev = yamlConfig["Lora"]["spidev"].as<std::string>("spidev0.0");
-            if (portduino_config.lora_spi_dev != "ch341") {
+            if (portduino_config.lora_spi_dev != "ch341" && portduino_config.lora_spi_dev != "serial") {
                portduino_config.lora_spi_dev = "/dev/" + portduino_config.lora_spi_dev;
                if (portduino_config.lora_spi_dev.length() == 14) {
                    int x = portduino_config.lora_spi_dev.at(11) - '0';
@@ -86,6 +86,9 @@ extern struct portduino_config_struct {
    bool has_device_id = false;
    uint8_t device_id[16] = {0};
    std::string lora_spi_dev = "";
+    std::string lora_serial_device = "";
+    int lora_serial_baud = 115200;
+    int lora_serial_timeout_ms = 500;
    std::string lora_usb_serial_num = "";
    int lora_spi_dev_int = 0;
    int lora_default_gpiochip = 0;
@@ -276,6 +279,12 @@ extern struct portduino_config_struct {
        }
        if (lora_usb_serial_num != "")
            out << YAML::Key << "USB_Serialnum" << YAML::Value << lora_usb_serial_num;
+        if (lora_serial_device != "")
+            out << YAML::Key << "SerialDevice" << YAML::Value << lora_serial_device;
+        if (lora_serial_baud != 115200)
+            out << YAML::Key << "SerialBaud" << YAML::Value << lora_serial_baud;
+        if (lora_serial_timeout_ms != 500)
+            out << YAML::Key << "SerialTimeoutMs" << YAML::Value << lora_serial_timeout_ms;
        if (spiSpeed != 2000000)
            out << YAML::Key << "spiSpeed" << YAML::Value << spiSpeed;
        if (rfswitch_dio_pins[0] != RADIOLIB_NC) {
@@ -0,0 +1,595 @@
+#include "platform/portduino/SerialHal.h"
+
+#include "mesh/mesh-pb-constants.h"
+#include "platform/portduino/PortduinoGlue.h"
+#include <cerrno>
+#include <chrono>
+#include <cstring>
+#include <fcntl.h>
+#include <poll.h>
+#include <sched.h>
+#include <sys/time.h>
+#include <termios.h>
+#include <unistd.h>
+#include <utility>
+
+namespace
+{
+constexpr uint8_t START1 = 0x94;
+constexpr uint8_t SERIALHAL_MAGIC = 0xA5;
+constexpr size_t HEADER_SIZE = 4; // START1 + SERIALHAL_MAGIC + LEN_H + LEN_L
+constexpr uint8_t START2 = 0xC3;  // second byte of a normal FromRadio frame
+
+speed_t toTermiosBaud(uint32_t baud)
+{
+    switch (baud) {
+    case 9600:
+        return B9600;
+    case 19200:
+        return B19200;
+    case 38400:
+        return B38400;
+    case 57600:
+        return B57600;
+    case 115200:
+        return B115200;
+    case 230400:
+        return B230400;
+    case 460800:
+        return B460800;
+    case 921600:
+        return B921600;
+    default:
+        return B115200;
+    }
+}
+} // namespace
+
+SerialHal::SerialHal(const std::string &devicePath, uint32_t baudRate, uint32_t opTimeoutMs)
+    : RadioLibHal(SERIAL_PI_INPUT, SERIAL_PI_OUTPUT, SERIAL_PI_LOW, SERIAL_PI_HIGH, SERIAL_PI_RISING, SERIAL_PI_FALLING),
+      device(devicePath), baud(baudRate), timeoutMs(opTimeoutMs)
+{
+    if (!openPort()) {
+        setTransportError("unable to open serial device");
+    }
+}
+
+SerialHal::~SerialHal()
+{
+    closePort();
+}
+
+bool SerialHal::openPort()
+{
+    closePort();
+    fd = ::open(device.c_str(), O_RDWR | O_NOCTTY | O_SYNC);
+    if (fd < 0) {
+        return false;
+    }
+
+    termios tty = {};
+    if (tcgetattr(fd, &tty) != 0) {
+        closePort();
+        return false;
+    }
+
+    cfsetospeed(&tty, toTermiosBaud(baud));
+    cfsetispeed(&tty, toTermiosBaud(baud));
+
+    tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8;
+    tty.c_iflag &= ~(IGNBRK | IXON | IXOFF | IXANY);
+    tty.c_lflag = 0;
+    tty.c_oflag = 0;
+    tty.c_cc[VMIN] = 0;
+    tty.c_cc[VTIME] = 0;
+    tty.c_cflag |= (CLOCAL | CREAD);
+    tty.c_cflag &= ~(PARENB | PARODD);
+    tty.c_cflag &= ~CSTOPB;
+    tty.c_cflag &= ~CRTSCTS;
+
+    if (tcsetattr(fd, TCSANOW, &tty) != 0) {
+        closePort();
+        return false;
+    }
+
+    tcflush(fd, TCIOFLUSH);
+    inError = false;
+    startReaderThread();
+    return true;
+}
+
+void SerialHal::closePort()
+{
+    stopReaderThread();
+    if (fd >= 0) {
+        ::close(fd);
+        fd = -1;
+    }
+}
+
+void SerialHal::setTransportError(const char *msg)
+{
+    if (!inError.load() || !hasWarned) {
+        LOG_ERROR("SerialHal: %s (%s)", msg, device.c_str());
+    }
+    inError = true;
+    hasWarned = true;
+    portduino_status.LoRa_in_error = true;
+}
+
+bool SerialHal::waitForReadable(int timeout)
+{
+    if (fd < 0) {
+        return false;
+    }
+    pollfd pfd = {};
+    pfd.fd = fd;
+    pfd.events = POLLIN;
+    int ret = poll(&pfd, 1, timeout);
+    return ret > 0 && (pfd.revents & POLLIN);
+}
+
+bool SerialHal::writeAll(const uint8_t *data, size_t len)
+{
+    size_t off = 0;
+    while (off < len) {
+        ssize_t rc = ::write(fd, data + off, len - off);
+        if (rc < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
+            return false;
+        }
+        off += (size_t)rc;
+    }
+    return true;
+}
+
+bool SerialHal::readExact(uint8_t *data, size_t len)
+{
+    size_t off = 0;
+    auto start = std::chrono::steady_clock::now();
+    while (off < len) {
+        auto now = std::chrono::steady_clock::now();
+        int elapsed = (int)std::chrono::duration_cast<std::chrono::milliseconds>(now - start).count();
+        int remaining = (int)timeoutMs - elapsed;
+        if (remaining <= 0 || !waitForReadable(remaining)) {
+            return false;
+        }
+        ssize_t rc = ::read(fd, data + off, len - off);
+        if (rc < 0) {
+            if (errno == EINTR) {
+                continue;
+            }
+            return false;
+        }
+        if (rc == 0) {
+            return false;
+        }
+        off += (size_t)rc;
+    }
+    return true;
+}
+
+uint16_t SerialHal::crc16(const uint8_t *data, size_t len) const
+{
+    uint16_t crc = 0xFFFF;
+    for (size_t i = 0; i < len; ++i) {
+        crc ^= ((uint16_t)data[i] << 8);
+        for (int bit = 0; bit < 8; ++bit) {
+            if (crc & 0x8000) {
+                crc = (uint16_t)((crc << 1) ^ 0x1021);
+            } else {
+                crc = (uint16_t)(crc << 1);
+            }
+        }
+    }
+    return crc;
+}
+
+bool SerialHal::sendRequest(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse *response)
+{
+    if (fd < 0 && !openPort()) {
+        setTransportError("serial open failed");
+        return false;
+    }
+
+    uint8_t encoded[meshtastic_SerialHalCommand_size] = {0};
+    const size_t payloadLen =
+        pb_encode_to_bytes(encoded, sizeof(encoded), &meshtastic_SerialHalCommand_msg, static_cast<const void *>(&cmd));
+    if (payloadLen == 0 || payloadLen > 0xFFFF) {
+        setTransportError("serial command encode failed");
+        return false;
+    }
+
+    // Build frame with StreamAPI canonical framing: START1 SERIALHAL_MAGIC LEN_H LEN_L [payload]
+    std::vector<uint8_t> frame;
+    frame.resize(HEADER_SIZE + payloadLen);
+
+    frame[0] = START1;
+    frame[1] = SERIALHAL_MAGIC;
+    frame[2] = (uint8_t)((payloadLen >> 8) & 0xFF); // LEN_H (big-endian)
+    frame[3] = (uint8_t)(payloadLen & 0xFF);        // LEN_L
+    memcpy(frame.data() + HEADER_SIZE, encoded, payloadLen);
+
+    {
+        std::lock_guard<std::mutex> writeGuard(writeMutex);
+        if (!writeAll(frame.data(), frame.size())) {
+            setTransportError("serial write failed");
+            return false;
+        }
+    }
+
+    meshtastic_SerialHalResponse got = meshtastic_SerialHalResponse_init_zero;
+    {
+        std::unique_lock<std::mutex> lock(stateMutex);
+        const auto timeout = std::chrono::milliseconds(timeoutMs);
+        const bool arrived = responseCv.wait_for(lock, timeout, [&]() { return pendingResponses.count(cmd.transaction_id) > 0; });
+        if (!arrived) {
+            setTransportError("serial response timeout");
+            LOG_WARN("SerialHal: response timeout for transaction_id %u, cmd type %u", cmd.transaction_id, cmd.type);
+            return false;
+        }
+
+        got = pendingResponses[cmd.transaction_id];
+        pendingResponses.erase(cmd.transaction_id);
+    }
+
+    if (got.result != meshtastic_SerialHalResponse_Result_OK) {
+        setTransportError("serial response reported error");
+        LOG_WARN("SerialHal: response error: %s, %u, %u", got.error, cmd.type, cmd.data.size);
+
+        return false;
+    }
+
+    if (response != nullptr) {
+        *response = got;
+    }
+
+    inError = false;
+    hasWarned = false;
+    return true;
+}
+
+void SerialHal::pinMode(uint32_t pin, uint32_t mode)
+{
+    if (checkError() || pin == RADIOLIB_NC) {
+        return;
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_PIN_MODE;
+    cmd.pin = pin;
+    cmd.mode = mode;
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    sendRequest(cmd, &response);
+}
+
+void SerialHal::digitalWrite(uint32_t pin, uint32_t value)
+{
+    if (checkError() || pin == RADIOLIB_NC) {
+        return;
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_DIGITAL_WRITE;
+    cmd.pin = pin;
+    cmd.value = value;
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    sendRequest(cmd, &response);
+}
+
+uint32_t SerialHal::digitalRead(uint32_t pin)
+{
+    if (checkError() || pin == RADIOLIB_NC) {
+        return 0;
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_DIGITAL_READ;
+    cmd.pin = pin;
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    if (!sendRequest(cmd, &response)) {
+        return 0;
+    }
+    return response.value;
+}
+
+void SerialHal::attachInterrupt(uint32_t interruptNum, void (*interruptCb)(void), uint32_t mode)
+{
+    if (checkError() || interruptNum == RADIOLIB_NC) {
+        return;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(stateMutex);
+        interruptCallbacks[interruptNum] = interruptCb;
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_ATTACH_INTERRUPT;
+    cmd.pin = interruptNum;
+    cmd.mode = mode;
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    sendRequest(cmd, &response);
+}
+
+void SerialHal::detachInterrupt(uint32_t interruptNum)
+{
+    if (checkError() || interruptNum == RADIOLIB_NC) {
+        return;
+    }
+
+    {
+        std::lock_guard<std::mutex> lock(stateMutex);
+        interruptCallbacks.erase(interruptNum);
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_DETACH_INTERRUPT;
+    cmd.pin = interruptNum;
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    sendRequest(cmd, &response);
+}
+
+void SerialHal::delay(unsigned long ms)
+{
+    delayMicroseconds(ms * 1000);
+}
+
+void SerialHal::delayMicroseconds(unsigned long us)
+{
+    if (us == 0) {
+        sched_yield();
+        return;
+    }
+    usleep(us);
+}
+
+void SerialHal::yield()
+{
+    sched_yield();
+}
+
+unsigned long SerialHal::millis()
+{
+    struct timeval tv;
+    gettimeofday(&tv, nullptr);
+    return (tv.tv_sec * 1000ULL) + (tv.tv_usec / 1000ULL);
+}
+
+unsigned long SerialHal::micros()
+{
+    struct timeval tv;
+    gettimeofday(&tv, nullptr);
+    return (tv.tv_sec * 1000000ULL) + tv.tv_usec;
+}
+
+long SerialHal::pulseIn(uint32_t pin, uint32_t state, unsigned long timeout)
+{
+    (void)pin;
+    (void)state;
+    (void)timeout;
+    LOG_WARN("SerialHal pulseIn is not supported");
+    return 0;
+}
+
+void SerialHal::spiTransfer(uint8_t *out, size_t len, uint8_t *in)
+{
+    if (checkError()) {
+        return;
+    }
+
+    if (len == 0) {
+        return;
+    }
+
+    meshtastic_SerialHalCommand cmd = meshtastic_SerialHalCommand_init_zero;
+    cmd.transaction_id = txId.fetch_add(1);
+    cmd.type = meshtastic_SerialHalCommand_Type_SPI_TRANSFER;
+
+    const size_t maxTx = sizeof(cmd.data.bytes);
+    const size_t txLen = len < maxTx ? len : maxTx;
+    cmd.data.size = txLen;
+    if (out != nullptr) {
+        memcpy(cmd.data.bytes, out, txLen);
+    } else {
+        memset(cmd.data.bytes, 0, txLen);
+    }
+
+    meshtastic_SerialHalResponse response = meshtastic_SerialHalResponse_init_zero;
+    if (!sendRequest(cmd, &response)) {
+        return;
+    }
+
+    if (in != nullptr) {
+        size_t copyLen = response.data.size < len ? response.data.size : len;
+        memcpy(in, response.data.bytes, copyLen);
+        if (copyLen < len) {
+            memset(in + copyLen, 0, len - copyLen);
+        }
+    }
+}
+
+bool SerialHal::checkError()
+{
+    if (inError.load()) {
+        if (!hasWarned) {
+            LOG_ERROR("SerialHal in_error detected");
+            hasWarned = true;
+        }
+        portduino_status.LoRa_in_error = true;
+        return true;
+    }
+    hasWarned = false;
+    return false;
+}
+
+bool SerialHal::readFrame(std::vector<uint8_t> &payload, int firstByteTimeoutMs)
+{
+    payload.clear();
+
+    // Loop so that normal FromRadio frames (START1 START2 ...) emitted by the
+    // device on the same serial port are drained and discarded rather than
+    // causing the byte stream to desync.
+    for (;;) {
+        uint8_t hdr[HEADER_SIZE] = {0};
+        for (;;) {
+
+            ssize_t rc = ::read(fd, &hdr[0], 1);
+            if (rc < 0) {
+                if (errno == EINTR) {
+                    continue;
+                }
+                return false;
+            }
+            if (rc == 0) {
+                return false;
+            }
+            if (hdr[0] == START1) {
+                break;
+            }
+        }
+
+        if (!readExact(hdr + 1, HEADER_SIZE - 1)) {
+            return false;
+        }
+
+        const uint16_t len = ((uint16_t)hdr[2] << 8) | (uint16_t)hdr[3];
+
+        if (hdr[1] == SERIALHAL_MAGIC) {
+            // SerialHal response frame — this is what we want.
+            if (len > meshtastic_SerialHalResponse_size) {
+                return false;
+            }
+            payload.resize(len);
+            if (len > 0 && !readExact(payload.data(), len)) {
+                payload.clear();
+                return false;
+            }
+            return true;
+        } else if (hdr[1] == START2) {
+            // Normal FromRadio frame emitted by the device — drain and discard
+            // its payload so we stay in sync, then loop to find a SerialHal frame.
+            if (len > 0) {
+                std::vector<uint8_t> discard(len);
+                if (!readExact(discard.data(), len)) {
+                    return false;
+                }
+            }
+            // continue looping, look for next frame
+        } else {
+            // Unknown second byte after START1 — restart search for framing.
+            continue;
+        }
+    }
+}
+
+void SerialHal::readerLoop()
+{
+    readerRunning = true;
+    while (!readerStopRequested.load()) {
+        if (fd < 0) {
+            break;
+        }
+
+        if (!waitForReadable(100)) {
+            continue;
+        }
+
+        std::vector<uint8_t> payload;
+        if (!readFrame(payload, 40)) {
+            continue;
+        }
+
+        meshtastic_SerialHalResponse resp = meshtastic_SerialHalResponse_init_zero;
+        if (payload.empty() || !pb_decode_from_bytes(payload.data(), payload.size(), &meshtastic_SerialHalResponse_msg, &resp)) {
+            continue;
+        }
+
+        if (resp.transaction_id == 0) {
+            LOG_WARN("SerialHal: received unsolicited interrupt event: pin=%u", resp.value);
+            // transaction_id 0 is reserved for unsolicited interrupt events.
+            // The device reports the triggered pin in resp.value instead of
+            // matching one of the synchronous request/response transactions.
+            {
+                std::lock_guard<std::mutex> lock(stateMutex);
+                if (interruptCallbacks.count(resp.value) > 0) {
+                    pendingInterruptPins.push_back(resp.value);
+                }
+            }
+            interruptCv.notify_one();
+            continue;
+        }
+
+        {
+            std::lock_guard<std::mutex> lock(stateMutex);
+            pendingResponses[resp.transaction_id] = resp;
+        }
+        responseCv.notify_all();
+    }
+    readerRunning = false;
+}
+
+void SerialHal::interruptDispatchLoop()
+{
+    interruptDispatcherRunning = true;
+    while (!readerStopRequested.load()) {
+        uint32_t pin = 0;
+        void (*cb)(void) = nullptr;
+
+        {
+            std::unique_lock<std::mutex> lock(stateMutex);
+            interruptCv.wait(lock, [&]() { return readerStopRequested.load() || !pendingInterruptPins.empty(); });
+            if (readerStopRequested.load()) {
+                break;
+            }
+
+            pin = pendingInterruptPins.front();
+            pendingInterruptPins.pop_front();
+
+            auto it = interruptCallbacks.find(pin);
+            if (it != interruptCallbacks.end()) {
+                cb = it->second;
+            }
+        }
+
+        if (cb != nullptr) {
+            cb();
+        }
+    }
+    interruptDispatcherRunning = false;
+}
+
+void SerialHal::startReaderThread()
+{
+    stopReaderThread();
+    readerStopRequested = false;
+    readerThread = std::thread(&SerialHal::readerLoop, this);
+    interruptThread = std::thread(&SerialHal::interruptDispatchLoop, this);
+}
+
+void SerialHal::stopReaderThread()
+{
+    readerStopRequested = true;
+    interruptCv.notify_all();
+    if (readerThread.joinable()) {
+        readerThread.join();
+    }
+    if (interruptThread.joinable()) {
+        interruptThread.join();
+    }
+
+    std::lock_guard<std::mutex> lock(stateMutex);
+    pendingInterruptPins.clear();
+}
@@ -0,0 +1,99 @@
+#ifndef PI_HAL_SERIAL_H
+#define PI_HAL_SERIAL_H
+
+#include <RadioLib.h>
+#include <atomic>
+#include <condition_variable>
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <mesh/generated/meshtastic/serial_hal.pb.h>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#define SERIAL_PI_INPUT (0)
+#define SERIAL_PI_OUTPUT (1)
+#define SERIAL_PI_LOW (0)
+#define SERIAL_PI_HIGH (1)
+#define SERIAL_PI_RISING (1)
+#define SERIAL_PI_FALLING (2)
+
+class SerialHal : public RadioLibHal
+{
+  public:
+    explicit SerialHal(const std::string &device, uint32_t baud = 115200, uint32_t timeoutMs = 500);
+    ~SerialHal() override;
+
+    void init() override {}
+    void term() override {}
+
+    void pinMode(uint32_t pin, uint32_t mode) override;
+    void digitalWrite(uint32_t pin, uint32_t value) override;
+    uint32_t digitalRead(uint32_t pin) override;
+
+    void attachInterrupt(uint32_t interruptNum, void (*interruptCb)(void), uint32_t mode) override;
+    void detachInterrupt(uint32_t interruptNum) override;
+
+    void delay(unsigned long ms) override;
+    void delayMicroseconds(unsigned long us) override;
+    void yield() override;
+
+    unsigned long millis() override;
+    unsigned long micros() override;
+
+    long pulseIn(uint32_t pin, uint32_t state, unsigned long timeout) override;
+
+    void spiBegin() override {}
+    void spiBeginTransaction() override {}
+    void spiTransfer(uint8_t *out, size_t len, uint8_t *in) override;
+    void spiEndTransaction() override {}
+    void spiEnd() override {}
+
+    bool checkError();
+
+  private:
+    bool openPort();
+    void closePort();
+    bool sendRequest(const meshtastic_SerialHalCommand &cmd, meshtastic_SerialHalResponse *response);
+    bool writeAll(const uint8_t *data, size_t len);
+    bool readExact(uint8_t *data, size_t len);
+    bool waitForReadable(int timeoutMs);
+    bool readFrame(std::vector<uint8_t> &payload, int firstByteTimeoutMs);
+    void readerLoop();
+    void interruptDispatchLoop();
+    void startReaderThread();
+    void stopReaderThread();
+
+    uint16_t crc16(const uint8_t *data, size_t len) const;
+    void setTransportError(const char *msg);
+
+    std::string device;
+    uint32_t baud;
+    uint32_t timeoutMs;
+    int fd = -1;
+    bool hasWarned = false;
+    std::atomic<bool> inError{false};
+    std::atomic<uint16_t> txId{1};
+
+    std::mutex fdMutex;
+    std::mutex writeMutex;
+    std::mutex stateMutex;
+    std::condition_variable responseCv;
+
+    std::thread readerThread;
+    std::thread interruptThread;
+    std::atomic<bool> readerStopRequested{false};
+    std::atomic<bool> readerRunning{false};
+    std::atomic<bool> interruptDispatcherRunning{false};
+
+    std::condition_variable interruptCv;
+    std::deque<uint32_t> pendingInterruptPins;
+
+    std::unordered_map<uint32_t, void (*)(void)> interruptCallbacks;
+    std::unordered_map<uint16_t, meshtastic_SerialHalResponse> pendingResponses;
+};
+
+#endif
@@ -4,10 +4,8 @@
 #include "configuration.h"

 #ifdef ARCH_ESP32
-// #include <driver/adc.h>
-#include <esp_adc/adc_cali.h>
-#include <esp_adc/adc_cali_scheme.h>
-#include <esp_adc/adc_oneshot.h>
+// "legacy adc calibration driver is deprecated, please migrate to use esp_adc/adc_cali.h and esp_adc/adc_cali_scheme.h
+#include <esp_adc_cal.h>
 #include <soc/adc_channel.h>
 #endif

@@ -30,6 +28,11 @@
 #define NUM_CELLS 1
 #endif

+#ifdef BAT_MEASURE_ADC_UNIT
+extern RTC_NOINIT_ATTR uint64_t RTC_reg_b;
+#include "soc/sens_reg.h" // needed for adc pin reset
+#endif
+
 #if HAS_TELEMETRY && !MESHTASTIC_EXCLUDE_ENVIRONMENTAL_SENSOR
 #include "modules/Telemetry/Sensor/nullSensor.h"
 #if __has_include(<Adafruit_INA219.h>)
@@ -18,6 +18,8 @@
 #include "target_specific.h"

 #ifdef ARCH_ESP32
+// "esp_pm_config_esp32_t is deprecated, please include esp_pm.h and use esp_pm_config_t instead"
+#include "esp32/pm.h"
 #include "esp_pm.h"
 #if HAS_WIFI
 #include "mesh/wifi/WiFiAPClient.h"
@@ -144,31 +146,15 @@ void initDeepSleep()
    // If we booted because our timer ran out or the user pressed reset, send those as fake events
    RESET_REASON hwReason = rtc_get_reset_reason(0);

-#ifdef CONFIG_IDF_TARGET_ESP32P4
-    if (hwReason == BROWN_OUT_RESET)
-        reason = "brownout";
-    else if (hwReason == HP_CORE_HP_WDT_RESET)
-        reason = "taskWatchdog";
-    else if (hwReason == HP_CORE_LP_WDT_RESET)
-        reason = "intWatchdog";
-    else if (hwReason == CHIP_LP_WDT_RESET)
-        reason = "chipWatchdog";
-    else if (hwReason == SUPER_WDT_RESET)
-        reason = "superWatchdog";
-    else if (hwReason == HP_SYS_HP_WDT_RESET)
-        reason = "systemWatchdog";
-    else if (hwReason == HP_SYS_LP_WDT_RESET)
-        reason = "systemLowPowerWatchdog";
-#else
    if (hwReason == RTCWDT_BROWN_OUT_RESET)
        reason = "brownout";
-    else if (hwReason == RTCWDT_RTC_RESET)
-        reason = "rtcWatchdog";
-    else if (hwReason == TG0WDT_SYS_RESET)
+
+    if (hwReason == TG0WDT_SYS_RESET)
        reason = "taskWatchdog";
-    else if (hwReason == TG1WDT_SYS_RESET)
+
+    if (hwReason == TG1WDT_SYS_RESET)
        reason = "intWatchdog";
-#endif
+
    LOG_INFO("Booted, wake cause %d (boot count %d), reset_reason=%s", wakeCause, bootCount, reason);
 #endif

@@ -234,8 +220,8 @@ void doDeepSleep(uint32_t msecToWake, bool skipPreflight = false, bool skipSaveN

 #if defined(ARCH_ESP32) && !MESHTASTIC_EXCLUDE_BLUETOOTH
    // Full shutdown of bluetooth hardware
-    if (bluetoothApi)
-        bluetoothApi->deinit();
+    if (nimbleBluetooth)
+        nimbleBluetooth->deinit();
 #endif

 #ifdef ARCH_ESP32
@@ -411,10 +397,8 @@ esp_sleep_wakeup_cause_t doLightSleep(uint64_t sleepMsec) // FIXME, use a more r

    // NOTE! ESP docs say we must disable bluetooth and wifi before light sleep

-#if SOC_PM_SUPPORT_RTC_PERIPH_PD
    // We want RTC peripherals to stay on
    esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
-#endif

 #if defined(BUTTON_PIN) && defined(BUTTON_NEED_PULLUP)
    gpio_pullup_en((gpio_num_t)BUTTON_PIN);
@@ -548,7 +532,11 @@ esp_sleep_wakeup_cause_t doLightSleep(uint64_t sleepMsec) // FIXME, use a more r
 */
 void enableModemSleep()
 {
+#if ESP_ARDUINO_VERSION >= ESP_ARDUINO_VERSION_VAL(3, 0, 0)
    static esp_pm_config_t esp32_config; // filled with zeros because bss
+#else
+    static esp_pm_config_esp32_t esp32_config; // filled with zeros because bss
+#endif
 #if CONFIG_IDF_TARGET_ESP32S3
    esp32_config.max_freq_mhz = CONFIG_ESP32S3_DEFAULT_CPU_FREQ_MHZ;
 #elif CONFIG_IDF_TARGET_ESP32S2
@@ -557,12 +545,6 @@ void enableModemSleep()
    esp32_config.max_freq_mhz = CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ;
 #elif CONFIG_IDF_TARGET_ESP32C3
    esp32_config.max_freq_mhz = CONFIG_ESP32C3_DEFAULT_CPU_FREQ_MHZ;
-#elif CONFIG_IDF_TARGET_ESP32P4
-#if CONFIG_ESP32P4_REV_MIN_FULL < 300
-    esp32_config.max_freq_mhz = 360;
-#else
-    esp32_config.max_freq_mhz = 400;
-#endif
 #else
    esp32_config.max_freq_mhz = CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ;
 #endif
@@ -580,8 +562,8 @@ bool shouldLoraWake(uint32_t msecToWake)

 void enableLoraInterrupt()
 {
-#if SOC_PM_SUPPORT_EXT_WAKEUP && defined(LORA_DIO1) && (LORA_DIO1 != RADIOLIB_NC)
    esp_err_t res;
+#if SOC_PM_SUPPORT_EXT_WAKEUP && defined(LORA_DIO1) && (LORA_DIO1 != RADIOLIB_NC)
    res = gpio_pulldown_en((gpio_num_t)LORA_DIO1);
    if (res != ESP_OK) {
        LOG_ERROR("gpio_pulldown_en(LORA_DIO1) result %d", res);
@@ -70,7 +70,7 @@
 // Battery

 #define BATTERY_PIN 34 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_6
+#define ADC_CHANNEL ADC1_GPIO34_CHANNEL
 #define ADC_ATTENUATION                                                                                                          \
    ADC_ATTEN_DB_2_5       // 2_5-> 100mv-1250mv, 11-> 150mv-3100mv for ESP32
                           // ESP32-S2/C3/S3 are different
@@ -30,7 +30,7 @@
 // Battery sense
 #define BATTERY_PIN 35
 #define ADC_MULTIPLIER 2.01 // 100k + 100k, and add 1% tolerance
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define BATTERY_SENSE_RESOLUTION_BITS ADC_RESOLUTION

 // SPI
@@ -3,7 +3,7 @@
 #define I2C_SDA 4
 #define I2C_SCL 5
 #define BATTERY_PIN 34
-#define ADC_CHANNEL ADC_CHANNEL_6
+#define ADC_CHANNEL ADC1_GPIO34_CHANNEL

 // GPS
 #undef GPS_RX_PIN
@@ -11,7 +11,7 @@
 // Note: On the ESP32 base version, gpio34-39 are input-only, and do not have internal pull-ups.
 // If 39 is not being used for a button, it is suggested to remove the #define.
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define ADC_MULTIPLIER 1.85 // (R1 = 470k, R2 = 680k)
 #define EXT_PWR_DETECT 4    // Pin to detect connected external power source for LILYGO® TTGO T-Energy T18 and other DIY boards
 #define EXT_NOTIFY_OUT 12   // Overridden default pin to use for Ext Notify Module (#975).
@@ -11,7 +11,7 @@

 #define BUTTON_PIN 39  // The middle button GPIO on the T-Beam
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define ADC_MULTIPLIER 1.85 // (R1 = 470k, R2 = 680k)
 #define EXT_PWR_DETECT 4    // Pin to detect connected external power source for LILYGO® TTGO T-Energy T18 and other DIY boards
 #define EXT_NOTIFY_OUT 12   // Overridden default pin to use for Ext Notify Module (#975).
@@ -4,9 +4,8 @@ extends = arduino_base
 custom_esp32_kind =
 custom_mtjson_part =
 platform =
-  # TODO renovate
-  https://github.com/pioarduino/platform-espressif32/releases/download/55.03.38-1/platform-espressif32.zip
-  ; https://github.com/pioarduino/platform-espressif32.git#develop
+  # renovate: datasource=custom.pio depName=platformio/espressif32 packageName=platformio/platform/espressif32
+  platformio/espressif32@6.13.0
 platform_packages =
  # renovate: datasource=custom.pio depName=platformio/tool-mklittlefs packageName=platformio/tool/tool-mklittlefs
  platformio/tool-mklittlefs@1.203.210628
@@ -36,18 +35,20 @@ build_unflags =
  -std=gnu++11
 build_flags =
  ${arduino_base.build_flags}
+  -flto
  -Wall
  -Wextra
  -Isrc/platform/esp32
  -std=gnu++17
  -DLOG_LOCAL_LEVEL=ESP_LOG_DEBUG
-  # DO NOT INCREASE THIS TO DEBUG. It appears to trigger a bug in ESP-IDF
-  # Bluetooth stack with Pixel 8 Android devices:
-  # https://github.com/espressif/esp-idf/issues/18126#issuecomment-4286197744
-  # Once the bug is resolved, we can remove this warning.
-  -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_INFO
+  -DCORE_DEBUG_LEVEL=ARDUHAL_LOG_LEVEL_DEBUG
  -DMYNEWT_VAL_BLE_HS_LOG_LVL=LOG_LEVEL_CRITICAL
  -DAXP_DEBUG_PORT=Serial
+  -DCONFIG_BT_NIMBLE_ENABLED
+  -DCONFIG_BT_NIMBLE_MAX_BONDS=6 # default is 3
+  -DCONFIG_NIMBLE_CPP_LOG_LEVEL=2
+  -DCONFIG_BT_NIMBLE_MAX_CCCDS=20
+  -DCONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
  -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
  -DSERIAL_BUFFER_SIZE=4096
  -DSERIAL_HAS_ON_RECEIVE
@@ -61,13 +62,16 @@ build_flags =
 lib_deps =
  ${arduino_base.lib_deps}
  ${networking_base.lib_deps}
+  ${networking_extra.lib_deps}
  ${environmental_base.lib_deps}
  ${environmental_extra.lib_deps}
  ${radiolib_base.lib_deps}
  # renovate: datasource=git-refs depName=meshtastic-esp32_https_server packageName=https://github.com/meshtastic/esp32_https_server gitBranch=master
  https://github.com/meshtastic/esp32_https_server/archive/0c71f380390ad483ff134ad938e07f6cf1226c5b.zip
-  # TODO renovate
-  https://github.com/mverch67/libpax/archive/6f52ee989301cdabaeef00bcbf93bff55708ce2f.zip
+  # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
+  h2zero/NimBLE-Arduino@1.4.3
+  # renovate: datasource=git-refs depName=libpax packageName=https://github.com/dbinfrago/libpax gitBranch=master
+  https://github.com/dbinfrago/libpax/archive/3cdc0371c375676a97967547f4065607d4c53fd1.zip
  # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
  lewisxhe/XPowersLib@0.3.3
  # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
@@ -75,30 +79,7 @@ lib_deps =

 lib_ignore = 
  segger_rtt
-  ; ESP32 BLE Arduino
-  ; BLE
-  ; Ignore select Bluetooth libs
-  NimBLE-Arduino
-  BluetoothSerial
-  SimpleBLE
-  WiFiProv
-  ArduinoOTA
-  ; Ignore pioarduino esp32 libs we don't use
-  ESP_I2S
-  ESP_NOW
-  ESP_SR
-  Insights
-  Matter
-  OpenThread
-  RainMaker
-  ;SPIFFS
-  USB
-  ;NetworkClientSecure
-  Zigbee
-  Micro-RTSP
-  ; testing below
-  mqtt
-  esp-mqtt
+  ESP32 BLE Arduino

 ; leave this commented out to avoid breaking Windows
 ;upload_port = /dev/ttyUSB0
@@ -111,226 +92,3 @@ lib_ignore =
 ; customize the partition table
 ; http://docs.platformio.org/en/latest/platforms/espressif32.html#partition-tables
 board_build.partitions = partition-table.csv
-
-custom_component_remove =
-  espressif/esp_hosted
-  espressif/esp_wifi_remote
-  espressif/esp_modem
-  espressif/esp-dsp
-  espressif/esp32-camera
-  espressif/libsodium
-  espressif/esp-modbus
-  espressif/qrcode
-  espressif/esp_insights
-  espressif/esp_diag_data_store
-  espressif/esp_diagnostics
-  espressif/esp_rainmaker
-  espressif/rmaker_common
-  espressif/network_provisioning
-  chmorgan/esp-libhelix-mp3
-  espressif/esp-tflite-micro
-  espressif/esp-sr
-  espressif/esp_matter
-  espressif/esp-zboss-lib
-  espressif/esp-zigbee-lib
-  espressif/mqtt
-
-custom_sdkconfig =
-  ; CONFIG_LOG_DEFAULT_LEVEL=4
-  ; CONFIG_LOG_MAXIMUM_LEVEL=4
-  '# CONFIG_BT_NIMBLE_LOG_LEVEL_INFO is not set'
-  CONFIG_BT_NIMBLE_LOG_LEVEL_ERROR=y
-  CONFIG_LOG_COLORS=y
-  CONFIG_ARDUHAL_LOG_COLORS=y
-  CONFIG_BOOTLOADER_LOG_LEVEL_NONE=y
-  CONFIG_IDF_EXPERIMENTAL_FEATURES=y
-  ;
-  ; Compiler options
-  ;
-  CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE=n
-  CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE=y
-  CONFIG_COMPILER_CXX_EXCEPTIONS=n
-  CONFIG_COMPILER_STACK_CHECK_MODE_NORM=n
-  CONFIG_COMPILER_STACK_CHECK_MODE_NONE=y
-  CONFIG_COMPILER_DISABLE_GCC12_WARNINGS=y
-  CONFIG_COMPILER_DISABLE_GCC13_WARNINGS=y
-  CONFIG_COMPILER_DISABLE_GCC14_WARNINGS=y
-  CONFIG_COMPILER_ORPHAN_SECTIONS_WARNING=n
-  CONFIG_COMPILER_ORPHAN_SECTIONS_PLACE=y
-  CONFIG_ESP_GDBSTUB_ENABLED=n
-  CONFIG_ESP_TASK_WDT_INIT=n
-  CONFIG_NEWLIB_NANO_FORMAT=y
-  ; LIBC_NEWLIB_NANO_FORMAT is enabled via 'esp32_extra.py' to allow float support
-  CONFIG_ESP_COREDUMP_ENABLE=n
-  CONFIG_ESP_COREDUMP_ENABLE_TO_FLASH=n
-  CONFIG_ESP_COREDUMP_ENABLE_TO_NONE=y
-  CONFIG_ESP32_ENABLE_COREDUMP=n
-  CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS=n
-  CONFIG_FREERTOS_USE_STATS_FORMATTING_FUNCTIONS=n
-  CONFIG_FREERTOS_USE_TRACE_FACILITY=n
-  CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH=y
-  CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH=y
-  CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH=y
-  CONFIG_ESP_SYSTEM_ESP32_SRAM1_REGION_AS_IRAM=y
-  CONFIG_ESP_WIFI_IRAM_OPT=n
-  CONFIG_ESP32_WIFI_RX_IRAM_OPT=n
-  CONFIG_SPIRAM_CACHE_LIBCHAR_IN_IRAM=n
-  CONFIG_SPIRAM_CACHE_LIBSTR_IN_IRAM=n
-  CONFIG_SPIRAM_CACHE_LIBMISC_IN_IRAM=n
-  CONFIG_SPIRAM_CACHE_LIBTIME_IN_IRAM=n
-  CONFIG_UNITY_ENABLE_FLOAT=n
-  CONFIG_UNITY_ENABLE_DOUBLE=n
-  CONFIG_UNITY_ENABLE_IDF_TEST_RUNNER=n
-  CONFIG_SUPPORT_TERMIOS=n
-  CONFIG_VFS_SUPPORT_TERMIOS=n
-  CONFIG_VFS_SUPPORT_SELECT=n
-  CONFIG_VFS_SUPPRESS_SELECT_DEBUG_OUTPUT=n
-  CONFIG_WS_TRANSPORT=n
-  CONFIG_PPP_SUPPORT=n
-  CONFIG_NETWORK_PROV_NETWORK_TYPE_WIFI=n
-  ; CONFIG_LWIP_DHCPS=n
-  CONFIG_LWIP_PPP_SUPPORT=n
-  CONFIG_LWIP_IP_FORWARD=n
-  CONFIG_LWIP_IPV4_NAPT=n
-  ;
-  ; MBEDTLS
-  ;
-  CONFIG_MBEDTLS_SSL_MAX_CONTENT_LEN=8192
-  CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_FULL=n
-  CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN=y
-  ; Switch to custom CA bundle (for Meshtastic MQTT/etc) in the future
-  ; https://docs.espressif.com/projects/esp-idf/en/latest/esp32s3/api-reference/kconfig-reference.html#certificate-bundle-configuration
-  ; CONFIG_MBEDTLS_CUSTOM_CERTIFICATE_BUNDLE=y
-  ; CONFIG_MBEDTLS_CUSTOM_CERTIFICATE_BUNDLE_PATH=""
-  CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_MAX_CERTS=1
-  ; #shame
-  CONFIG_MBEDTLS_ALLOW_WEAK_CERTIFICATE_VERIFICATION=y
-  CONFIG_MBEDTLS_SSL_RENEGOTIATION=n
-  CONFIG_MBEDTLS_SSL_PROTO_DTLS=n
-  CONFIG_MBEDTLS_CLIENT_SSL_SESSION_TICKETS=n
-  CONFIG_MBEDTLS_SERVER_SSL_SESSION_TICKETS=n
-  CONFIG_MBEDTLS_PKCS7_C=n
-  CONFIG_MBEDTLS_CAMELLIA_C=n
-  CONFIG_MBEDTLS_CCM_C=n
-  CONFIG_MBEDTLS_CMAC_C=n
-  CONFIG_MBEDTLS_SHA512_C=n
-  CONFIG_MBEDTLS_X509_CRL_PARSE_C=n
-  CONFIG_MBEDTLS_X509_CSR_PARSE_C=n
-  CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_PSK=n
-  CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA=n
-  CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA=n
-  CONFIG_MBEDTLS_KEY_EXCHANGE_ECJPAKE=n
-  CONFIG_MBEDTLS_ECP_DP_SECP192R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP224R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP192K1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP224K1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED=n
-  CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED=n
-  CONFIG_MDNS_ENABLE_CONSOLE_CLI=n
-  CONFIG_MDNS_PREDEF_NETIF_AP=n
-  ; CONFIG_ESP_WIFI_SOFTAP_SUPPORT=n
-  CONFIG_ESP_WIFI_ENTERPRISE_SUPPORT=n
-  CONFIG_ESP_WIFI_ENABLE_WPA3_SAE=n
-  CONFIG_ESP_WIFI_ENABLE_WPA3_OWE_STA=n
-  CONFIG_ESP_WIFI_ENABLE_SAE_H2E=n
-  CONFIG_OPENTHREAD_ENABLED=n
-  CONFIG_ZB_ENABLED=n
-  CONFIG_IEEE802154_ENABLED=n
-  CONFIG_ESP_INSIGHTS_ENABLED=n
-  CONFIG_HTTPD_WS_SUPPORT=n
-  CONFIG_ESP_HTTP_CLIENT_ENABLE_HTTPS=n
-  CONFIG_ESP_HTTP_CLIENT_ENABLE_BASIC_AUTH=n
-  ; using esp-idf5-https_server library instead, for now?
-  CONFIG_ESP_HTTPS_SERVER_ENABLE=n
-  ;
-  ; Builtin ESP-MQTT, we don't use this (yet?)
-  ;
-  CONFIG_MQTT_TRANSPORT_SSL=n
-  CONFIG_MQTT_TRANSPORT_WEBSOCKET=n
-  CONFIG_MQTT_TRANSPORT_WEBSOCKET_SECURE=n
-  CONFIG_MQTT_PROTOCOL_311=n
-  ;
-  ; Ethernet
-  ; Disabled in esp32_common, re-enable on variants that need it
-  ;
-  CONFIG_ETH_ENABLED=n
-  CONFIG_ARDUINO_SELECTIVE_Ethernet=n
-  ;
-  ; Bluetooth
-  ;
-  CONFIG_BLE_MESH=n
-  CONFIG_BT_ENABLED=y
-  CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
-  CONFIG_BT_BLUEDROID_ENABLED=n
-  CONFIG_BT_NIMBLE_ENABLED=y
-  CONFIG_BT_NIMBLE_NVS_PERSIST=y
-  CONFIG_BT_NIMBLE_ROLE_CENTRAL=n
-  CONFIG_BT_NIMBLE_ROLE_OBSERVER=n
-  CONFIG_BT_CONTROLLER_ENABLED=y
-  CONFIG_BT_NIMBLE_HOST_TASK_STACK_SIZE=8192
-  CONFIG_BT_NIMBLE_MAX_CCCDS=20
-  CONFIG_BT_NIMBLE_MAX_BONDS=6
-  CONFIG_BT_NIMBLE_ENABLE_PERIODIC_SYNC=n
-  CONFIG_BT_NIMBLE_ENABLE_PERIODIC_ADV=n
-  CONFIG_BT_NIMBLE_EXT_SCAN=n
-  CONFIG_BT_NIMBLE_EXT_ADV=n
-  CONFIG_BT_NIMBLE_PERIODIC_ADV_SYNC_TRANSFER=n
-  CONFIG_BT_NIMBLE_LL_CFG_FEAT_LE_2M_PHY=n
-  CONFIG_BT_NIMBLE_BLUFI_ENABLE=n
-  CONFIG_BT_NIMBLE_PROX_SERVICE=n
-  CONFIG_BT_NIMBLE_ANS_SERVICE=n
-  CONFIG_BT_NIMBLE_CTS_SERVICE=n
-  CONFIG_BT_NIMBLE_HTP_SERVICE=n
-  CONFIG_BT_NIMBLE_IPSS_SERVICE=n
-  CONFIG_BT_NIMBLE_TPS_SERVICE=n
-  CONFIG_BT_NIMBLE_IAS_SERVICE=n
-  CONFIG_BT_NIMBLE_LLS_SERVICE=n
-  CONFIG_BT_NIMBLE_SPS_SERVICE=y
-  CONFIG_BT_NIMBLE_HR_SERVICE=n
-  CONFIG_BT_NIMBLE_HID_SERVICE=n
-  CONFIG_BT_NIMBLE_BAS_SERVICE=n
-  CONFIG_BT_NIMBLE_DIS_SERVICE=n
-  ;
-  ; Arduino selective compilation
-  ; Disable unused Arduino libraries to save space
-  ;
-  CONFIG_ARDUINO_SELECTIVE_COMPILATION=y
-  CONFIG_ARDUINO_SELECTIVE_SPI=y
-  CONFIG_ARDUINO_SELECTIVE_Wire=y
-  CONFIG_ARDUINO_SELECTIVE_ESP_SR=n
-  CONFIG_ARDUINO_SELECTIVE_EEPROM=y
-  CONFIG_ARDUINO_SELECTIVE_Preferences=y
-  CONFIG_ARDUINO_SELECTIVE_Ticker=y
-  CONFIG_ARDUINO_SELECTIVE_Update=y
-  CONFIG_ARDUINO_SELECTIVE_Zigbee=n
-  CONFIG_ARDUINO_SELECTIVE_FS=y
-  CONFIG_ARDUINO_SELECTIVE_SD=y
-  CONFIG_ARDUINO_SELECTIVE_SD_MMC=y
-  CONFIG_ARDUINO_SELECTIVE_SPIFFS=y
-  CONFIG_ARDUINO_SELECTIVE_FFat=n
-  CONFIG_ARDUINO_SELECTIVE_LittleFS=y
-  CONFIG_ARDUINO_SELECTIVE_Network=y
-  ; CONFIG_ARDUINO_SELECTIVE_Ethernet=n
-  CONFIG_ARDUINO_SELECTIVE_PPP=n
-  CONFIG_ARDUINO_SELECTIVE_Hash=y
-  CONFIG_ARDUINO_SELECTIVE_ArduinoOTA=n
-  CONFIG_ARDUINO_SELECTIVE_AsyncUDP=y
-  CONFIG_ARDUINO_SELECTIVE_DNSServer=n
-  CONFIG_ARDUINO_SELECTIVE_ESPmDNS=y
-  CONFIG_ARDUINO_SELECTIVE_HTTPClient=n
-  CONFIG_ARDUINO_SELECTIVE_Matter=n
-  CONFIG_ARDUINO_SELECTIVE_NetBIOS=n
-  CONFIG_ARDUINO_SELECTIVE_WebServer=n
-  CONFIG_ARDUINO_SELECTIVE_WiFi=y
-  CONFIG_ARDUINO_SELECTIVE_NetworkClientSecure=y
-  CONFIG_ARDUINO_SELECTIVE_WiFiProv=n
-  CONFIG_ARDUINO_SELECTIVE_BLE=y
-  CONFIG_ARDUINO_SELECTIVE_BluetoothSerial=n
-  CONFIG_ARDUINO_SELECTIVE_SimpleBLE=n
-  CONFIG_ARDUINO_SELECTIVE_RainMaker=n
-  CONFIG_ARDUINO_SELECTIVE_OpenThread=n
-  CONFIG_ARDUINO_SELECTIVE_Insights=n
@@ -11,39 +11,12 @@ build_src_filter =

 build_flags =
  ${esp32_common.build_flags}
-  -mtext-section-literals
-  -D ESP32_FORCE_IRAM_MEMSET
-  -Wl,--wrap=memset
-  -Wl,--wrap=memcpy
  -DMESHTASTIC_EXCLUDE_AUDIO=1
  -DMESHTASTIC_EXCLUDE_ACCELEROMETER=1
  -DMESHTASTIC_EXCLUDE_PAXCOUNTER=1
  -DMESHTASTIC_EXCLUDE_WEBSERVER=1
  -DMESHTASTIC_EXCLUDE_RANGETEST=1
-  ; HACK HACK HACK this is just a proof of concept ESP32+NimBLE but these
-  ; includes need to be done properly somehow
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/host/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/porting/nimble/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/port/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/porting/npl/freertos/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/transport/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/host/services/gap/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/esp-hci/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/host/services/gatt/include
-  -I${platformio.packages_dir}/framework-espidf/components/bt/host/nimble/nimble/nimble/host/util/include

-custom_sdkconfig =
-  ${esp32_common.custom_sdkconfig}
-  CONFIG_BTDM_CTRL_MODE_BLE_ONLY=y
-  '# CONFIG_BTDM_CTRL_MODE_BR_EDR_ONLY is not set'
-  '# CONFIG_BTDM_CTRL_MODE_BTDM is not set'
-  '# CONFIG_BT_BLUEDROID_ENABLED is not set'
-  CONFIG_BT_NIMBLE_ENABLED=y
-  CONFIG_SPI_FLASH_SUPPORT_BOYA_CHIP=y
-
-; Override lib_deps to use environmental_extra_no_bsec instead of environmental_extra
-; BSEC library uses ~3.5KB DRAM which causes overflow on original ESP32 targets
 lib_deps =
  ${arduino_base.lib_deps}
  ${networking_base.lib_deps}
@@ -51,8 +24,8 @@ lib_deps =
  ${radiolib_base.lib_deps}
  ${environmental_base.lib_deps}
  ${environmental_extra_no_bsec.lib_deps}
-  # TODO renovate
-  https://github.com/mverch67/libpax/archive/6f52ee989301cdabaeef00bcbf93bff55708ce2f.zip
+  # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
+  h2zero/NimBLE-Arduino@1.4.3
  # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
  lewisxhe/XPowersLib@0.3.3
  # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
@@ -12,7 +12,7 @@
 #define ADC_CTRL 21
 #define ADC_CTRL_ENABLED LOW
 #define BATTERY_PIN 37 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_1
+#define ADC_CHANNEL ADC1_CHANNEL_1
 // ratio of voltage divider = 3.20 (R1=100k, R2=220k)
 #define ADC_MULTIPLIER 3.2

@@ -92,7 +92,7 @@
 #define PIN_EINK_MOSI 23 // EPD_MOSI

 #define BATTERY_PIN 35
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 // https://m5stack.oss-cn-shenzhen.aliyuncs.com/resource/docs/schematic/Core/m5paper/M5_PAPER_SCH.pdf
 // https://github.com/m5stack/M5Core-Ink/blob/master/examples/Basics/FactoryTest/FactoryTest.ino#L58
 //  VBAT
@@ -33,7 +33,7 @@
 #endif

 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define BATTERY_SENSE_SAMPLES 15 // Set the number of samples, It has an effect of increasing sensitivity.
 #define ADC_MULTIPLIER 2

@@ -7,7 +7,7 @@ build_flags =
  -DVTABLES_IN_FLASH=1
  -DCONFIG_DISABLE_HAL_LOCKS=1
  -DHAS_STK8XXX=1
-  ; -O2
+  -O2
  -I variants/esp32/radiomaster_900_bandit
 board_build.f_cpu = 240000000L
 upload_protocol = esptool
@@ -47,7 +47,7 @@ static const uint8_t SCK = 33;

 #define PIN_VBAT WB_A0
 #define BATTERY_PIN PIN_VBAT
-#define ADC_CHANNEL ADC_CHANNEL_0
+#define ADC_CHANNEL ADC1_GPIO36_CHANNEL

 // https://docs.rakwireless.com/Product-Categories/WisBlock/RAK13300/

@@ -32,7 +32,7 @@
 #endif

 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define BATTERY_SENSE_SAMPLES 30 // Set the number of samples, It has an effect of increasing sensitivity.
 #define ADC_MULTIPLIER 6.45
 #define CELL_TYPE_LION // same curve for liion/lipo
@@ -16,7 +16,6 @@ board_check = true
 build_flags = ${esp32_base.build_flags}
  -D TBEAM_V10
  -I variants/esp32/tbeam
-
 upload_speed = 921600

 [env:tbeam-displayshield]
@@ -6,7 +6,7 @@
 #define BUTTON_PIN 39
 #define BATTERY_PIN 35    // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 #define EXT_NOTIFY_OUT 13 // Default pin to use for Ext Notify Module.
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL

 #define USE_RF95
 #define LORA_DIO0 26 // a No connect on the SX1262 module
@@ -1,5 +1,5 @@
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL

 #define I2C_SDA 21 // I2C pins for this board
 #define I2C_SCL 22
@@ -1,5 +1,5 @@
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL

 #define I2C_SDA 21 // I2C pins for this board
 #define I2C_SCL 22
@@ -1,5 +1,5 @@
 #define BATTERY_PIN 35
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define BATTERY_SENSE_SAMPLES 30

 // ratio of voltage divider = 2.0 (R42=100k, R43=100k)
@@ -1,7 +1,7 @@
 #define BATTERY_PIN 35 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 // ratio of voltage divider = 2.0 (R42=100k, R43=100k)
 #define ADC_MULTIPLIER 2.11 // 2.0 + 10% for correction of display undervoltage.
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL

 #define I2C_SDA 21 // I2C pins for this board
 #define I2C_SCL 22
@@ -22,7 +22,7 @@
 #undef BAT_MEASURE_ADC_UNIT
 #define BATTERY_PIN 35      // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
 #define ADC_MULTIPLIER 1.34 //  tracked resistance divider is 100k+470k, so it can not fillfull well on esp32 adc
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO35_CHANNEL
 #define ADC_ATTENUATION ADC_ATTEN_DB_12 // lower dB for high resistance voltage divider

 #undef GPS_RX_PIN
@@ -5,19 +5,6 @@ custom_esp32_kind = esp32c3
 monitor_speed = 115200
 monitor_filters = esp32_c3_exception_decoder

-build_flags =
-  ${esp32_common.build_flags}
-  ; Linker script to align text.handler_execute section to 4 bytes
-  -Wl,-Tsrc/platform/esp32/align-text.handler_execute-4.ld
-
-custom_sdkconfig =
-  ${esp32_common.custom_sdkconfig}
-  ; ESP32c3 doesn't support SD_MMC
-  CONFIG_ARDUINO_SELECTIVE_SD_MMC=n
-  ; CONFIG_BT_NIMBLE_EXT_ADV=y
-  ; CONFIG_BT_NIMBLE_TRANSPORT_EVT_SIZE=257
-  ; CONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
-
 lib_deps =
  ${esp32_common.lib_deps}
  # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
@@ -1,34 +1,50 @@
 [esp32c6_base]
 extends = esp32_common
-custom_esp32_kind = esp32c6
-
+platform =
+  # Do not renovate until we have switched to pioarduino tagged builds
+  https://github.com/Jason2866/platform-espressif32/archive/22faa566df8c789000f8136cd8d0aca49617af55.zip
+platform_packages =
+  # HACK: This release was automatically removed upstream
+  framework-arduinoespressif32 @ https://github.com/vidplace7/platform-espressif32/releases/download/meshtastic-esp32c6/framework-arduinoespressif32-all-release_v5.1-124d64e.zip
 build_flags =
-  ${esp32_common.build_flags}
-  ; Linker script to align text.handler_execute section to 4 bytes
-  -Wl,-Tsrc/platform/esp32/align-text.handler_execute-4.ld
-  ; Exclude Paxcounter, it uses 'esp_vhci_host_send_packet' whch is not available on ESP32-C6
-  ; https://github.com/espressif/arduino-esp32/issues/11716
+  ${arduino_base.build_flags}
+  -Wall
+  -Wextra
+  -Isrc/platform/esp32
+  -DESP_OPENSSL_SUPPRESS_LEGACY_WARNING
+  -DSERIAL_BUFFER_SIZE=4096
+  -DLIBPAX_ARDUINO
+  -DLIBPAX_WIFI
+  -DLIBPAX_BLE
+  -DMESHTASTIC_EXCLUDE_WEBSERVER
+  ;-DDEBUG_HEAP
+  ; TEMP
+  -DHAS_BLUETOOTH=0
  -DMESHTASTIC_EXCLUDE_PAXCOUNTER
+  -DMESHTASTIC_EXCLUDE_BLUETOOTH
+
+lib_deps =
+  ${arduino_base.lib_deps}
+  ${networking_base.lib_deps}
+  ${environmental_base.lib_deps}
+  ${environmental_extra.lib_deps}
+  ${radiolib_base.lib_deps}
+  # renovate: datasource=custom.pio depName=XPowersLib packageName=lewisxhe/library/XPowersLib
+  lewisxhe/XPowersLib@0.3.3
+  # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
+  https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
+  # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
+  rweather/Crypto@0.4.0

 build_src_filter = 
- ${esp32_common.build_src_filter}
+  ${esp32_common.build_src_filter} -<mesh/http>

 monitor_speed = 460800
 monitor_filters = esp32_c3_exception_decoder

-custom_sdkconfig =
-  ${esp32_common.custom_sdkconfig}
-  ; ESP32c6 doesn't support SD_MMC
-  CONFIG_ARDUINO_SELECTIVE_SD_MMC=n
-  ; CONFIG_BT_NIMBLE_EXT_ADV=y
-  ; CONFIG_BT_NIMBLE_TRANSPORT_EVT_SIZE=257
-  ; CONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
-
 lib_ignore =
  ${esp32_common.lib_ignore}
+  NonBlockingRTTTL
+  NimBLE-Arduino
  libpax
-
-lib_deps =
-  ${esp32_common.lib_deps}
-  # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
-  https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
+  
@@ -17,12 +17,28 @@ board_build.partitions = default_16MB.csv
 ;Normal method
 upload_protocol = esptool
 ;upload_port = /dev/ttyACM2
+build_unflags =
+  -D HAS_BLUETOOTH
+  -D MESHTASTIC_EXCLUDE_BLUETOOTH
+  -D HAS_WIFI
+lib_deps =
+  ${esp32c6_base.lib_deps}
+  # renovate: datasource=custom.pio depName=NimBLE-Arduino packageName=h2zero/library/NimBLE-Arduino
+  h2zero/NimBLE-Arduino@2.3.7
 build_flags = 
  ${esp32c6_base.build_flags}
  -D M5STACK_UNITC6L
  -I variants/esp32c6/m5stack_unitc6l
+  -DMESHTASTIC_EXCLUDE_PAXCOUNTER=1
  -DARDUINO_USB_CDC_ON_BOOT=1
  -DARDUINO_USB_MODE=1
+  -D HAS_BLUETOOTH=1
+	-DCONFIG_BT_NIMBLE_EXT_ADV=1
+	-DCONFIG_BT_NIMBLE_MAX_EXT_ADV_INSTANCES=2
+  -D NIMBLE_TWO
 monitor_speed=115200
+lib_ignore =
+  NonBlockingRTTTL
+  libpax
 build_src_filter = 
 ${esp32c6_base.build_src_filter} +<../variants/esp32c6/m5stack_unitc6l>
@@ -8,11 +8,3 @@ build_flags =
  -I variants/esp32c6/tlora_c6
  -DARDUINO_USB_CDC_ON_BOOT=1
  -DARDUINO_USB_MODE=1
-  ; Disable screen + audio.
-  ; ESP32-C6 with 4MB flash is TIGHT on space.
-  -DMESHTASTIC_EXCLUDE_SCREEN=1
-  -DMESHTASTIC_EXCLUDE_AUDIO=1
-
-lib_ignore =
-  ${esp32c6_base.lib_ignore}
-  ESP32 Codec2
@@ -1,116 +0,0 @@
-#ifndef Pins_Arduino_h
-#define Pins_Arduino_h
-
-#include "soc/soc_caps.h"
-#include <stdint.h>
-
-// BOOT_MODE 35
-// BOOT_MODE2 36 pullup
-
-static const uint8_t TX = 37;
-static const uint8_t RX = 38;
-
-#if defined(CROWPANEL_ADV_P4_50)
-static const uint8_t SDA = 45;
-static const uint8_t SCL = 46;
-#else
-static const uint8_t SDA = 45;
-static const uint8_t SCL = 46;
-#endif
-
-// Use GPIOs 36 or lower on the P4 DevKit to avoid LDO power issues with high numbered GPIOs.
-static const uint8_t SS = 30;
-static const uint8_t MOSI = 48;
-static const uint8_t MISO = 47;
-static const uint8_t SCK = 26;
-
-static const uint8_t A0 = 16;
-static const uint8_t A1 = 17;
-static const uint8_t A2 = 18;
-static const uint8_t A3 = 19;
-static const uint8_t A4 = 20;
-static const uint8_t A5 = 21;
-static const uint8_t A6 = 22;
-static const uint8_t A7 = 23;
-static const uint8_t A8 = 49;
-static const uint8_t A9 = 50;
-static const uint8_t A10 = 51;
-static const uint8_t A11 = 52;
-static const uint8_t A12 = 53;
-static const uint8_t A13 = 54;
-
-static const uint8_t T0 = 2;
-static const uint8_t T1 = 3;
-static const uint8_t T2 = 4;
-static const uint8_t T3 = 5;
-static const uint8_t T4 = 6;
-static const uint8_t T5 = 7;
-static const uint8_t T6 = 8;
-static const uint8_t T7 = 9;
-static const uint8_t T8 = 10;
-static const uint8_t T9 = 11;
-static const uint8_t T10 = 12;
-static const uint8_t T11 = 13;
-static const uint8_t T12 = 14;
-static const uint8_t T13 = 15;
-
-/* ESP32-P4 EV Function board specific definitions */
-// ETH
-// #define ETH_PHY_TYPE    ETH_PHY_TLK110
-// #define ETH_PHY_ADDR    1
-// #define ETH_PHY_MDC     31
-// #define ETH_PHY_MDIO    52
-// #define ETH_PHY_POWER   51
-// #define ETH_RMII_TX_EN  49
-// #define ETH_RMII_TX0    34
-// #define ETH_RMII_TX1    35
-// #define ETH_RMII_RX0    29
-// #define ETH_RMII_RX1_EN 30
-// #define ETH_RMII_CRS_DV 28
-// #define ETH_RMII_CLK    50
-// #define ETH_CLK_MODE    EMAC_CLK_EXT_IN
-
-// SDMMC
-#define BOARD_HAS_SDMMC
-#define BOARD_HAS_SD_SDMMC
-#define SDMMC_CMD 44 // SD_CMD/MOSI
-#define SDMMC_CLK 43 // SD_CLK
-#define SDMMC_D0 39  // SD_D0/MISO
-#define SD_CS -1     // No CS pin in SDMMC mode
-
-#if defined(CROWPANEL_ADV_P4_50)
-#define BOARD_SDMMC_SLOT 1
-// Workaround for Arduino-ESP32 P4 SPI LDO auto-config on SDMMC slot0 pins (47/48).
-// Use a valid GPIO (aligned to variant LoRa CS) and pre-tag it in initVariant()
-// so setLDOPower() short-circuits.
-#define BOARD_SDMMC_POWER_PIN 30
-#else
-#define BOARD_SDMMC_POWER_PIN 10
-#define BOARD_SDMMC_SLOT 0
-#endif
-#define BOARD_SDMMC_POWER_CHANNEL 4
-#define BOARD_SDMMC_POWER_ON_LEVEL HIGH
-
-// BT/WIFI - ESP32C6
-#define BOARD_HAS_SDIO_ESP_HOSTED
-#ifdef CROWPANEL_ADV_P4_50
-// CrowPanel Advanced P4 50": 4-bit SDIO on Slot 1 with GPIO 53/54/52/51/50/49
-#define BOARD_SDIO_ESP_HOSTED_CLK 53
-#define BOARD_SDIO_ESP_HOSTED_CMD 54
-#define BOARD_SDIO_ESP_HOSTED_D0 52
-#define BOARD_SDIO_ESP_HOSTED_D1 51
-#define BOARD_SDIO_ESP_HOSTED_D2 50
-#define BOARD_SDIO_ESP_HOSTED_D3 49
-#define BOARD_SDIO_ESP_HOSTED_RESET 20
-#else
-// CrowPanel Advanced P4 70/90/101": 1-bit SDIO on Slot 1 with GPIO 18/19/14/15
-#define BOARD_SDIO_ESP_HOSTED_CLK 18
-#define BOARD_SDIO_ESP_HOSTED_CMD 19
-#define BOARD_SDIO_ESP_HOSTED_D0 14
-#define BOARD_SDIO_ESP_HOSTED_D1 15
-#define BOARD_SDIO_ESP_HOSTED_D2 16
-#define BOARD_SDIO_ESP_HOSTED_D3 17
-#define BOARD_SDIO_ESP_HOSTED_RESET 32
-#endif
-
-#endif /* Pins_Arduino_h */
@@ -1,193 +0,0 @@
-[env:crowpanel-advanced-p4-50]
-extends = esp32p4_base
-board = crowpanel-p4
-board_check = true
-board_build.partitions = default_16MB.csv
-
-build_src_filter =
-  ${esp32p4_base.build_src_filter}
-  +<../variants/esp32p4/crowpanel-advanced-p4>
-
-build_flags = 
-  ${esp32p4_base.build_flags}
-  -D CROWPANEL_ADV_P4
-  -D CROWPANEL_ADV_P4_50
-  -I variants/esp32p4/crowpanel-advanced-p4
-  -D ARDUINO_USB_CDC_ON_BOOT=0
-  -D ARDUINO_USB_MODE=1
-  -D MESHTASTIC_EXCLUDE_WEBSERVER=1
-  -D MESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
-  -D MESHTASTIC_EXCLUDE_INPUTBROKER=1
-  -D MAX_NUM_NODES=500
-  -D MAX_NUM_NODES_VIEW=500
-;  -DSOC_USB_OTG_SUPPORTED=1
-  -D CONFIG_DISABLE_HAL_LOCKS=1 ; "feels" to be a bit more stable without locks
-;  -D INPUTDRIVER_BUTTON_TYPE=0
-  -D HAS_SDCARD
-  -D HAS_SD_MMC
-  -D BOARD_MAX_SDMMC_FREQ=100000
-  -D BOARD_HAS_1BIT_SDMMC
-  -D SD_SCLK_PIN=43
-  -D SD_MISO_PIN=39
-  -D SD_MOSI_PIN=44
-  -D SD_MMC_HOST_SLOT=SDMMC_HOST_SLOT_1
-  -D HAS_SCREEN=1
-  -D HAS_TFT=1
-;  -D USE_I2S_BUZZER
-  -D RAM_SIZE=10240
-  -D LV_LVGL_H_INCLUDE_SIMPLE
-  -D LV_CONF_INCLUDE_SIMPLE
-  -D LV_COMP_CONF_INCLUDE_SIMPLE
-  -D LV_USE_SYSMON=0
-  -D LV_USE_PROFILER=0
-  -D LV_USE_PERF_MONITOR=0
-  -D LV_USE_MEM_MONITOR=0
-  -D LV_USE_LOG=0
-  -D LV_CACHE_DEF_SIZE=3400000
-  -D USE_LOG_DEBUG
-  -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
-  -D RADIOLIB_SPI_PARANOID=0
-  -D LGFX_SCREEN_WIDTH=800
-  -D LGFX_SCREEN_HEIGHT=480
-  -D DISPLAY_SIZE=800x480 ; landscape mode
-  -D LGFX_DRIVER=LGFX_ELECROW_P4_50
-  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_ELECROW_P4_50.h\"
-  -D LGFX_BUFSIZE=1152000
-  -D LGFX_SKIP_RGB565_SWAP
-  -D VIEW_320x240
-  -D DISPLAY_SET_RESOLUTION
-  -D USE_PACKET_API
-  -D MAP_FULL_REDRAW
-
-lib_deps =
-  ${esp32p4_base.lib_deps}
-  ${device-ui_base.lib_deps}
-  https://github.com/lovyan03/LovyanGFX#develop
-
-custom_sdkconfig =
-  ${esp32p4_base.custom_sdkconfig}
-  # Disable external SDMMC IO power control to avoid GPIO conflicts
-  CONFIG_SOC_SDMMC_IO_POWER_EXTERNAL=n
-  # CONFIG_BT_BLE_50_FEATURES_SUPPORTED is not set
-  CONFIG_BT_BLE_42_FEATURES_SUPPORTED=y
-
-  # Force hosted transport/target selection for this env.
-  CONFIG_ESP_HOSTED_SDIO_4_BIT_BUS=y
-  CONFIG_ESP_HOSTED_SDIO_CLOCK_FREQ_KHZ=40000
-  # CrowPanel SDIO pins
-  CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_CMD_SLOT_1=54
-  CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_CLK_SLOT_1=53
-  CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D0_SLOT_1=52
-  CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D1_4BIT_BUS_SLOT_1=51
-  CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D2_4BIT_BUS_SLOT_1=50
-  CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D3_4BIT_BUS_SLOT_1=49
-
-  # Also set resolved SDIO pins explicitly so generated sdkconfig does not
-  # retain stale template values from framework sdkconfig.
-  CONFIG_ESP_HOSTED_SDIO_PIN_CMD=54
-  CONFIG_ESP_HOSTED_SDIO_PIN_CLK=53
-  CONFIG_ESP_HOSTED_SDIO_PIN_D0=52
-  CONFIG_ESP_HOSTED_SDIO_PIN_D1=51
-  CONFIG_ESP_HOSTED_SDIO_PIN_D2=50
-  CONFIG_ESP_HOSTED_SDIO_PIN_D3=49
-  CONFIG_ESP_HOSTED_SDIO_PRIV_PIN_D1_4BIT_BUS=51
-
-  # SDIO Slot 1 via GPIO matrix
-  CONFIG_ESP_HOSTED_SDIO_SLOT_1=y
-  CONFIG_ESP_HOSTED_SDIO_RESET_ACTIVE_HIGH=y
-  CONFIG_ESP_HOSTED_SDIO_GPIO_RESET_SLAVE=20
-  CONFIG_ESP_HOSTED_GPIO_SLAVE_RESET_SLAVE=20
-
-[env:crowpanel-advanced-p4-70-90-101]
-extends = esp32p4_base
-board = esp32-p4-evboard
-board_check = true
-board_build.partitions = default_16MB.csv
-
-build_src_filter =
-  ${esp32p4_base.build_src_filter}
-  +<../variants/esp32p4/crowpanel-advanced-p4>
-
-build_flags =
-  ${esp32p4_base.build_flags}
-  -D CROWPANEL_ADV_P4
-  -D CROWPANEL_ADV_P4_70_90_101
-  -I variants/esp32p4/crowpanel-advanced-p4
-  -D ARDUINO_USB_CDC_ON_BOOT=0
-  -D ARDUINO_USB_MODE=1
-  -D MESHTASTIC_EXCLUDE_WEBSERVER=1
-  -D MESHTASTIC_EXCLUDE_CANNEDMESSAGES=1
-  -D MESHTASTIC_EXCLUDE_INPUTBROKER=1
-  -D MAX_NUM_NODES=500
-  -D MAX_NUM_NODES_VIEW=500
-;  -DSOC_USB_OTG_SUPPORTED=1
-  -D CONFIG_DISABLE_HAL_LOCKS=1 ; "feels" to be a bit more stable without locks
-;  -D INPUTDRIVER_BUTTON_TYPE=0
-  -D HAS_SDCARD
-  -D HAS_SD_MMC
-  -D BOARD_MAX_SDMMC_FREQ=10000
-  -D BOARD_HAS_1BIT_SDMMC
-  -D SD_SCLK_PIN=43
-  -D SD_MISO_PIN=39
-  -D SD_MOSI_PIN=44
-  -D SD_MMC_HOST_SLOT=SDMMC_HOST_SLOT_0
-  -D HAS_SCREEN=1
-  -D HAS_TFT=1
-;  -D USE_I2S_BUZZER
-  -D RAM_SIZE=12288
-  -D LV_LVGL_H_INCLUDE_SIMPLE
-  -D LV_CONF_INCLUDE_SIMPLE
-  -D LV_COMP_CONF_INCLUDE_SIMPLE
-  -D LV_USE_SYSMON=1
-  -D LV_USE_PROFILER=0
-  -D LV_USE_PERF_MONITOR=1
-  -D LV_USE_MEM_MONITOR=0
-  -D LV_USE_LOG=0
-  -D LV_CACHE_DEF_SIZE=5600000
-  -D USE_LOG_DEBUG
-  -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
-  -D LORA_SPI_FREQUENCY=1000000
-  -D BOARD_LORA_MAX_TX_POWER=17
-  -D SX126X_CURRENT_LIMIT_MA=100
-  -D RADIOLIB_SPI_PARANOID=0
-  -D LGFX_SCREEN_WIDTH=1024
-  -D LGFX_SCREEN_HEIGHT=600
-  -D DISPLAY_SIZE=1024x600 ; landscape mode
-  -D LGFX_DRIVER=LGFX_ELECROW_P4_70_90_101
-  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_ELECROW_P4_70_90_101.h\"
-  -D LGFX_BUFSIZE=614400
-  -D VIEW_320x240
-  -D DISPLAY_SET_RESOLUTION
-  -D USE_PACKET_API
-;  -D MAP_FULL_REDRAW
-
-lib_deps =
-  ${esp32p4_base.lib_deps}
-  ${device-ui_base.lib_deps}
-  https://github.com/lovyan03/LovyanGFX#develop
-
-custom_sdkconfig =
-  ${esp32p4_base.custom_sdkconfig}
-  CONFIG_SOC_SDMMC_IO_POWER_EXTERNAL=n
-  # CONFIG_BT_BLE_50_FEATURES_SUPPORTED is not set
-  CONFIG_BT_BLE_42_FEATURES_SUPPORTED=y
-  # SDIO Slot 1 via GPIO matrix
-  CONFIG_ESP_HOSTED_SDIO_SLOT_1=y
-  
-  # 1-bit bus (proven stable on CrowPanel)
-  CONFIG_ESP_HOSTED_SDIO_1_BIT_BUS=y
-  CONFIG_ESP_HOSTED_SDIO_BUS_WIDTH=1
-  
-  # Conservative 10 MHz clock for OTA reliability
-  CONFIG_ESP_HOSTED_SDIO_CLOCK_FREQ_KHZ=10000
-  
-  # CrowPanel SDIO pins (happen to match P4 Slot 1 defaults)
-  CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_CLK_SLOT_1=18
-  CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_CMD_SLOT_1=19
-  CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D0_SLOT_1=14
-  CONFIG_ESP_HOSTED_PRIV_SDIO_PIN_D1_1BIT_BUS_SLOT_1=15
-  
-  # Reset pin: GPIO32, active high (R77 pullup on CrowPanel)
-  CONFIG_ESP_HOSTED_SDIO_RESET_ACTIVE_HIGH=y
-  CONFIG_ESP_HOSTED_SDIO_GPIO_RESET_SLAVE=32
-  CONFIG_ESP_HOSTED_GPIO_SLAVE_RESET_SLAVE=32
@@ -1,23 +0,0 @@
-#include "variant.h"
-#include "Arduino.h"
-#include <esp32-hal-periman.h>
-
-extern "C" void initVariant(void)
-{
-#if defined(CONFIG_IDF_TARGET_ESP32P4) && defined(BOARD_SDMMC_POWER_PIN)
-    // Ensure setLDOPower() exits early for this board family.
-    // On ESP32-P4, Arduino SPI may attempt SDMMC on-chip LDO setup when SPI uses
-    // pins that match SDMMC slot0 IOMUX pins (for example, GPIO 47/48 on p4-50).
-    // Pre-tagging BOARD_SDMMC_POWER_PIN as "SDMMC POWER" short-circuits that path.
-    if (perimanPinIsValid(BOARD_SDMMC_POWER_PIN)) {
-        pinMode(BOARD_SDMMC_POWER_PIN, OUTPUT);
-        digitalWrite(BOARD_SDMMC_POWER_PIN, BOARD_SDMMC_POWER_ON_LEVEL);
-
-        if (perimanGetPinBusType(BOARD_SDMMC_POWER_PIN) != ESP32_BUS_TYPE_MAX &&
-            perimanGetPinBusExtraType(BOARD_SDMMC_POWER_PIN) == nullptr) {
-            perimanSetPinBusExtraType(BOARD_SDMMC_POWER_PIN, "");
-        }
-        perimanSetPinBusExtraType(BOARD_SDMMC_POWER_PIN, "SDMMC POWER");
-    }
-#endif
-}
@@ -1,54 +0,0 @@
-#define HAS_WIRE 0
-#define I2C_SDA1 45
-#define I2C_SCL1 46
-
-#define USE_POWERSAVE
-#define WAKE_ON_TOUCH
-#define SCREEN_TOUCH_INT 42
-#define SLEEP_TIME 180
-
-#if defined(CROWPANEL_ADV_P4_50)
-
-// use UART3-IN for GPS (UART1 can not work with lora)
-#define GPS_DEFAULT_NOT_PRESENT 1
-#define GPS_RX_PIN 28
-#define GPS_TX_PIN 27
-
-// LoRa
-#define USE_SX1262
-#define LORA_SCK 26
-#define LORA_MISO 47
-#define LORA_MOSI 48
-#define LORA_CS 30
-#define LORA_RESET 32
-
-#define SX126X_CS LORA_CS
-#define SX126X_DIO1 31
-#define SX126X_BUSY 29
-#define SX126X_RESET LORA_RESET
-#define SX126X_DIO2_AS_RF_SWITCH
-#define SX126X_DIO3_TCXO_VOLTAGE 3.3
-
-#elif defined(CROWPANEL_ADV_P4_70_90_101)
-
-// use UART1 for GPS
-#define GPS_DEFAULT_NOT_PRESENT 1
-#define GPS_RX_PIN 48
-#define GPS_TX_PIN 47
-
-// LoRa
-#define USE_SX1262
-#define LORA_SCK 8
-#define LORA_MISO 7
-#define LORA_MOSI 6
-#define LORA_CS 10
-#define LORA_RESET 54
-
-#define SX126X_CS LORA_CS
-#define SX126X_DIO1 53
-#define SX126X_BUSY 9
-#define SX126X_RESET LORA_RESET
-#define SX126X_DIO2_AS_RF_SWITCH
-#define SX126X_DIO3_TCXO_VOLTAGE 3.3
-
-#endif
@@ -1,110 +0,0 @@
-[esp32p4_base]
-extends = esp32_common
-custom_esp32_kind = esp32p4
-board_build.mcu = esp32p4
-
-build_unflags=
-  -DHAS_UDP_MULTICAST=1
-
-build_flags =
-  ${esp32_common.build_flags}
-  -DMESHTASTIC_EXCLUDE_WIFI=1 ; TODO
-  -DMESHTASTIC_EXCLUDE_MQTT=1
-  -DMESHTASTIC_EXCLUDE_PAXCOUNTER=1
-
-build_src_filter = 
-  ${esp32_common.build_src_filter} -<libpax/> -<platform/stm32wl> -<nimble> -<mesh/http/> -<platform/rp2xx0> -<mesh/raspihttp> -<serialization/>
-
-extra_scripts =
-  ${esp32_common.extra_scripts}
-  extra_scripts/ld_response_file.py
-
-; Override esp32_common component pruning: keep esp_hosted + esp_wifi_remote for P4 hosted BT
-custom_component_remove =
-  espressif/esp_modem
-  espressif/esp-dsp
-  espressif/esp32-camera
-  espressif/libsodium
-  espressif/esp-modbus
-  espressif/qrcode
-  espressif/esp_insights
-  espressif/esp_diag_data_store
-  espressif/esp_diagnostics
-  espressif/esp_rainmaker
-  espressif/rmaker_common
-  espressif/network_provisioning
-  chmorgan/esp-libhelix-mp3
-  espressif/esp-tflite-micro
-  espressif/esp-sr
-  espressif/esp_matter
-  espressif/esp-zboss-lib
-  espressif/esp-zigbee-lib
-  espressif/mqtt
-
-custom_sdkconfig =
-  ${esp32_common.custom_sdkconfig}
-  CONFIG_ARDUINO_SELECTIVE_SD_MMC=y
-  CONFIG_BT_CONTROLLER_DISABLED=y
-  CONFIG_ESP_WIFI_REMOTE_ENABLED=y
-  # esp_hosted core
-  CONFIG_ESP_HOSTED_ENABLED=y
-  # Board: custom (not Espressif EV board)
-  CONFIG_ESP_HOSTED_P4_DEV_BOARD_NONE=y
-  # Delay after C6 reset to allow boot (e.g. old v2.3.0 may be slow)
-  CONFIG_ESP_HOSTED_SDIO_RESET_DELAY_MS=1500
-  CONFIG_ESP_HOSTED_SDIO_OPTIMIZATION_RX_STREAMING_MODE=y
-  CONFIG_ESP_HOSTED_SDIO_HOST_INTERFACE=y
-  CONFIG_ESP_HOSTED_IDF_SLAVE_TARGET="esp32c6"
-  CONFIG_ESP_HOSTED_CP_TARGET_ESP32C6=y
-  CONFIG_ESP_HOSTED_CP_TARGET_ESP32H2=n
-  CONFIG_ESP_HOSTED_PRIV_SDIO_OPTION=y
-  CONFIG_ESP_HOSTED_SPI_HOST_INTERFACE=n
-  CONFIG_ESP_HOSTED_TRANSPORT_SDIO=y
-  CONFIG_ESP_HOSTED_ENABLE_NIMBLE=y
-  CONFIG_ESP_HOSTED_ENABLE_BT_NIMBLE=y
-  CONFIG_ESP_HOSTED_NIMBLE_HCI_VHCI=y
-  CONFIG_ESP_HOSTED_ENABLE_PEER_DATA_TRANSFER=y
-  CONFIG_ESP_HOSTED_MAX_CUSTOM_MSG_HANDLERS=3
-  # OTA method: LittleFS
-  CONFIG_OTA_METHOD_LITTLEFS=y
-
-  # Skip version check — we force OTA regardless
-  # CONFIG_OTA_VERSION_CHECK_HOST_SLAVE is not set
-  # CONFIG_OTA_VERSION_CHECK_SLAVEFW_SLAVE is not set
-
-  # RX streaming mode
-  CONFIG_ESP_HOSTED_SLAVE_RESET_ON_EVERY_HOST_BOOTUP=y
-  ;CONFIG_ESP_HOSTED_SLAVE_RESET_ONLY_IF_NECESSARY=y
-  # SOC_LCD (MUI / lovyanGFX)
-  CONFIG_SOC_LCD_I80_SUPPORTED=y
-  CONFIG_SOC_LCD_RGB_SUPPORTED=y
-  CONFIG_SOC_MIPI_DSI_SUPPORTED=y
-  # stack dump
-  CONFIG_ESP_SYSTEM_PANIC_PRINT_HALT=y ; remove for production version
-  ;CONFIG_ESP_SYSTEM_PANIC_PRINT_REBOOT=y; for production version
-  ;CONFIG_ESP_SYSTEM_PANIC_GDBSTUB=y ; for target debugging
-  # Logger: verbose for experiment
-  CONFIG_LOG_DEFAULT_LEVEL_INFO=y
-  CONFIG_LOG_MAXIMUM_LEVEL_DEBUG=y
-
-
-lib_ignore =
-  ${esp32_common.lib_ignore}
-  libpax
-  esp8266-oled-ssd1306
-  bsec2
-  esp32_idf5_https_server
-  esp_driver_cam
-  esp_http_server
-
-; Override lib_deps to exclude environmental_extras
-lib_deps =
-  ${arduino_base.lib_deps}
-  ${networking_base.lib_deps}
-  ${networking_extra.lib_deps}
-  ${environmental_base.lib_deps}
-  ${radiolib_base.lib_deps}
-  # renovate: datasource=custom.pio depName=rweather/Crypto packageName=rweather/library/Crypto
-  rweather/Crypto@0.4.0
-  # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
-  https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
@@ -12,18 +12,13 @@ build_flags =
  -DHAS_BLUETOOTH=0
  -DMESHTASTIC_EXCLUDE_PAXCOUNTER
  -DMESHTASTIC_EXCLUDE_BLUETOOTH
-  -mtext-section-literals
-
-custom_sdkconfig =
-  ${esp32_common.custom_sdkconfig}
-
-lib_ignore = 
-  ${esp32_common.lib_ignore}
-  NimBLE-Arduino
-  libpax

 lib_deps =
  ${esp32_common.lib_deps}
  # renovate: datasource=git-refs depName=meshtastic-ESP32_Codec2 packageName=https://github.com/meshtastic/ESP32_Codec2 gitBranch=master
  https://github.com/meshtastic/ESP32_Codec2/archive/633326c78ac251c059ab3a8c430fcdf25b41672f.zip
-  
+
+lib_ignore = 
+  ${esp32_common.lib_ignore}
+  NimBLE-Arduino
+  libpax
@@ -7,7 +7,7 @@
 #define BUTTON_PIN 0 // BOOT button

 #define BATTERY_PIN 1
-#define ADC_CHANNEL ADC_CHANNEL_0
+#define ADC_CHANNEL ADC1_GPIO1_CHANNEL
 #define ADC_MULTIPLIER 103.0 // Calibrated value
 #define ADC_ATTENUATION ADC_ATTEN_DB_0
 #define ADC_CTRL 37
@@ -18,7 +18,7 @@

 // Battery voltage monitoring - TODO: test, currently untested, copied from T3S3 variant
 #define BATTERY_PIN 1 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC_CHANNEL_0
+#define ADC_CHANNEL ADC1_GPIO1_CHANNEL
 #define ADC_MULTIPLIER                                                                                                           \
    2.11 // ratio of voltage divider = 2.0 (R10=1M, R13=1M), plus some undervoltage correction - TODO: this was carried over from
         // the T3S3, test to see if the undervoltage correction is needed.
@@ -40,8 +40,8 @@
 // Battery
 // #define BATTERY_PIN 2
 #define BATTERY_PIN 17
-// #define ADC_CHANNEL ADC_CHANNEL_1
-#define ADC_CHANNEL ADC_CHANNEL_6
+// #define ADC_CHANNEL ADC1_GPIO2_CHANNEL
+#define ADC_CHANNEL ADC2_GPIO17_CHANNEL
 #define BATTERY_SENSE_RESOLUTION_BITS 12
 #define BATTERY_SENSE_RESOLUTION 4096.0
 #undef AREF_VOLTAGE
@@ -16,7 +16,7 @@
 // USB_CHECK
 #define EXT_PWR_DETECT 12
 #define BATTERY_PIN 8
-#define ADC_CHANNEL ADC_CHANNEL_7
+#define ADC_CHANNEL ADC1_GPIO8_CHANNEL

 #define ADC_MULTIPLIER 2.0 // 2.0 + 10% for correction of display undervoltage.

@@ -17,7 +17,7 @@
 // #define BATTERY_PIN 1 // A battery voltage measurement pin, voltage divider connected here to
 //  measure battery voltage ratio of voltage divider = 2.0 (assumption)
 // #define ADC_MULTIPLIER 2.11 // 2.0 + 10% for correction of display undervoltage.
-// #define ADC_CHANNEL ADC_CHANNEL_0
+// #define ADC_CHANNEL ADC1_GPIO1_CHANNEL

 #define I2C_SDA SDA // 21
 #define I2C_SCL SCL // 15
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jonathan Bennett	7555242661	Merge branch 'develop' into serialHal	2026-05-04 22:10:48 -05:00
Jonathan Bennett	c5a8fbc157	Merge branch 'develop' into serialHal	2026-05-04 13:09:22 -05:00
Jonathan Bennett	fbccf910d4	and fix it on esp32 again	2026-04-30 16:03:35 -05:00
Jonathan Bennett	b02193f341	Compile on 2040	2026-04-30 15:45:36 -05:00
Jonathan Bennett	097f77cbcf	Seitch to concurrency over std::mutex for platform agnostic behavior	2026-04-30 15:21:42 -05:00
Jonathan Bennett	8995a68b07	Merge branch 'develop' into serialHal	2026-04-30 10:54:42 -05:00
Ben Meadors	ebe6ddc7aa	Merge branch 'develop' into serialHal	2026-04-30 06:12:30 -05:00
Jonathan Bennett	b27f80131a	Merge branch 'develop' into serialHal	2026-04-30 00:44:52 -05:00
Jonathan Bennett	e3d68645c1	Initial implementation of serialHal	2026-04-30 00:37:00 -05:00