Log the CCCD write status as a signed int and name the handle

The neutral write callback reports an int status, so %x printed
errno-style negatives as ffffff..; include the failing handle too.
Also correct the hex buffer comment: the size comes from the V2
minimum payload, not the longest message.

CODEOWNERS

@@ -439,6 +439,7 @@ esphome/components/ota/* @esphome/core
 esphome/components/output/* @esphome/core
 esphome/components/packet_transport/* @clydebarrow
 esphome/components/pca6416a/* @Mat931
+esphome/components/pca9505/* @ajfriesen @ssieb
 esphome/components/pca9554/* @bdraco @clydebarrow @hwstar
 esphome/components/pcf85063/* @brogon
 esphome/components/pcf8563/* @KoenBreeman

esphome/components/bedjet/bedjet_const.h

@@ -1,10 +1,11 @@
 #pragma once
 
 #include <set>
+#include "esphome/core/log.h"
 
 namespace esphome::bedjet {
 
-static const char *const TAG = "bedjet";
+ESPHOME_LOG_TAG(TAG, "bedjet");
 
 /// Converts a BedJet fan step to a speed percentage, in the range of 5% to 100%.
 inline static uint8_t bedjet_fan_step_to_speed(const uint8_t fan) {

esphome/components/ble_client/__init__.py

@@ -1,8 +1,23 @@
+from collections.abc import Callable
+import functools
+from typing import Any
+
 from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
-from esphome.components import esp32_ble, esp32_ble_client, esp32_ble_tracker
-from esphome.components.esp32_ble import BTLoggers
+from esphome.components import ble_device_base, bluetooth_connection
+from esphome.components.ble_device_base import (
+    BT_UUID16_FORMAT as bt_uuid16_format,
+    BT_UUID32_FORMAT as bt_uuid32_format,
+    BT_UUID128_FORMAT as bt_uuid128_format,
+    as_hex,
+    as_reversed_hex_array,
+    bt_uuid,
+)
+from esphome.config_helpers import (
+    filter_source_files_from_platform,
+    frameworks_for_platforms,
+)
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHARACTERISTIC_UUID,
@@ -15,15 +30,55 @@ from esphome.const import (
     CONF_SERVICE_UUID,
     CONF_TRIGGER_ID,
     CONF_VALUE,
+    PLATFORM_ESP32,
+    PlatformFramework,
 )
-from esphome.core import ID
+from esphome.core import CORE, ID
+from esphome.enum import StrEnum
+from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
 from esphome.types import ConfigType
 
-AUTO_LOAD = ["esp32_ble_client"]
+# The esp32 BLE stack (esp32_ble, esp32_ble_tracker) is imported lazily inside
+# the esp32 schema/codegen arms: importing those modules registers esp32-only
+# automations as a side effect, which must not leak into the neutral
+# platforms' registries (the bluetooth_proxy pattern).
+
+
+def _legacy_engine() -> bool:
+    """True when the build uses the legacy raw-gattc engine - one line to
+    flip when esp32 moves to the neutral engine (with
+    USE_BLE_CLIENT_LEGACY_ENGINE in _to_code_esp32)."""
+    return CORE.is_esp32
+
+
+def AUTO_LOAD() -> list[str]:
+    """The engine's closure per platform: the legacy esp32 engine builds on
+    esp32_ble_client plus bluetooth_connection (the shared service-table
+    materializer; its sources compile empty in builds without a neutral
+    node), the neutral engine on the bluetooth_connection backend. The
+    platform-less arm is the union for manifest-resolving tooling."""
+    if _legacy_engine() or CORE.target_platform is None:
+        return ["bluetooth_connection", "esp32_ble_client"]
+    return ["bluetooth_connection"]
+
+
 CODEOWNERS = ["@buxtronix", "@clydebarrow"]
-DEPENDENCIES = ["esp32_ble_tracker"]
 DOMAIN = "ble_client"
 
+FILTER_SOURCE_FILES = filter_source_files_from_platform(
+    {
+        "ble_client.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
+        },
+        # Every framework of every non-esp32 registry platform: a platform
+        # that validates the neutral arm must also compile the neutral engine.
+        "ble_client_gatt.cpp": frameworks_for_platforms(
+            set(bluetooth_connection.GATT_CLIENT_PLATFORMS) - {PLATFORM_ESP32}
+        ),
+    }
+)
+
 CONF_DESCRIPTOR_UUID = "descriptor_uuid"
 CONF_ON_NOTIFY = "on_notify"
 
@@ -59,7 +114,9 @@ def notify_from_on_notify(config: ConfigType) -> ConfigType:
 
 
 ble_client_ns = cg.esphome_ns.namespace("ble_client")
-BLEClient = ble_client_ns.class_("BLEClient", esp32_ble_client.BLEClientBase)
+# One codegen class for both engines: the exclusively-gated headers resolve
+# the name to exactly one C++ definition per build.
+BLEClient = ble_client_ns.class_("BLEClient", cg.Component)
 BLEClientNode = ble_client_ns.class_("BLEClientNode")
 BLEClientNodeConstRef = BLEClientNode.operator("ref").operator("const")
 # Triggers
@@ -106,62 +163,179 @@ CONF_AUTO_CONNECT = "auto_connect"
 
 MULTI_CONF = True
 
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(BLEClient),
-            cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
-            cv.Optional(CONF_NAME): cv.string,
-            cv.Optional(CONF_AUTO_CONNECT, default=True): cv.boolean,
-            cv.Optional(CONF_ON_CONNECT): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        BLEClientConnectTrigger
-                    ),
-                }
-            ),
-            cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        BLEClientDisconnectTrigger
-                    ),
-                }
-            ),
-            cv.Optional(CONF_ON_PASSKEY_REQUEST): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        BLEClientPasskeyRequestTrigger
-                    ),
-                }
-            ),
-            cv.Optional(CONF_ON_PASSKEY_NOTIFICATION): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        BLEClientPasskeyNotificationTrigger
-                    ),
-                }
-            ),
-            cv.Optional(
-                CONF_ON_NUMERIC_COMPARISON_REQUEST
-            ): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        BLEClientNumericComparisonRequestTrigger
-                    ),
-                }
-            ),
-        }
+# Keys shared by both engines' schemas.
+_COMMON_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(BLEClient),
+        cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
+        cv.Optional(CONF_AUTO_CONNECT, default=True): cv.boolean,
+        cv.Optional(CONF_ON_CONNECT): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(BLEClientConnectTrigger),
+            }
+        ),
+        cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation(
+            {
+                cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                    BLEClientDisconnectTrigger
+                ),
+            }
+        ),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+
+@functools.cache
+def _esp32_config_schema() -> cv.All:
+    """The legacy engine's schema, byte-compatible with what esp32 always had
+    (including the Bluedroid security triggers)."""
+    from esphome.components import esp32_ble_tracker
+
+    return cv.All(
+        _COMMON_SCHEMA.extend(
+            {
+                # Accepted-but-unused legacy key; not propagated to the
+                # neutral schema.
+                cv.Optional(CONF_NAME): cv.string,
+                cv.Optional(CONF_ON_PASSKEY_REQUEST): automation.validate_automation(
+                    {
+                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                            BLEClientPasskeyRequestTrigger
+                        ),
+                    }
+                ),
+                cv.Optional(
+                    CONF_ON_PASSKEY_NOTIFICATION
+                ): automation.validate_automation(
+                    {
+                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                            BLEClientPasskeyNotificationTrigger
+                        ),
+                    }
+                ),
+                cv.Optional(
+                    CONF_ON_NUMERIC_COMPARISON_REQUEST
+                ): automation.validate_automation(
+                    {
+                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                            BLEClientNumericComparisonRequestTrigger
+                        ),
+                    }
+                ),
+            }
+        ).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA),
+        bluetooth_connection.consume_gatt_slot("ble_client"),
     )
-    .extend(cv.COMPONENT_SCHEMA)
-    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA),
-    esp32_ble.consume_connection_slots(1, "ble_client"),
-)
+
+
+@functools.cache
+def _gatt_config_schema(platform: str) -> cv.All:
+    """The neutral engine's schema: the shared keys plus the hub reference
+    (parsed-advertisement sightings) and the GATT backend declaration.
+    Keyed by platform - the backend fragment differs per platform."""
+    return cv.All(
+        _COMMON_SCHEMA.extend(ble_device_base.BLE_DEVICE_SCHEMA).extend(
+            bluetooth_connection.gatt_client_schema(platform)
+        ),
+        bluetooth_connection.consume_gatt_slot("ble_client"),
+    )
+
+
+@schema_extractor("schema")
+def _validate_platform(config: ConfigType) -> ConfigType:
+    if config is SCHEMA_EXTRACT:
+        # Deliberate gap (the bluetooth_proxy pattern): the dumper gets only
+        # this shape, so the neutral arm's ble_hub_id is absent from editor
+        # schemas and the esp32-only keys are advertised on every platform.
+        # The language-schema dumper runs without a platform; expose the
+        # esp32 (legacy-engine) shape.
+        return _esp32_config_schema()
+    if _legacy_engine():
+        return _esp32_config_schema()(config)
+    if CORE.target_platform in bluetooth_connection.GATT_CLIENT_PLATFORMS:
+        return _gatt_config_schema(CORE.target_platform)(config)
+    raise cv.Invalid(f"ble_client is not supported on {CORE.target_platform}")
+
+
+CONFIG_SCHEMA = _validate_platform
 
 CONF_BLE_CLIENT_ID = "ble_client_id"
 
+
+class BLEClientFeatures(StrEnum):
+    """Per-platform engine capabilities consumers declare against."""
+
+    # The platform-neutral node interface (on_connected/table + completion
+    # callbacks) - every platform with a ble_client engine.
+    GATT_NODE = "gatt_node"
+    # The raw esp32 GATT client event stream (gattc/gap handlers,
+    # node_state) - the legacy engine only.
+    RAW_GATTC = "raw_gattc"
+    # Pairing dialog replies and bond management (Bluedroid GAP/SMP).
+    SECURITY = "security"
+
+
+def _engine_features() -> set[BLEClientFeatures]:
+    """Features the validated platform's engine provides."""
+    if _legacy_engine():
+        return {
+            BLEClientFeatures.GATT_NODE,
+            BLEClientFeatures.RAW_GATTC,
+            BLEClientFeatures.SECURITY,
+        }
+    if CORE.target_platform in bluetooth_connection.GATT_CLIENT_PLATFORMS:
+        return {BLEClientFeatures.GATT_NODE}
+    return set()
+
+
+def requires_feature(
+    feature: BLEClientFeatures, description: str
+) -> Callable[[Any], Any]:
+    """Validator gating a consumer to platforms whose engine provides
+    `feature`, naming the missing capability in the error."""
+
+    def validator(value: Any) -> Any:
+        features = _engine_features()
+        if feature not in features:
+            available = (
+                f"; this platform's engine provides: {', '.join(sorted(features))}"
+                if features
+                else ""
+            )
+            raise cv.Invalid(
+                f"{description} requires the ble_client '{feature}' feature, "
+                f"which {CORE.target_platform} does not provide{available}"
+            )
+        return value
+
+    return validator
+
+
+# The one choke point for every node component still on the raw esp32 event
+# stream; migrating to the neutral interface (NODE_BLE_CLIENT_SCHEMA +
+# register_gatt_node) lifts it.
+_legacy_engine_only = requires_feature(
+    BLEClientFeatures.RAW_GATTC,
+    "This component drives the raw ESP32 GATT client events and has not "
+    "been migrated to the platform-neutral node interface yet; it",
+)
+
 BLE_CLIENT_SCHEMA = cv.Schema(
     {
-        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.use_id(BLEClient),
+        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.All(
+            cv.use_id(BLEClient), _legacy_engine_only
+        ),
+    }
+)
+
+# For node components on the neutral interface: valid wherever ble_client
+# itself is.
+NODE_BLE_CLIENT_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.All(
+            cv.use_id(BLEClient),
+            requires_feature(BLEClientFeatures.GATT_NODE, "This component"),
+        ),
     }
 )
 
@@ -171,11 +345,31 @@ async def register_ble_node(var, config):
     cg.add(parent.register_ble_node(var))
 
 
+def _request_gatt_node_build() -> None:
+    """Node storage and the one define meaning "the neutral node surface is
+    compiled in", plus the esp32 bridge/materializer defines."""
+    _request_node_slot()
+    cg.add_define("USE_BLE_CLIENT_GATT_NODES")
+    if _legacy_engine():
+        # Deliberately not ble_device_base.request_gatt_client(): that would
+        # claim a phantom backend slot on combined proxy builds.
+        cg.add_define("USE_BLE_GATT_CLIENT")
+        cg.add_define("USE_BLE_GATT_BACKEND_BLUEDROID")
+        cg.add_define("USE_BLUEDROID_GATT_SERVICE_TABLE")
+
+
+async def register_gatt_node(var, config):
+    """Register a node on the platform-neutral interface (both engines)."""
+    parent = await cg.get_variable(config[CONF_BLE_CLIENT_ID])
+    _request_gatt_node_build()
+    cg.add(parent.register_gatt_node(var))
+
+
 BLE_WRITE_ACTION_SCHEMA = cv.Schema(
     {
         cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-        cv.Required(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
-        cv.Required(CONF_CHARACTERISTIC_UUID): esp32_ble_tracker.bt_uuid,
+        cv.Required(CONF_SERVICE_UUID): bt_uuid,
+        cv.Required(CONF_CHARACTERISTIC_UUID): bt_uuid,
         cv.Required(CONF_VALUE): cv.templatable(cv.ensure_list(cv.hex_uint8_t)),
     }
 )
@@ -186,25 +380,34 @@ BLE_CONNECT_ACTION_SCHEMA = maybe_simple_id(
     }
 )
 
-BLE_NUMERIC_COMPARISON_REPLY_ACTION_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-        cv.Required(CONF_ACCEPT): cv.templatable(cv.boolean),
-    }
+BLE_NUMERIC_COMPARISON_REPLY_ACTION_SCHEMA = cv.All(
+    requires_feature(BLEClientFeatures.SECURITY, "This action"),
+    cv.Schema(
+        {
+            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+            cv.Required(CONF_ACCEPT): cv.templatable(cv.boolean),
+        }
+    ),
 )
 
-BLE_PASSKEY_REPLY_ACTION_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-        cv.Required(CONF_PASSKEY): cv.templatable(cv.int_range(min=0, max=999999)),
-    }
+BLE_PASSKEY_REPLY_ACTION_SCHEMA = cv.All(
+    requires_feature(BLEClientFeatures.SECURITY, "This action"),
+    cv.Schema(
+        {
+            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+            cv.Required(CONF_PASSKEY): cv.templatable(cv.int_range(min=0, max=999999)),
+        }
+    ),
 )
 
 
-BLE_REMOVE_BOND_ACTION_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-    }
+BLE_REMOVE_BOND_ACTION_SCHEMA = cv.All(
+    requires_feature(BLEClientFeatures.SECURITY, "This action"),
+    cv.Schema(
+        {
+            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+        }
+    ),
 )
 
 
@@ -232,6 +435,8 @@ automation.register_simple_action(
 )
 async def ble_write_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
+    # The action registers itself as a neutral node in its constructor.
+    _request_gatt_node_build()
     var = cg.new_Pvariable(action_id, template_arg, parent)
 
     value = config[CONF_VALUE]
@@ -246,38 +451,20 @@ async def ble_write_to_code(config, action_id, template_arg, args):
         arr = cg.static_const_array(arr_id, cg.ArrayInitializer(*value))
         cg.add(var.set_value_simple(arr, len(value)))
 
-    if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
-        cg.add(
-            var.set_service_uuid16(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
-        )
-    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid32_format):
-        cg.add(
-            var.set_service_uuid32(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
-        )
-    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid128_format):
-        uuid128 = esp32_ble_tracker.as_reversed_hex_array(config[CONF_SERVICE_UUID])
+    if len(config[CONF_SERVICE_UUID]) == len(bt_uuid16_format):
+        cg.add(var.set_service_uuid16(as_hex(config[CONF_SERVICE_UUID])))
+    elif len(config[CONF_SERVICE_UUID]) == len(bt_uuid32_format):
+        cg.add(var.set_service_uuid32(as_hex(config[CONF_SERVICE_UUID])))
+    elif len(config[CONF_SERVICE_UUID]) == len(bt_uuid128_format):
+        uuid128 = as_reversed_hex_array(config[CONF_SERVICE_UUID])
         cg.add(var.set_service_uuid128(uuid128))
 
-    if len(config[CONF_CHARACTERISTIC_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
-        cg.add(
-            var.set_char_uuid16(
-                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
-            )
-        )
-    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
-        esp32_ble_tracker.bt_uuid32_format
-    ):
-        cg.add(
-            var.set_char_uuid32(
-                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
-            )
-        )
-    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
-        esp32_ble_tracker.bt_uuid128_format
-    ):
-        uuid128 = esp32_ble_tracker.as_reversed_hex_array(
-            config[CONF_CHARACTERISTIC_UUID]
-        )
+    if len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid16_format):
+        cg.add(var.set_char_uuid16(as_hex(config[CONF_CHARACTERISTIC_UUID])))
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid32_format):
+        cg.add(var.set_char_uuid32(as_hex(config[CONF_CHARACTERISTIC_UUID])))
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid128_format):
+        uuid128 = as_reversed_hex_array(config[CONF_CHARACTERISTIC_UUID])
         cg.add(var.set_char_uuid128(uuid128))
 
     return var
@@ -331,14 +518,45 @@ automation.register_simple_action(
 )
 
 
-async def to_code(config):
+async def _to_code_esp32(config: ConfigType) -> cg.MockObj:
+    from esphome.components import esp32_ble, esp32_ble_tracker
+    from esphome.components.esp32_ble import BTLoggers
+
     # Register the loggers this component needs
     esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.SMP)
     cg.add_define("USE_ESP32_BLE_UUID")
+    cg.add_define("USE_BLE_CLIENT_LEGACY_ENGINE")
 
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await esp32_ble_tracker.register_client(var, config)
+    return var
+
+
+# Sizes the neutral client's node storage; the client itself requests a
+# baseline slot so the define exists on every build that compiles the engine.
+_request_node_slot = cg.slot_counter("ESPHOME_BLE_CLIENT_MAX_NODES")
+
+
+async def _to_code_gatt(config: ConfigType) -> cg.MockObj:
+    # The engine always carries the node surface (the client itself owns the
+    # baseline slot).
+    _request_gatt_node_build()
+    backend = await bluetooth_connection.new_gatt_backend(config)
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    cg.add(var.set_backend(backend))
+    # Sighting-gated connects: the client listens for the peer's parsed
+    # advertisements through the hub.
+    await ble_device_base.register_ble_device(var, config)
+    return var
+
+
+async def to_code(config: ConfigType) -> None:
+    if _legacy_engine():
+        var = await _to_code_esp32(config)
+    else:
+        var = await _to_code_gatt(config)
     cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
     cg.add(var.set_auto_connect(config[CONF_AUTO_CONNECT]))
     for conf in config.get(CONF_ON_CONNECT, []):

esphome/components/ble_client/automation.cpp

@@ -1,11 +0,0 @@
-#ifdef USE_ESP32
-
-#include "automation.h"
-
-namespace esphome::ble_client {
-
-const char *const Automation::TAG = "ble_client.automation";
-
-}  // namespace esphome::ble_client
-
-#endif

esphome/components/ble_client/automation.h

@@ -1,27 +1,14 @@
 #pragma once
 
-#ifdef USE_ESP32
+#include "esphome/core/defines.h"
 
-#include <utility>
-#include <vector>
+#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
 
 #include "esphome/core/automation.h"
 #include "esphome/components/ble_client/ble_client.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-// Maximum bytes to log in hex format for BLE writes (many logging buffers are 256 chars)
-static constexpr size_t BLE_WRITE_MAX_LOG_BYTES = 64;
 
 namespace esphome::ble_client {
 
-// placeholder class for static TAG .
-class Automation {
- public:
-  // could be made inline with C++17
-  static const char *const TAG;
-};
-
 // Base for nodes that never read the parent's services.
 // The parent releases its services only once every node reports Established, so a node that never
 // reports it keeps that memory allocated for the life of the connection.
@@ -110,144 +97,6 @@ class BLEClientNumericComparisonRequestTrigger final : public Trigger<uint32_t>,
   }
 };
 
-// implement the ble_client.ble_write action.
-template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>, public BLEClientNode {
- public:
-  BLEClientWriteAction(BLEClient *ble_client) {
-    ble_client->register_ble_node(this);
-    ble_client_ = ble_client;
-  }
-
-  void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
-  void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
-  void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
-
-  void set_char_uuid16(uint16_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
-  void set_char_uuid32(uint32_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
-  void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
-
-  void set_value_template(std::vector<uint8_t> (*func)(Ts...)) {
-    this->value_.func = func;
-    this->len_ = -1;  // Sentinel value indicates template mode
-  }
-
-  // Store pointer to static data in flash (no RAM copy)
-  void set_value_simple(const uint8_t *data, size_t len) {
-    this->value_.data = data;
-    this->len_ = len;  // Length >= 0 indicates static mode
-  }
-
-  void play(const Ts &...x) override {}
-
-  void play_complex(const Ts &...x) override {
-    this->num_running_++;
-    this->var_ = std::make_tuple(x...);
-
-    bool result;
-    if (this->len_ >= 0) {
-      // Static mode: write directly from flash pointer
-      result = this->write(this->value_.data, this->len_);
-    } else {
-      // Template mode: call function and write the vector
-      std::vector<uint8_t> value = this->value_.func(x...);
-      result = this->write(value);
-    }
-
-    // on write failure, continue the automation chain rather than stopping so that e.g. disconnect can work.
-    if (!result)
-      this->play_next_(x...);
-  }
-
-  /**
-   * Note about logging: the esph_log_X macros are used here because the CI checks complain about use of the ESP LOG
-   * macros in header files (Can't even write it in a comment!)
-   * Not sure why, because they seem to work just fine.
-   * The problem is that the implementation of a templated class can't be placed in a .cpp file when using C++ less than
-   * 17, so the methods have to be here.  The esph_log_X macros are equivalent in function, but don't trigger the CI
-   * errors.
-   */
-  // initiate the write. Return true if all went well, will be followed by a WRITE_CHAR event.
-  bool write(const uint8_t *data, size_t len) {
-    if (this->node_state != espbt::ClientState::ESTABLISHED) {
-      esph_log_w(Automation::TAG, "Cannot write to BLE characteristic - not connected");
-      return false;
-    }
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
-    char hex_buf[format_hex_pretty_size(BLE_WRITE_MAX_LOG_BYTES)];
-    esph_log_vv(Automation::TAG, "Will write %d bytes: %s", len, format_hex_pretty_to(hex_buf, data, len));
-#endif
-    esp_err_t err =
-        esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->char_handle_, len,
-                                 const_cast<uint8_t *>(data), this->write_type_, ESP_GATT_AUTH_REQ_NONE);
-    if (err != ESP_OK) {
-      esph_log_e(Automation::TAG, "Error writing to characteristic: %s!", esp_err_to_name(err));
-      return false;
-    }
-    return true;
-  }
-
-  bool write(const std::vector<uint8_t> &value) { return this->write(value.data(), value.size()); }
-
-  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
-                           esp_ble_gattc_cb_param_t *param) override {
-    switch (event) {
-      case ESP_GATTC_WRITE_CHAR_EVT:
-        // upstream code checked the MAC address, verify the characteristic.
-        if (param->write.handle == this->char_handle_)
-          this->parent()->run_later([this]() { this->play_next_tuple_(this->var_); });
-        break;
-      case ESP_GATTC_DISCONNECT_EVT:
-        if (this->num_running_ != 0)
-          this->stop_complex();
-        break;
-      case ESP_GATTC_SEARCH_CMPL_EVT: {
-        auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->char_uuid_);
-        if (chr == nullptr) {
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          char service_buf[esp32_ble::UUID_STR_LEN];
-          esph_log_w("ble_write_action", "Characteristic %s was not found in service %s",
-                     this->char_uuid_.to_str(char_buf), this->service_uuid_.to_str(service_buf));
-          break;
-        }
-        this->char_handle_ = chr->handle;
-        this->char_props_ = chr->properties;
-        if (this->char_props_ & ESP_GATT_CHAR_PROP_BIT_WRITE) {
-          this->write_type_ = ESP_GATT_WRITE_TYPE_RSP;
-          esph_log_d(Automation::TAG, "Write type: ESP_GATT_WRITE_TYPE_RSP");
-        } else if (this->char_props_ & ESP_GATT_CHAR_PROP_BIT_WRITE_NR) {
-          this->write_type_ = ESP_GATT_WRITE_TYPE_NO_RSP;
-          esph_log_d(Automation::TAG, "Write type: ESP_GATT_WRITE_TYPE_NO_RSP");
-        } else {
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          esph_log_e(Automation::TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_str(char_buf));
-          break;
-        }
-        this->node_state = espbt::ClientState::ESTABLISHED;
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        esph_log_d(Automation::TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
-                   ble_client_->address_str());
-        break;
-      }
-      default:
-        break;
-    }
-  }
-
- private:
-  BLEClient *ble_client_;
-  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
-  union Value {
-    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
-    const uint8_t *data;                  // Pointer to static data in flash
-  } value_;
-  espbt::ESPBTUUID service_uuid_;
-  espbt::ESPBTUUID char_uuid_;
-  std::tuple<Ts...> var_{};
-  uint16_t char_handle_{};
-  esp_gatt_char_prop_t char_props_{};
-  esp_gatt_write_type_t write_type_{};
-};
-
 template<typename... Ts> class BLEClientPasskeyReplyAction final : public Action<Ts...> {
  public:
   BLEClientPasskeyReplyAction(BLEClient *ble_client) { parent_ = ble_client; }

esphome/components/ble_client/automation_gatt.h

@@ -0,0 +1,118 @@
+// Neutral twins of the shared ble_client automations. Class names, namespace,
+// and codegen-visible signatures are IDENTICAL to automation.h so generated
+// main.cpp compiles against whichever engine the build gates in; only the
+// internals differ (client callbacks and the neutral node interface instead
+// of raw gattc events). The Bluedroid-security automations (passkey, numeric
+// comparison, remove bond) have no neutral equivalent and stay esp32-only.
+
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#if defined(USE_BLE_GATT_CLIENT) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
+
+#include <tuple>
+
+#include "ble_client_gatt.h"
+#include "esphome/core/automation.h"
+
+namespace esphome::ble_client {
+
+class BLEClientConnectTrigger final : public Trigger<> {
+ public:
+  explicit BLEClientConnectTrigger(BLEClient *parent) {
+    parent->add_on_connect_callback([this]() { this->trigger(); });
+  }
+};
+
+class BLEClientDisconnectTrigger final : public Trigger<> {
+ public:
+  explicit BLEClientDisconnectTrigger(BLEClient *parent) {
+    // Fires only after a completed connection (never for failed attempts),
+    // matching the legacy CLOSE_EVT semantics.
+    parent->add_on_disconnect_callback([this]() { this->trigger(); });
+  }
+};
+
+template<typename... Ts> class BLEClientConnectAction final : public Action<Ts...> {
+ public:
+  BLEClientConnectAction(BLEClient *ble_client) {
+    ble_client_ = ble_client;
+    ble_client->add_on_connect_callback([this]() {
+      if (this->num_running_ != 0)
+        this->play_next_tuple_(this->var_);
+    });
+    // A connect attempt that dies (or a later disconnect) terminates the
+    // chain, mirroring the legacy DISCONNECT_EVT handling.
+    ble_client->add_on_connect_failed_callback([this]() {
+      if (this->num_running_ != 0)
+        this->stop_complex();
+    });
+    ble_client->add_on_disconnect_callback([this]() {
+      if (this->num_running_ != 0)
+        this->stop_complex();
+    });
+  }
+
+  // not used since we override play_complex_
+  void play(const Ts &...x) override {}
+
+  void play_complex(const Ts &...x) override {
+    // it makes no sense to have multiple instances of this running at the
+    // same time; cancel a re-trigger while still running.
+    if (this->num_running_ != 0) {
+      this->stop_complex();
+      return;
+    }
+    this->num_running_++;
+    if (this->ble_client_->connected()) {
+      this->play_next_(x...);
+    } else {
+      this->var_ = std::make_tuple(x...);
+      // No-op while already connecting; the callback resolves the wait.
+      this->ble_client_->connect();
+    }
+  }
+
+ private:
+  BLEClient *ble_client_;
+  std::tuple<Ts...> var_{};
+};
+
+template<typename... Ts> class BLEClientDisconnectAction final : public Action<Ts...> {
+ public:
+  BLEClientDisconnectAction(BLEClient *ble_client) {
+    ble_client_ = ble_client;
+    // Both terminal outcomes resolve the wait: a completed teardown and a
+    // connect attempt that died on the way down.
+    ble_client->add_on_disconnect_callback([this]() {
+      if (this->num_running_ != 0)
+        this->play_next_tuple_(this->var_);
+    });
+    ble_client->add_on_connect_failed_callback([this]() {
+      if (this->num_running_ != 0)
+        this->play_next_tuple_(this->var_);
+    });
+  }
+
+  // not used since we override play_complex_
+  void play(const Ts &...x) override {}
+
+  void play_complex(const Ts &...x) override {
+    this->num_running_++;
+    if (this->ble_client_->idle()) {
+      this->play_next_(x...);
+    } else {
+      this->var_ = std::make_tuple(x...);
+      this->ble_client_->disconnect();
+    }
+  }
+
+ private:
+  BLEClient *ble_client_;
+  std::tuple<Ts...> var_{};
+};
+
+}  // namespace esphome::ble_client
+
+#endif  // USE_BLE_GATT_CLIENT && !USE_BLE_CLIENT_LEGACY_ENGINE

esphome/components/ble_client/ble_client.cpp

@@ -2,10 +2,16 @@
 #include "esphome/components/esp32_ble_client/ble_client_base.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/application.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-#ifdef USE_ESP32
+#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
+
+#ifdef USE_BLE_CLIENT_GATT_NODES
+#include "esphome/components/bluetooth_connection/bluetooth_connection.h"
+#include "esphome/components/bluetooth_connection/gatt_service_table_bluedroid.h"
+#endif
 
 namespace esphome::ble_client {
 
@@ -30,6 +36,10 @@ void BLEClient::dump_config() {
 bool BLEClient::parse_device(const espbt::ESPBTDevice &device) {
   if (!this->enabled)
     return false;
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  if (device.address_uint64() == this->address_ && this->gatt_backoff_.holding_off())
+    return false;
+#endif
   return BLEClientBase::parse_device(device);
 }
 
@@ -40,24 +50,60 @@ void BLEClient::set_enabled(bool enabled) {
   if (!enabled) {
     ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str());
     this->disconnect();
+    return;
   }
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // A re-enable clears the backoff (neutral-engine parity).
+  this->gatt_backoff_.reset();
+#endif
 }
 
 bool BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t esp_gattc_if,
                                     esp_ble_gattc_cb_param_t *param) {
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // Bridge-initiated registrations bypass the base's REG_FOR_NOTIFY handling:
+  // its automatic CCCD write would double the node's own.
+  // Handle-keyed: mixed legacy/neutral subscriptions to one characteristic
+  // are unsupported during the migration window.
+  if (event == ESP_GATTC_REG_FOR_NOTIFY_EVT && esp_gattc_if == this->gattc_if_ &&
+      this->take_pending_gatt_reg_(param->reg_for_notify.handle)) {
+    if (this->pending_notify_regs_ > 0)
+      this->pending_notify_regs_--;
+    int err = param->reg_for_notify.status == ESP_GATT_OK ? 0 : param->reg_for_notify.status;
+    this->notify_state_to_gatt_nodes_(param->reg_for_notify.handle, true, err);
+    // A retiring last registration must still release the cache.
+    this->maybe_release_services_();
+    return true;
+  }
+#endif
   if (!BLEClientBase::gattc_event_handler(event, esp_gattc_if, param))
     return false;
 
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // Before the legacy fan-out so gatt nodes resolve before any trigger fires.
+  if (!this->gatt_nodes_.empty()) {
+    if (event == ESP_GATTC_SEARCH_CMPL_EVT) {
+      // A failed discovery tears the link down; the on_connect trigger must
+      // not fire into the teardown.
+      if (!this->handle_gatt_search_cmpl_(param->search_cmpl.status))
+        return true;
+    } else {
+      this->dispatch_gatt_event_(event, param);
+    }
+  }
+#endif
   for (auto *node : this->nodes_)
     node->gattc_event_handler(event, esp_gattc_if, param);
+  this->maybe_release_services_();
+  return true;
+}
 
+void BLEClient::maybe_release_services_() {
   // The release frees the GATT cache that BLEClientBase's CCCD lookup still needs.
-  // The last REG_FOR_NOTIFY event clears the counter before node dispatch, so the release still runs here.
   if (!this->services_.empty() && !this->notify_registration_pending() && this->all_nodes_established_()) {
     this->release_services();
     ESP_LOGD(TAG, "All clients established, services released");
   }
-  return true;
 }
 
 void BLEClient::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
@@ -65,10 +111,19 @@ void BLEClient::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_p
 
   for (auto *node : this->nodes_)
     node->gap_event_handler(event, param);
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  if (event == ESP_GAP_BLE_AUTH_CMPL_EVT && this->check_addr(param->ble_security.auth_cmpl.bd_addr)) {
+    int status = param->ble_security.auth_cmpl.success ? 0 : param->ble_security.auth_cmpl.fail_reason;
+    for (auto *node : this->gatt_nodes_)
+      node->on_pairing_result(status);
+  }
+#endif
 }
 
 void BLEClient::set_state(espbt::ClientState state) {
   BLEClientBase::set_state(state);
+  // ESTABLISHED never flows through here; gatt nodes are promoted after the
+  // on_connected fan-out.
   for (auto &node : nodes_)
     node->node_state = state;
 }
@@ -83,6 +138,221 @@ bool BLEClient::all_nodes_established_() {
   return true;
 }
 
+#ifdef USE_BLE_CLIENT_GATT_NODES
+
+void BLEClient::register_gatt_node(BLEClientNode *node) {
+  // Parent before the capacity check so a dropped node still has a usable
+  // parent() (neutral-engine parity).
+  node->set_ble_client_parent(this);
+  if (this->gatt_nodes_.size() == ESPHOME_BLE_CLIENT_MAX_NODES) {
+    // push_back past capacity is a silent no-op; an undersized slot count
+    // must be loud at boot, not an unresolvable node at runtime.
+    ESP_LOGE(TAG, "[%s] Node capacity exceeded; node dropped", this->address_str());
+    this->status_set_error(LOG_STR("node capacity exceeded"));
+    return;
+  }
+  this->gatt_nodes_.push_back(node);
+  // nodes_ covers the shared state bookkeeping; gatt_nodes_ is the neutral
+  // fan-out subset.
+  this->register_ble_node(node);
+}
+
+int BLEClient::find_pending_gatt_reg_(uint16_t handle) const {
+  for (uint8_t i = 0; i < this->pending_gatt_reg_count_; i++) {
+    if (this->pending_gatt_regs_[i] == handle)
+      return i;
+  }
+  return -1;
+}
+
+bool BLEClient::take_pending_gatt_reg_(uint16_t handle) {
+  int i = this->find_pending_gatt_reg_(handle);
+  if (i < 0)
+    return false;
+  // No duplicates (notify_characteristic refuses a re-push); swap-with-last.
+  this->pending_gatt_regs_[i] = this->pending_gatt_regs_[--this->pending_gatt_reg_count_];
+  return true;
+}
+
+void BLEClient::notify_state_to_gatt_nodes_(uint16_t handle, bool enabled, int error) {
+  if (error != 0) {
+    ESP_LOGW(TAG, "[%s] Notify %s on handle 0x%04x failed, status=%d", this->address_str(),
+             enabled ? "enable" : "disable", handle, error);
+  }
+  for (auto *node : this->gatt_nodes_)
+    node->on_notify_state(handle, enabled, error);
+}
+
+void BLEClient::dispatch_gatt_event_(esp_gattc_cb_event_t event, esp_ble_gattc_cb_param_t *param) {
+  switch (event) {
+    case ESP_GATTC_READ_CHAR_EVT:
+    case ESP_GATTC_READ_DESCR_EVT: {
+      bool ok = param->read.status == ESP_GATT_OK;
+      if (!ok) {
+        // Breadcrumb even when no node claims the handle.
+        ESP_LOGD(TAG, "[%s] Read on handle 0x%04x completed with status %d", this->address_str(), param->read.handle,
+                 param->read.status);
+      }
+      for (auto *node : this->gatt_nodes_) {
+        node->on_read_result(param->read.handle, ok ? param->read.value : nullptr, ok ? param->read.value_len : 0,
+                             ok ? 0 : param->read.status);
+      }
+      break;
+    }
+    case ESP_GATTC_WRITE_CHAR_EVT:
+    case ESP_GATTC_WRITE_DESCR_EVT:
+      if (param->write.status != ESP_GATT_OK) {
+        // Breadcrumb even when no node claims the handle.
+        ESP_LOGD(TAG, "[%s] Write on handle 0x%04x completed with status %d", this->address_str(), param->write.handle,
+                 param->write.status);
+      }
+      for (auto *node : this->gatt_nodes_) {
+        node->on_write_result(param->write.handle, param->write.status == ESP_GATT_OK ? 0 : param->write.status);
+      }
+      break;
+    case ESP_GATTC_NOTIFY_EVT:
+      for (auto *node : this->gatt_nodes_) {
+        node->on_notify(param->notify.handle, param->notify.value, param->notify.value_len);
+      }
+      break;
+    case ESP_GATTC_UNREG_FOR_NOTIFY_EVT:
+      // The base does no CCCD work for unregister; no interception needed.
+      this->notify_state_to_gatt_nodes_(
+          param->unreg_for_notify.handle, false,
+          param->unreg_for_notify.status == ESP_GATT_OK ? 0 : param->unreg_for_notify.status);
+      break;
+    default:
+      break;
+  }
+}
+
+bool BLEClient::handle_gatt_search_cmpl_(esp_gatt_status_t status) {
+  // The base ignores the search status; the neutral contract must not.
+  uint16_t service_total = 0;
+  bool counted = status == ESP_GATT_OK && bluetooth_connection::BluedroidServiceTable::count_services(
+                                              this->gattc_if_, this->conn_id_, &service_total);
+  if (!counted || service_total == 0) {
+    // A failed search poisons the whole discovery, legacy nodes included.
+    ESP_LOGW(TAG, "[%s] Discovery failed (status=%d, services=%u)", this->address_str(), status, service_total);
+    this->gatt_backoff_.register_failure(this->address_str());
+    this->disconnect();
+    return false;
+  }
+  // Stack-owned; nodes copy their handles during on_connected().
+  bluetooth_connection::BluedroidServiceTable table;
+  if (!table.build(this->gattc_if_, this->conn_id_, service_total, this->connection_index_)) {
+    if (!this->has_legacy_nodes_()) {
+      ESP_LOGW(TAG, "[%s] Service table build failed; treating as failed discovery", this->address_str());
+      this->gatt_backoff_.register_failure(this->address_str());
+      this->disconnect();
+      return false;
+    }
+    // Only the table build failed; legacy nodes read the base's services_
+    // and keep the link. Gatt nodes catch the next connection.
+    ESP_LOGW(TAG, "[%s] Service table build failed; gatt nodes skip this connection", this->address_str());
+    this->status_set_warning(LOG_STR("gatt nodes inactive: service table build failed"));
+    // A peer whose database never walks must not retry the build at
+    // advertisement cadence once the legacy nodes drop the link.
+    this->gatt_backoff_.register_failure(this->address_str());
+  } else {
+    this->gatt_connected_ = true;
+    auto view = table.view();
+    for (auto *node : this->gatt_nodes_) {
+      node->on_connected(view);
+      if (this->state() != espbt::ClientState::ESTABLISHED) {
+        // The node tore the link down; remaining nodes get on_disconnected
+        // with no preceding on_connected, so leave a trace of why.
+        ESP_LOGW(TAG, "[%s] A node aborted the connection during setup", this->address_str());
+        return false;
+      }
+    }
+    this->gatt_backoff_.reset();
+    this->status_clear_warning();
+  }
+  // Promote so the legacy release condition can fire.
+  for (auto *node : this->gatt_nodes_)
+    node->node_state = espbt::ClientState::ESTABLISHED;
+  return true;
+}
+
+void BLEClient::on_disconnect_complete(esp_err_t reason) {
+  this->pending_gatt_reg_count_ = 0;
+  if (!this->gatt_connected_)
+    return;  // Never-established links report nothing (neutral parity).
+  this->gatt_connected_ = false;
+  for (auto *node : this->gatt_nodes_)
+    node->on_disconnected();
+}
+
+int BLEClient::check_and_log_error_(const char *operation, esp_err_t err) {
+  if (err != ESP_OK)
+    this->log_gattc_warning_(operation, err);
+  return err;
+}
+
+int BLEClient::write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response) {
+  if (this->conn_id_ == UNSET_CONN_ID)
+    return ble_device_base::GATT_ERR_NOT_CONNECTED;
+  return this->check_and_log_error_(
+      "esp_ble_gattc_write_char",
+      esp_ble_gattc_write_char(this->gattc_if_, this->conn_id_, handle, len, const_cast<uint8_t *>(data),
+                               response ? ESP_GATT_WRITE_TYPE_RSP : ESP_GATT_WRITE_TYPE_NO_RSP,
+                               ESP_GATT_AUTH_REQ_NONE));
+}
+
+int BLEClient::read_characteristic(uint16_t handle) {
+  if (this->conn_id_ == UNSET_CONN_ID)
+    return ble_device_base::GATT_ERR_NOT_CONNECTED;
+  return this->check_and_log_error_("esp_ble_gattc_read_char", esp_ble_gattc_read_char(this->gattc_if_, this->conn_id_,
+                                                                                       handle, ESP_GATT_AUTH_REQ_NONE));
+}
+
+int BLEClient::read_descriptor(uint16_t handle) {
+  if (this->conn_id_ == UNSET_CONN_ID)
+    return ble_device_base::GATT_ERR_NOT_CONNECTED;
+  return this->check_and_log_error_(
+      "esp_ble_gattc_read_char_descr",
+      esp_ble_gattc_read_char_descr(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE));
+}
+
+int BLEClient::write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len) {
+  if (this->conn_id_ == UNSET_CONN_ID)
+    return ble_device_base::GATT_ERR_NOT_CONNECTED;
+  return this->check_and_log_error_(
+      "esp_ble_gattc_write_char_descr",
+      esp_ble_gattc_write_char_descr(this->gattc_if_, this->conn_id_, handle, len, const_cast<uint8_t *>(data),
+                                     ESP_GATT_WRITE_TYPE_RSP, ESP_GATT_AUTH_REQ_NONE));
+}
+
+int BLEClient::notify_characteristic(uint16_t handle, bool enable) {
+  if (this->conn_id_ == UNSET_CONN_ID)
+    return ble_device_base::GATT_ERR_NOT_CONNECTED;
+  if (enable) {
+    if (this->find_pending_gatt_reg_(handle) >= 0) {
+      // ESP_OK: the in-flight registration's completion fans out to all nodes.
+      ESP_LOGW(TAG, "[%s] Notify registration already pending for handle 0x%04x", this->address_str(), handle);
+      return ESP_OK;
+    }
+    if (this->pending_gatt_reg_count_ == MAX_PENDING_NOTIFY_REGS) {
+      // An untracked registration would let the base's auto-CCCD through.
+      ESP_LOGE(TAG, "[%s] Too many pending notify registrations", this->address_str());
+      return ble_device_base::GATT_ERR_NO_MEMORY;
+    }
+    // The base helper's pending count holds the service-release until the
+    // (intercepted) completion.
+    esp_err_t err = this->register_for_notify(handle);
+    if (err == ESP_OK)
+      this->pending_gatt_regs_[this->pending_gatt_reg_count_++] = handle;
+    return this->check_and_log_error_("esp_ble_gattc_register_for_notify", err);
+  }
+  return this->check_and_log_error_("esp_ble_gattc_unregister_for_notify",
+                                    esp_ble_gattc_unregister_for_notify(this->gattc_if_, this->remote_bda_, handle));
+}
+
+int BLEClient::unpair() { return bluetooth_connection::unpair_device(this->get_address()); }
+
+#endif  // USE_BLE_CLIENT_GATT_NODES
+
 }  // namespace esphome::ble_client
 
 #endif

esphome/components/ble_client/ble_client.h

@@ -1,18 +1,20 @@
 #pragma once
 
+#include "esphome/core/defines.h"
+
+#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
+
+#include "ble_client_node.h"
+#include "connect_backoff.h"
 #include "esphome/components/esp32_ble_client/ble_client_base.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
-#ifdef USE_ESP32
-
 #include <esp_bt_defs.h>
 #include <esp_gap_ble_api.h>
 #include <esp_gatt_common_api.h>
 #include <esp_gattc_api.h>
-#include <array>
-#include <string>
 #include <vector>
 
 namespace esphome::ble_client {
@@ -21,34 +23,6 @@ namespace espbt = esphome::esp32_ble_tracker;
 
 using namespace esp32_ble_client;
 
-class BLEClient;
-
-class BLEClientNode {
- public:
-  virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
-                                   esp_ble_gattc_cb_param_t *param){};
-  virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {}
-  virtual void loop() {}
-  void set_address(uint64_t address) { address_ = address; }
-  espbt::ESPBTClient *client;
-  // This should be transitioned to Established once the node no longer needs
-  // the services/descriptors/characteristics of the parent client. This will
-  // allow some memory to be freed.
-  // The parent frees the peer's GATT cache once every node reports Established.
-  // Never report Established while an operation that reads that cache is outstanding.
-  // - esp_ble_gattc_register_for_notify() completes asynchronously.
-  // - Register from ESP_GATTC_SEARCH_CMPL_EVT, then set this from ESP_GATTC_REG_FOR_NOTIFY_EVT.
-  // - BLEClientBase::register_for_notify() holds the release until the registration completes.
-  espbt::ClientState node_state;
-
-  BLEClient *parent() { return this->parent_; }
-  void set_ble_client_parent(BLEClient *parent) { this->parent_ = parent; }
-
- protected:
-  BLEClient *parent_;
-  uint64_t address_;
-};
-
 class BLEClient final : public BLEClientBase {
  public:
   void setup() override;
@@ -64,7 +38,6 @@ class BLEClient final : public BLEClientBase {
   void set_enabled(bool enabled);
 
   void register_ble_node(BLEClientNode *node) {
-    node->client = this;
     node->set_ble_client_parent(this);
     this->nodes_.push_back(node);
   }
@@ -73,10 +46,57 @@ class BLEClient final : public BLEClientBase {
 
   void set_state(espbt::ClientState state) override;
 
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // ---- the neutral node surface (signatures shared with the non-esp32
+  // engine, so nodes on the neutral interface compile against either) ----
+  void register_gatt_node(BLEClientNode *node);
+
+  bool idle() const { return this->state() == espbt::ClientState::IDLE; }
+
+  int write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response);
+  int read_characteristic(uint16_t handle);
+  int read_descriptor(uint16_t handle);
+  int write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len);
+  /// Local registration only; per the neutral contract the CCCD write is the
+  /// node's job (the legacy auto-CCCD is suppressed for these handles).
+  int notify_characteristic(uint16_t handle, bool enable);
+  // pair() comes from BLEClientBase, matching the neutral engine's.
+  int unpair();
+#endif
+
  protected:
   bool all_nodes_established_();
+  void maybe_release_services_();
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  int check_and_log_error_(const char *operation, esp_err_t err);
+  int find_pending_gatt_reg_(uint16_t handle) const;
+  void notify_state_to_gatt_nodes_(uint16_t handle, bool enabled, int error);
+  void dispatch_gatt_event_(esp_gattc_cb_event_t event, esp_ble_gattc_cb_param_t *param);
+  // False = failed discovery: the link comes down and the caller suppresses
+  // the legacy fan-out.
+  bool handle_gatt_search_cmpl_(esp_gatt_status_t status);
+  bool take_pending_gatt_reg_(uint16_t handle);
+  void on_disconnect_complete(esp_err_t reason) override;
+#endif
 
   std::vector<BLEClientNode *> nodes_;
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // Raise if a migrated node needs more concurrent registrations.
+  static constexpr uint8_t MAX_PENDING_NOTIFY_REGS = 4;
+
+  // Nodes on the neutral surface; fed the translated callbacks and
+  // auto-established after the on_connected fan-out. Every gatt node is
+  // also in nodes_ (registration pushes into both).
+  StaticVector<BLEClientNode *, ESPHOME_BLE_CLIENT_MAX_NODES> gatt_nodes_;
+  bool has_legacy_nodes_() const { return this->nodes_.size() > this->gatt_nodes_.size(); }
+  // Reconnect backoff after materializer failures.
+  ConnectBackoff gatt_backoff_;
+  // Bridge-initiated notify registrations awaiting REG_FOR_NOTIFY_EVT.
+  uint16_t pending_gatt_regs_[MAX_PENDING_NOTIFY_REGS];
+  uint8_t pending_gatt_reg_count_{0};
+  // on_connected fan-out started; on_disconnected is owed at teardown.
+  bool gatt_connected_{false};
+#endif
 };
 
 }  // namespace esphome::ble_client

esphome/components/ble_client/ble_client_gatt.cpp

@@ -0,0 +1,255 @@
+#include "ble_client_gatt.h"
+
+#if defined(USE_BLE_GATT_CLIENT) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
+
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+namespace esphome::ble_client {
+
+ESPHOME_LOG_TAG(TAG, "ble_client");
+
+void BLEClient::register_ble_node(BLEClientNode *node) {
+  node->set_ble_client_parent(this);
+  if (this->nodes_.size() == ESPHOME_BLE_CLIENT_MAX_NODES) {
+    // push_back past capacity is a silent no-op; an undersized slot count
+    // must be loud at boot, not an unresolvable node at runtime.
+    ESP_LOGE(TAG, "[%s] Node capacity exceeded; node dropped", this->address_str_);
+    this->status_set_error(LOG_STR("node capacity exceeded"));
+    return;
+  }
+  this->nodes_.push_back(node);
+}
+
+void BLEClient::set_address(uint64_t address) {
+  this->address_ = address;
+  uint8_t mac[6];
+  ble_device_base::uint64_to_mac_msb_first(address, mac);
+  format_mac_addr_upper(mac, this->address_str_);
+}
+
+void BLEClient::set_enabled(bool enabled) {
+  if (enabled == this->enabled)
+    return;
+  ESP_LOGI(TAG, "[%s] %s", this->address_str_, enabled ? "Enabled" : "Disabled");
+  this->enabled = enabled;
+  if (!enabled) {
+    this->disconnect();
+    return;
+  }
+  // A re-enable clears the backoff; the next sighting connects (legacy
+  // parity: enabling does not itself connect).
+  this->backoff_.reset();
+}
+
+bool BLEClient::parse_device(const ble_device_base::ESPBTDevice &device) {
+  if (device.address_uint64() != this->address_)
+    return false;
+  // The sighting is the source of truth for the address type.
+  this->address_type_ = device.get_address_type();
+  this->address_type_known_ = true;
+  if (!this->enabled || !this->auto_connect_ || this->state_ != State::IDLE)
+    return true;
+  if (this->backoff_.holding_off())
+    return true;
+  this->attempt_connect_();
+  return true;
+}
+
+void BLEClient::connect() {
+  if (this->state_ != State::IDLE) {
+    ESP_LOGD(TAG, "[%s] Connect requested while busy, ignoring", this->address_str_);
+    return;
+  }
+  // An absent peer can inhibit scanning for the backend's full connect
+  // timeout, so this is worth a breadcrumb - but it is a supported action.
+  ESP_LOGI(TAG, "[%s] Connecting on request", this->address_str_);
+  if (!this->address_type_known_) {
+    // Legacy parity: without a sighting the address type defaults to
+    // public, which never matches a random-static peer.
+    ESP_LOGW(TAG, "[%s] No sighting yet; assuming a public address type", this->address_str_);
+  }
+  this->attempt_connect_();
+}
+
+void BLEClient::attempt_connect_() {
+  int err = this->backend_->connect(this->address_, this->address_type_);
+  if (err != 0) {
+    // A refused connect never produces a callback: stay idle, charge the
+    // backoff, and resolve any waiting connect action through the failure
+    // path so its chain terminates.
+    ESP_LOGW(TAG, "[%s] Connect refused, err=%d", this->address_str_, err);
+    this->backoff_.register_failure(this->address_str_);
+    this->defer([this]() { this->connect_failed_callbacks_.call(); });
+    return;
+  }
+  ESP_LOGD(TAG, "[%s] Connecting", this->address_str_);
+  this->state_ = State::CONNECTING;
+}
+
+void BLEClient::disconnect() {
+  if (this->state_ == State::IDLE) {
+    ESP_LOGD(TAG, "[%s] Disconnect requested while idle, ignoring", this->address_str_);
+    return;
+  }
+  // A deliberate teardown's failure report must not feed the backoff.
+  this->cancel_requested_ = true;
+  int err = this->backend_->gatt_disconnect();
+  if (err != 0) {
+    // Refused synchronously: backend and client disagree about the link
+    // state. Warn, then settle through the deliberate-cancel path.
+    ESP_LOGW(TAG, "[%s] Disconnect refused, err=%d; settling locally", this->address_str_, err);
+    this->on_connection_state(false, 0, err);
+  }
+}
+
+void BLEClient::on_connection_state(bool connected, uint16_t mtu, int error) {
+  if (connected) {
+    this->state_ = State::DISCOVERING;
+    int discover_err = this->backend_->discover_services();
+    if (discover_err != 0) {
+      // Synchronous refusal: no discovery completion will follow.
+      ESP_LOGW(TAG, "[%s] Service discovery refused, err=%d", this->address_str_, discover_err);
+      this->backoff_.register_failure(this->address_str_);
+      // Deliberate teardown: its report must not charge the backoff again.
+      this->disconnect();
+    }
+    return;
+  }
+  bool was_connected = this->state_ == State::CONNECTED;
+  bool cancelled = this->cancel_requested_;
+  this->cancel_requested_ = false;
+  this->state_ = State::IDLE;
+  if (was_connected) {
+    ESP_LOGI(TAG, "[%s] Disconnected, status=%d", this->address_str_, error);
+    for (auto *node : this->nodes_) {
+      node->on_disconnected();
+    }
+    // Continuations leave the backend's event-drain stack first.
+    this->defer([this]() { this->disconnect_callbacks_.call(); });
+  } else {
+    if (cancelled) {
+      // status carries the refusal code when the teardown settled
+      // synchronously; 0 on a backend-completed cancel.
+      ESP_LOGD(TAG, "[%s] Connect attempt cancelled, status=%d", this->address_str_, error);
+    } else {
+      ESP_LOGW(TAG, "[%s] Connect failed, status=%d", this->address_str_, error);
+      this->backoff_.register_failure(this->address_str_);
+    }
+    this->defer([this]() { this->connect_failed_callbacks_.call(); });
+  }
+}
+
+void BLEClient::on_service_discovery_done(int error) {
+  if (this->state_ != State::DISCOVERING || this->cancel_requested_) {
+    // Raced a teardown; the terminal report settles the link.
+    ESP_LOGD(TAG, "[%s] Discovery completed during teardown, ignoring", this->address_str_);
+    this->backend_->release_services();
+    return;
+  }
+  if (error != 0) {
+    ESP_LOGW(TAG, "[%s] Service discovery failed, status=%d", this->address_str_, error);
+    this->backoff_.register_failure(this->address_str_);
+    // The teardown is deliberate: do not charge the backoff again for its
+    // connection report.
+    this->disconnect();
+    return;
+  }
+  ble_device_base::GattServiceTable table{};
+  if (!this->nodes_.empty()) {
+    // Materialize only when a node will read it: a client with no nodes
+    // would pay the build/free cycle on every (re)connect for nothing.
+    table = this->backend_->get_service_table();
+    if (table.service_count == 0) {
+      // A failed materialization is indistinguishable from a service-less
+      // peer, and a real GATT peer always exposes at least GAP/GATT: fail
+      // the discovery before CONNECTED so the teardown resolves through
+      // connect_failed, never a spurious on_disconnect.
+      ESP_LOGW(TAG, "[%s] Service table is empty; treating as failed discovery", this->address_str_);
+      this->backend_->release_services();
+      this->backoff_.register_failure(this->address_str_);
+      this->disconnect();
+      return;
+    }
+  }
+  // CONNECTED before the fan-out so nodes may consult connected() from
+  // their own on_connected().
+  this->state_ = State::CONNECTED;
+  for (auto *node : this->nodes_) {
+    node->on_connected(table);
+    if (this->state_ != State::CONNECTED || this->cancel_requested_) {
+      // A node tore the link down mid-fan-out: on_disconnect fires with no
+      // preceding on_connect, so leave a trace of why.
+      ESP_LOGW(TAG, "[%s] A node aborted the connection during setup", this->address_str_);
+      this->backend_->release_services();
+      return;
+    }
+  }
+  this->backend_->release_services();
+  this->backoff_.reset();
+  ESP_LOGI(TAG, "[%s] Connected", this->address_str_);
+  this->defer([this]() { this->connect_callbacks_.call(); });
+}
+
+void BLEClient::on_write_result(uint16_t handle, int error) {
+  if (error != 0) {
+    // Breadcrumb even when no node claims the handle.
+    ESP_LOGD(TAG, "[%s] Write on handle 0x%04x completed with status %d", this->address_str_, handle, error);
+  }
+  for (auto *node : this->nodes_) {
+    node->on_write_result(handle, error);
+  }
+}
+
+void BLEClient::on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) {
+  if (error != 0) {
+    // Breadcrumb even when no node claims the handle.
+    ESP_LOGD(TAG, "[%s] Read on handle 0x%04x completed with status %d", this->address_str_, handle, error);
+  }
+  for (auto *node : this->nodes_) {
+    node->on_read_result(handle, data, len, error);
+  }
+}
+
+void BLEClient::on_notify_data(uint16_t handle, const uint8_t *data, uint16_t len) {
+  // Every node sees every notification and filters by handle (legacy parity).
+  for (auto *node : this->nodes_) {
+    node->on_notify(handle, data, len);
+  }
+}
+
+void BLEClient::on_notify_state(uint16_t handle, bool enabled, int error) {
+  if (error != 0) {
+    ESP_LOGW(TAG, "[%s] Notify %s on handle 0x%04x failed, status=%d", this->address_str_,
+             enabled ? "enable" : "disable", handle, error);
+  }
+  for (auto *node : this->nodes_) {
+    node->on_notify_state(handle, enabled, error);
+  }
+}
+
+void BLEClient::on_pairing_result(int status) {
+  if (status != 0) {
+    ESP_LOGW(TAG, "[%s] Pairing failed, status=%d", this->address_str_, status);
+  } else {
+    ESP_LOGI(TAG, "[%s] Paired", this->address_str_);
+  }
+  for (auto *node : this->nodes_) {
+    node->on_pairing_result(status);
+  }
+}
+
+void BLEClient::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "BLE Client:\n"
+                "  Address: %s\n"
+                "  Auto connect: %s",
+                this->address_str_, YESNO(this->auto_connect_));
+  if (this->enabled && this->state_ == State::IDLE) {
+    ESP_LOGCONFIG(TAG, "  Waiting for an advertisement from the device");
+  }
+}
+
+}  // namespace esphome::ble_client
+
+#endif  // USE_BLE_GATT_CLIENT && !USE_BLE_CLIENT_LEGACY_ENGINE

esphome/components/ble_client/ble_client_gatt.h

@@ -0,0 +1,149 @@
+// Platform-neutral ble_client engine on the ble_device_base GATT contract.
+//
+// Compiled on every platform with a GATT backend except esp32, which keeps
+// the legacy BLEClientBase engine (ble_client.h) until its raw-gattc node
+// family migrates - the exclusive gates make the same class names resolve to
+// exactly one definition per build, so codegen is shared.
+//
+// Connects are sighting-gated like the legacy engine: the client is a parsed
+// advertisement listener, captures the peer's address type from the sighting,
+// and asks the backend to connect only when enabled and idle.
+
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#if defined(USE_BLE_GATT_CLIENT) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
+
+#include "ble_client_node.h"
+#include "connect_backoff.h"
+#include "esphome/components/ble_device_base/ble_device.h"
+#include "esphome/components/ble_device_base/ble_gatt_client.h"
+#include "esphome/components/bluetooth_connection/bluetooth_connection.h"
+#include "esphome/components/bluetooth_connection/bluetooth_connection_gatt_backend.h"
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+
+#include <cstdint>
+#include <functional>
+
+namespace esphome::ble_client {
+
+class BLEClient : public Component,
+                  public ble_device_base::ESPBTDeviceListener,
+                  public ble_device_base::GattClientListener {
+ public:
+  void dump_config() override;
+
+  // Public field for legacy parity (the switch platform republishes it).
+  bool enabled{true};
+
+  void set_backend(ble_device_base::BLEGattConnection *backend) {
+    this->backend_ = backend;
+    backend->set_listener(this);
+  }
+  void set_address(uint64_t address);
+  void set_auto_connect(bool auto_connect) { this->auto_connect_ = auto_connect; }
+  void set_enabled(bool enabled);
+  const char *address_str() const { return this->address_str_; }
+
+  void register_ble_node(BLEClientNode *node);
+  // One registration spelling shared with the esp32 engine's bridge.
+  void register_gatt_node(BLEClientNode *node) { this->register_ble_node(node); }
+
+  bool connected() const { return this->state_ == State::CONNECTED; }
+  bool idle() const { return this->state_ == State::IDLE; }
+
+  /// Action-initiated connect (no sighting needed; uses the last captured
+  /// address type, public until a sighting arrives). No-op unless idle.
+  void connect();
+  void disconnect();
+
+  /// Legacy-named deferral used by the automation twins: neutral listener
+  /// callbacks run inside the backend's event drain, so automation chain
+  /// continuations must leave that stack first.
+  void run_later(std::function<void()> &&f) { this->defer(std::move(f)); }  // NOLINT
+
+  // Backend ops for nodes and actions - the frozen node-facing surface.
+  // Only write_characteristic has an in-tree caller; subscribing means
+  // notify_characteristic plus a CCCD write_descriptor (the caller's job
+  // per the contract).
+  int write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response) {
+    return this->backend_->write_characteristic(handle, data, len, response);
+  }
+  int read_characteristic(uint16_t handle) { return this->backend_->read_characteristic(handle); }
+  int read_descriptor(uint16_t handle) { return this->backend_->read_descriptor(handle); }
+  int write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len) {
+    return this->backend_->write_descriptor(handle, data, len);
+  }
+  int notify_characteristic(uint16_t handle, bool enable) {
+    return this->backend_->notify_characteristic(handle, enable);
+  }
+  int pair() { return this->backend_->pair(); }
+  int unpair() { return bluetooth_connection::unpair_device(this->address_); }
+
+  // Automation callback registration.
+  template<typename F> void add_on_connect_callback(F &&callback) {
+    this->connect_callbacks_.add(std::forward<F>(callback));
+  }
+  template<typename F> void add_on_disconnect_callback(F &&callback) {
+    this->disconnect_callbacks_.add(std::forward<F>(callback));
+  }
+  // Fired when a connect attempt dies before being established; the user
+  // on_disconnect trigger deliberately does NOT fire here (legacy parity).
+  template<typename F> void add_on_connect_failed_callback(F &&callback) {
+    this->connect_failed_callbacks_.add(std::forward<F>(callback));
+  }
+
+  // ---- ble_device_base::ESPBTDeviceListener ----
+  bool parse_device(const ble_device_base::ESPBTDevice &device) override;
+
+  // ---- ble_device_base::GattClientListener ----
+  void on_connection_state(bool connected, uint16_t mtu, int error) override;
+  void on_service_discovery_done(int error) override;
+  void on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) override;
+  void on_write_result(uint16_t handle, int error) override;
+  void on_notify_data(uint16_t handle, const uint8_t *data, uint16_t len) override;
+  void on_notify_state(uint16_t handle, bool enabled, int error) override;
+  void on_pairing_result(int status) override;
+
+ protected:
+  enum class State : uint8_t { IDLE, CONNECTING, DISCOVERING, CONNECTED };
+
+  void attempt_connect_();
+
+  // Group 1: pointers / containers
+  ble_device_base::BLEGattConnection *backend_{nullptr};
+  // Codegen-sized (ESPHOME_BLE_CLIENT_MAX_NODES); filled during setup.
+  StaticVector<BLEClientNode *, ESPHOME_BLE_CLIENT_MAX_NODES> nodes_;
+
+  // Group 2: 8-byte types
+  uint64_t address_{0};
+
+  // Group 3: callback managers (pointer-sized when empty)
+  LazyCallbackManager<void()> connect_callbacks_;
+  LazyCallbackManager<void()> disconnect_callbacks_;
+  LazyCallbackManager<void()> connect_failed_callbacks_;
+
+  // Group 4: 4-byte types
+  // Backoff so an undiscoverable database or a dead peer cannot produce a
+  // battery-draining connect loop.
+  ConnectBackoff backoff_;
+
+  // Group 5: arrays
+  char address_str_[MAC_ADDRESS_PRETTY_BUFFER_SIZE]{};
+
+  // Group 6: 1-byte types
+  State state_{State::IDLE};
+  uint8_t address_type_{0};  // BLE_ADDR_TYPE_*, captured from the sighting
+  // Distinguishes a captured public type from the never-sighted default.
+  bool address_type_known_{false};
+  bool auto_connect_{true};
+  // A user-initiated teardown in flight; its failure report is not a
+  // connect failure and must not feed the backoff.
+  bool cancel_requested_{false};
+};
+
+}  // namespace esphome::ble_client
+
+#endif  // USE_BLE_GATT_CLIENT && !USE_BLE_CLIENT_LEGACY_ENGINE

esphome/components/ble_client/ble_client_node.h

@@ -0,0 +1,68 @@
+// The single BLEClientNode both ble_client engines share. The neutral
+// callback surface is the one interface node components build on; the raw
+// esp32 surface below it remains for components that have not migrated yet.
+
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_BLE_GATT_CLIENT
+#include "esphome/components/ble_device_base/ble_gatt_client.h"
+#endif
+#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+
+#include <esp_gap_ble_api.h>
+#include <esp_gattc_api.h>
+#endif
+
+#include <cstdint>
+
+namespace esphome::ble_client {
+
+class BLEClient;
+
+class BLEClientNode {
+ public:
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // Neutral surface, delivered by both engines. The table is borrowed: copy
+  // handles during on_connected(). All nodes see all completions; filter by
+  // handle.
+  // A node that disconnects from inside on_connected() aborts the fan-out;
+  // the user's on_disconnect may then fire without a preceding on_connect.
+  virtual void on_connected(const ble_device_base::GattServiceTable &table) {}
+  virtual void on_disconnected() {}
+  virtual void on_notify(uint16_t handle, const uint8_t *data, uint16_t len) {}
+  // One in-flight registration per handle; its completion fans out to every
+  // node, so a refused duplicate request still sees on_notify_state.
+  virtual void on_notify_state(uint16_t handle, bool enabled, int error) {}
+  virtual void on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) {}
+  virtual void on_write_result(uint16_t handle, int error) {}
+  virtual void on_pairing_result(int status) {}
+#endif
+#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
+  // Legacy raw surface; components overriding these need the legacy engine
+  // until migrated to the neutral surface above.
+  virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                                   esp_ble_gattc_cb_param_t *param) {}
+  virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {}
+  virtual void loop() {}
+  // This should be transitioned to Established once the node no longer needs
+  // the services/descriptors/characteristics of the parent client. This will
+  // allow some memory to be freed.
+  // The parent frees the peer's GATT cache once every node reports Established.
+  // Never report Established while an operation that reads that cache is outstanding.
+  // - esp_ble_gattc_register_for_notify() completes asynchronously.
+  // - Register from ESP_GATTC_SEARCH_CMPL_EVT, then set this from ESP_GATTC_REG_FOR_NOTIFY_EVT.
+  // - BLEClientBase::register_for_notify() holds the release until the registration completes.
+  esp32_ble_tracker::ClientState node_state;
+#endif
+
+  BLEClient *parent() const { return this->parent_; }
+  void set_ble_client_parent(BLEClient *parent) { this->parent_ = parent; }
+
+ protected:
+  BLEClient *parent_{nullptr};
+};
+
+}  // namespace esphome::ble_client

esphome/components/ble_client/ble_write_action.h

@@ -0,0 +1,172 @@
+// The ble_client.ble_write action: a node on the platform-neutral interface,
+// so one implementation serves both engines (the esp32 bridge and the
+// neutral engine).
+
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_BLE_CLIENT_GATT_NODES
+
+#include <tuple>
+#include <vector>
+
+// One of the two engine headers resolves per build.
+#include "ble_client.h"
+#include "ble_client_gatt.h"
+#include "ble_client_node.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome::ble_client {
+
+static const char *const BLE_WRITE_TAG = "ble_client.automation";
+
+// Maximum bytes to log in hex format for BLE writes (many logging buffers are 256 chars)
+static constexpr size_t BLE_WRITE_MAX_LOG_BYTES = 64;
+
+template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>, public BLEClientNode {
+ public:
+  BLEClientWriteAction(BLEClient *ble_client) {
+    ble_client->register_gatt_node(this);
+    ble_client_ = ble_client;
+  }
+
+  void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_uint16(uuid); }
+  void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_uint32(uuid); }
+  void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_raw(uuid); }
+
+  void set_char_uuid16(uint16_t uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_uint16(uuid); }
+  void set_char_uuid32(uint32_t uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_uint32(uuid); }
+  void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_raw(uuid); }
+
+  void set_value_template(std::vector<uint8_t> (*func)(Ts...)) {
+    this->value_.func = func;
+    this->len_ = -1;  // Sentinel value indicates template mode
+  }
+
+  // Store pointer to static data in flash (no RAM copy)
+  void set_value_simple(const uint8_t *data, size_t len) {
+    this->value_.data = data;
+    this->len_ = len;  // Length >= 0 indicates static mode
+  }
+
+  void play(const Ts &...x) override {}
+
+  void play_complex(const Ts &...x) override {
+    this->num_running_++;
+    this->var_ = std::make_tuple(x...);
+
+    bool result;
+    if (this->len_ >= 0) {
+      result = this->write(this->value_.data, this->len_);
+    } else {
+      std::vector<uint8_t> value = this->value_.func(x...);
+      result = this->write(value.data(), value.size());
+    }
+
+    // on write failure, continue the automation chain rather than stopping so
+    // that e.g. disconnect can work.
+    if (!result)
+      this->play_next_(x...);
+  }
+
+  // Initiate the write; the completion arrives in on_write_result. The
+  // response-less path can complete synchronously inside the call, so the
+  // handle is armed before the backend is touched.
+  bool write(const uint8_t *data, size_t len) {
+    if (!this->ble_client_->connected()) {
+      esph_log_w(BLE_WRITE_TAG, "Cannot write to BLE characteristic - not connected");
+      return false;
+    }
+    if (!this->resolved_) {
+      esph_log_w(BLE_WRITE_TAG, "Cannot write to BLE characteristic - characteristic was not resolved");
+      return false;
+    }
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
+    char hex_buf[format_hex_pretty_size(BLE_WRITE_MAX_LOG_BYTES)];
+    esph_log_vv(BLE_WRITE_TAG, "Will write %d bytes: %s", len, format_hex_pretty_to(hex_buf, data, len));
+#endif
+    int err = this->ble_client_->write_characteristic(this->char_handle_, data, len, this->write_response_);
+    if (err != 0) {
+      esph_log_e(BLE_WRITE_TAG, "Error writing to characteristic: %d!", err);
+      return false;
+    }
+    return true;
+  }
+
+  void on_connected(const ble_device_base::GattServiceTable &table) override {
+    // Resolution comes from this table only; a re-discovery must not keep a
+    // stale handle.
+    this->resolved_ = false;
+    this->char_handle_ = 0;
+    const auto *service = ble_device_base::find_service(table, this->service_uuid_);
+    const auto *chr =
+        service == nullptr ? nullptr : ble_device_base::find_characteristic(table, *service, this->char_uuid_);
+    if (chr == nullptr) {
+      char char_buf[ble_device_base::UUID_STR_LEN];
+      char service_buf[ble_device_base::UUID_STR_LEN];
+      esph_log_w(BLE_WRITE_TAG, "Characteristic %s was not found in service %s", this->char_uuid_.to_str(char_buf),
+                 this->service_uuid_.to_str(service_buf));
+      return;
+    }
+    if (chr->properties & ble_device_base::GATT_CHAR_PROP_WRITE) {
+      this->write_response_ = true;
+    } else if (chr->properties & ble_device_base::GATT_CHAR_PROP_WRITE_NO_RSP) {
+      this->write_response_ = false;
+    } else {
+      char char_buf[ble_device_base::UUID_STR_LEN];
+      esph_log_e(BLE_WRITE_TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_str(char_buf));
+      return;
+    }
+    this->char_handle_ = chr->value_handle;
+    this->resolved_ = true;
+    char char_buf[ble_device_base::UUID_STR_LEN];
+    esph_log_d(BLE_WRITE_TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
+               this->ble_client_->address_str());
+  }
+
+  void on_disconnected() override {
+    this->resolved_ = false;
+    this->char_handle_ = 0;
+    if (this->num_running_ != 0)
+      this->stop_complex();
+  }
+
+  void on_write_result(uint16_t handle, int error) override {
+    if (this->num_running_ == 0) {
+      return;
+    }
+    if (!this->resolved_ || handle != this->char_handle_) {
+      // A parked chain waiting on a completion that never matches would
+      // otherwise stall silently until disconnect.
+      esph_log_d(BLE_WRITE_TAG, "Write result for handle 0x%04x ignored, waiting on 0x%04x", handle,
+                 this->char_handle_);
+      return;
+    }
+    if (error != 0) {
+      // Continue the chain (legacy parity) but leave a breadcrumb.
+      esph_log_w(BLE_WRITE_TAG, "Write completed with status %d", error);
+    }
+    this->ble_client_->run_later([this]() { this->play_next_tuple_(this->var_); });
+  }
+
+ private:
+  BLEClient *ble_client_;
+  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
+  union Value {
+    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
+    const uint8_t *data;                  // Pointer to static data in flash
+  } value_;
+  ble_device_base::ESPBTUUID service_uuid_;
+  ble_device_base::ESPBTUUID char_uuid_;
+  std::tuple<Ts...> var_{};
+  uint16_t char_handle_{};
+  bool write_response_{false};
+  bool resolved_{false};
+};
+
+}  // namespace esphome::ble_client
+
+#endif  // USE_BLE_CLIENT_GATT_NODES

esphome/components/ble_client/connect_backoff.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_BLE_GATT_CLIENT
+
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+#include <cstdint>
+
+namespace esphome::ble_client {
+
+/// Reconnect backoff after repeated connect/discovery failures, shared by
+/// both engines. 256 ms ticks in a uint16_t keep it 4 bytes; the ~4.7 h tick
+/// wrap can at worst reinstate one stale hold-off of a minute.
+class ConnectBackoff {
+ public:
+  bool holding_off() const {
+    return this->failures_ != 0 && static_cast<uint16_t>(now() - this->start_) < this->failures_ * STEP_TICKS;
+  }
+  void register_failure(const char *address_str) {
+    if (this->failures_ < MAX_STEPS)
+      this->failures_++;
+    this->start_ = now();
+    esph_log_w("ble_client", "[%s] Holding off reconnect for %u s", address_str, this->failures_ * 10u);
+  }
+  void reset() { this->failures_ = 0; }
+
+ private:
+  // ~10 s per consecutive failure, capped so a flapping peer retries within
+  // a minute at worst.
+  static constexpr uint16_t STEP_TICKS = 40;  // x 256 ms
+  static constexpr uint8_t MAX_STEPS = 6;
+  static uint16_t now() { return static_cast<uint16_t>(millis() >> 8); }
+
+  uint16_t start_{0};
+  uint8_t failures_{0};
+};
+
+}  // namespace esphome::ble_client
+
+#endif  // USE_BLE_GATT_CLIENT

esphome/components/ble_device_base/ble_gatt_client.cpp

@@ -0,0 +1,48 @@
+#include "ble_gatt_client.h"
+
+#ifdef USE_BLE_GATT_CLIENT
+
+#include "esphome/core/log.h"
+
+namespace esphome::ble_device_base {
+
+ESPHOME_LOG_TAG(TAG, "ble_device_base");
+
+const GattCharacteristic *find_characteristic(const GattServiceTable &table, const GattService &service,
+                                              const ESPBTUUID &uuid) {
+  // 32-bit range math: a corrupt first/count pair cannot wrap past the check.
+  uint32_t end = uint32_t(service.first_characteristic) + service.characteristic_count;
+  if (end > table.characteristic_count) {
+    ESP_LOGW(TAG, "characteristic range out of bounds");
+    return nullptr;
+  }
+  for (uint32_t i = service.first_characteristic; i < end; i++) {
+    if (table.characteristics[i].uuid == uuid)
+      return &table.characteristics[i];
+  }
+  return nullptr;
+}
+
+const GattDescriptor *find_descriptor(const GattServiceTable &table, const GattCharacteristic &characteristic,
+                                      const ESPBTUUID &uuid) {
+  uint32_t end = uint32_t(characteristic.first_descriptor) + characteristic.descriptor_count;
+  if (end > table.descriptor_count) {
+    // Corrupt range, not a missing descriptor.
+    ESP_LOGW(TAG, "descriptor range out of bounds");
+    return nullptr;
+  }
+  for (uint32_t i = characteristic.first_descriptor; i < end; i++) {
+    if (table.descriptors[i].uuid == uuid)
+      return &table.descriptors[i];
+  }
+  return nullptr;
+}
+
+uint16_t find_cccd(const GattServiceTable &table, const GattCharacteristic &characteristic) {
+  const GattDescriptor *desc = find_descriptor(table, characteristic, ESPBTUUID::from_uint16(CCCD_UUID));
+  return desc != nullptr ? desc->handle : 0;
+}
+
+}  // namespace esphome::ble_device_base
+
+#endif  // USE_BLE_GATT_CLIENT

esphome/components/ble_device_base/ble_gatt_client.h

@@ -11,13 +11,16 @@
 // interface. All listener calls are delivered on the ESPHome main loop;
 // borrowed data pointers are valid only for the duration of the call.
 //
-// Error domain (plain int, forwarded to the API without translation):
+// Error domain (plain int, forwarded to the API without translation, so the
+// values are wire-frozen - API clients interpret them):
 //   0            success
-//   1..0x11      ATT error codes (Bluetooth spec; BTstack and Bluedroid agree)
+//   1..0x11      ATT error codes (Bluetooth spec) - reserved; a backend whose
+//                native error codes land in this window must remap them out
 //   GATT_ERR_NOT_CONNECTED (-1)  no connection to the peer (on esp32 a raw
 //                ESP_FAIL from the stack shares this value; both read as a
 //                failed, unusable connection on the client side)
 //   GATT_ERR_NO_MEMORY (-2)      backend storage exhausted
+//   -1..-15      reserved for future contract sentinels
 //   anything else: platform stack error/status code, surfaced opaquely.
 // Connection events carry HCI status/disconnect reason codes (same code
 // space on every controller).
@@ -99,9 +102,18 @@ class GattClientListener {
 // The BLEGattConnection op surface, asserted where the alias binds
 // (bluetooth_connection_gatt_backend.h). Operations return 0 when accepted (completion arrives
 // through the listener) or a synchronous error (busy, not connected, stack
-// rejection); one operation may be outstanding at a time. Semantics beyond
-// the signatures:
+// rejection); one operation may be outstanding at a time. An accepted
+// operation's completion is delivered from the event loop, NEVER
+// synchronously from inside the op call - a synchronous terminal
+// on_connection_state from within gatt_disconnect() would re-enter the
+// consumer mid-teardown. Semantics beyond the signatures:
 // - connect: addr_type is a BLE_ADDR_TYPE_* constant (ble_device.h).
+//   Returning 0 means the request is accepted, not that the radio acted: the
+//   backend owns integration with its platform's scan/connect arbitration
+//   (Bluedroid parks the request for the tracker's promote loop, which owns
+//   scan-stop/coex/one-connect-at-a-time; the rp2 backend opens immediately
+//   and relies on sighting-gated consumers). Consumers must not assume
+//   connect timing.
 // - gatt_disconnect: also cancels a connect in progress (named to coexist
 //   with a platform stack's own void disconnect() on one backend class).
 //   Nonzero means nothing to tear down and no completion will follow; an
@@ -143,6 +155,41 @@ concept BLEGattConnectionContract = requires(T conn, GattClientListener *listene
   { conn.set_connection_type(ConnectionType{}) } -> std::same_as<void>;
 };
 
+// ---- service table lookup helpers ----
+//
+// Neutral, bounds-checked walks over a materialized GattServiceTable for
+// direct consumers that resolve a known device's handles by UUID (streaming
+// consumers forward the raw database and never need these). Linear search:
+// the table exists only between discovery and release_services(), for one
+// small known device.
+
+/// Client Characteristic Configuration descriptor UUID (Bluetooth spec).
+static constexpr uint16_t CCCD_UUID = 0x2902;
+
+// Characteristic property bits (the Bluetooth-spec declaration byte carried
+// in GattCharacteristic::properties; the ESP-IDF macros for these do not
+// exist on the other platforms).
+static constexpr uint8_t GATT_CHAR_PROP_WRITE_NO_RSP = 0x04;
+static constexpr uint8_t GATT_CHAR_PROP_WRITE = 0x08;
+
+inline const GattService *find_service(const GattServiceTable &table, const ESPBTUUID &uuid) {
+  for (uint16_t i = 0; i < table.service_count; i++) {
+    if (table.services[i].uuid == uuid)
+      return &table.services[i];
+  }
+  return nullptr;
+}
+
+const GattCharacteristic *find_characteristic(const GattServiceTable &table, const GattService &service,
+                                              const ESPBTUUID &uuid);
+
+const GattDescriptor *find_descriptor(const GattServiceTable &table, const GattCharacteristic &characteristic,
+                                      const ESPBTUUID &uuid);
+
+/// Handle of the characteristic's Client Characteristic Configuration
+/// descriptor (0x2902), or 0 when it has none.
+uint16_t find_cccd(const GattServiceTable &table, const GattCharacteristic &characteristic);
+
 }  // namespace esphome::ble_device_base
 
 #endif  // USE_BLE_GATT_CLIENT

esphome/components/bluetooth_connection/__init__.py

@@ -1,12 +1,14 @@
 """Per-platform GATT connection backends and the helpers to embed one.
 
-Backends: esp32 Bluedroid, rp2 BTstack. No user-facing configuration; the
-Bluetooth proxy's codegen declares and registers the backend instances
-through gatt_client_schema()/hub_connection_schema() + new_gatt_backend().
+Backends: esp32 Bluedroid, rp2 BTstack. No user-facing configuration; a
+consumer's codegen declares and registers the backend instances — the
+Bluetooth proxy through its per-slot connection wrappers (a streaming
+consumer), and the neutral ble_client through gatt_client_schema() +
+new_gatt_backend().
 """
 
 from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 import esphome.codegen as cg
 from esphome.components import rp2040_ble
@@ -23,7 +25,8 @@ from esphome.types import ConfigType
 def AUTO_LOAD() -> list[str]:
     """ble_device_base plus the platform BLE stack the build's backend
     registers with (the Bluedroid header includes the tracker's), so
-    consumers need not know. The platform-less arm serves manifest tooling."""
+    consumers stay platform-blind. The platform-less arm serves tooling that
+    resolves the manifest without a target."""
     if CORE.is_esp32:
         return ["ble_device_base", "esp32_ble_tracker"]
     if CORE.is_rp2:
@@ -63,6 +66,8 @@ DOMAIN = "bluetooth_connection"
 @dataclass
 class _ConnectionData:
     rp2_backend_count: int = 0
+    # GATT connection slots claimed this run, for the platform cap check.
+    slot_consumers: list[str] = field(default_factory=list)
 
 
 def _get_data() -> _ConnectionData:
@@ -119,6 +124,10 @@ class _PlatformBackend:
     backend_class: cg.MockObjClass
     schema_fragment: Callable[[], cv.Schema]
     register: Callable[[cg.MockObj, ConfigType], Awaitable[None]]
+    # Selects the backend's alias-ladder arm (order-independent arms).
+    define: str
+    # The backend's on-demand materializer gate, when it has one.
+    materializer_define: str | None = None
 
 
 # The single registry of platforms with a GATT client backend; a platform
@@ -126,11 +135,20 @@ class _PlatformBackend:
 # platform's arm.
 _PLATFORM_BACKENDS: dict[str, _PlatformBackend] = {
     PLATFORM_ESP32: _PlatformBackend(
-        BluedroidGattClient, _esp32_schema_fragment, _esp32_register
+        BluedroidGattClient,
+        _esp32_schema_fragment,
+        _esp32_register,
+        "USE_BLE_GATT_BACKEND_BLUEDROID",
+        materializer_define="USE_BLUEDROID_GATT_SERVICE_TABLE",
+    ),
+    PLATFORM_RP2: _PlatformBackend(
+        RP2GattClient, _rp2_schema_fragment, _rp2_register, "USE_BLE_GATT_BACKEND_RP2"
     ),
-    PLATFORM_RP2: _PlatformBackend(RP2GattClient, _rp2_schema_fragment, _rp2_register),
 }
 
+# Gates dedicated-backend consumers (cv.only_on).
+GATT_CLIENT_PLATFORMS = list(_PLATFORM_BACKENDS)
+
 
 def _backend_entry(platform: str | None = None) -> _PlatformBackend:
     key = platform if platform is not None else CORE.target_platform
@@ -165,21 +183,97 @@ def hub_connection_schema(platform: str | None = None) -> cv.Schema:
     )
 
 
-async def new_gatt_backend(config: ConfigType) -> cg.MockObj:
+def _charge_esp32_budget(count: int, consumer: str, config: ConfigType) -> None:
+    from esphome.components import esp32_ble
+
+    esp32_ble.consume_connection_slots(count, consumer)(config)
+
+
+def _charge_rp2_budget(count: int, consumer: str, config: ConfigType) -> None:
+    rp2040_ble.consume_connection_slots(count, consumer)(config)
+
+
+# Platforms whose BLE stack owns its own connection budget: the claim is
+# charged there and that stack's final validation is the one place an
+# overcommit is reported (never two messages for one misconfiguration). One
+# mapping drives both, so a platform can never be skipped without a charge.
+_STACK_BUDGETS: dict[str, Callable[[int, str, ConfigType], None]] = {
+    PLATFORM_ESP32: _charge_esp32_budget,
+    PLATFORM_RP2: _charge_rp2_budget,
+}
+
+
+def consume_gatt_slot(
+    consumer: str, count: int = 1
+) -> Callable[[ConfigType], ConfigType]:
+    """Validator claiming GATT connection slots - the one spelling for every
+    claimant. The neutral ledger covers backend platforms without a stack
+    budget (the cap check in FINAL_VALIDATE_SCHEMA)."""
+
+    def validator(config: ConfigType) -> ConfigType:
+        _get_data().slot_consumers.extend([consumer] * count)
+        if (charge := _STACK_BUDGETS.get(CORE.target_platform)) is not None:
+            charge(count, consumer, config)
+        return config
+
+    return validator
+
+
+def _validate_slot_totals(config: ConfigType) -> ConfigType:
+    # Skipped in testing mode so grouped component builds can co-exist
+    # (mirrors esp32_ble.validate_connection_slots).
+    if CORE.testing_mode:
+        return config
+    if CORE.target_platform in _STACK_BUDGETS:
+        return config
+    if (cap := HUB_MAX_CONNECTIONS.get(CORE.target_platform)) is None:
+        # Any backend platform without a stack budget must carry a cap here
+        # or fail loudly, never fail open.
+        if CORE.target_platform in _PLATFORM_BACKENDS:
+            raise cv.Invalid(
+                f"{CORE.target_platform} has a GATT backend but no slot cap "
+                "in HUB_MAX_CONNECTIONS"
+            )
+        return config
+    claimed = _get_data().slot_consumers
+    if len(claimed) > cap:
+        raise cv.Invalid(
+            f"{CORE.target_platform} supports at most {cap} GATT client "
+            f"connection(s); {len(claimed)} requested by: {', '.join(claimed)}"
+        )
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _validate_slot_totals
+
+
+async def new_gatt_backend(
+    config: ConfigType, *, service_table: bool = True
+) -> cg.MockObj:
     """Instantiate the backend declared by gatt_client_schema() and register
     it with its platform stack. The connection slot is claimed at validation
-    (the proxy's slot validators), not here.
+    (the consume_gatt_slot validators), not here.
+
+    service_table is honored by the Bluedroid backend only: forward
+    scaffolding for the first esp32 direct consumer, load-bearing on no
+    current build (rp2 ignores the define and always materializes - its
+    proxy hub streams through get_service_table(), so it must keep the
+    materializer regardless of the flag).
     """
     from esphome.components import ble_device_base
 
+    entry = _backend_entry()
     ble_device_base.request_gatt_client()
+    cg.add_define(entry.define)
+    if service_table and entry.materializer_define is not None:
+        cg.add_define(entry.materializer_define)
     backend = cg.new_Pvariable(config[CONF_BACKEND_ID])
     # The backend is the slot's real Component: component keys from the
     # connection entry (setup_priority, ...) apply to it. Consumers whose own
     # schema carries keys that register_component would misapply to the
     # backend (e.g. a polling interval) must not put them in this config.
     await cg.register_component(backend, config)
-    await _backend_entry().register(backend, config)
+    await entry.register(backend, config)
     return backend
 
 
@@ -187,6 +281,7 @@ async def new_gatt_backend(config: ConfigType) -> cg.MockObj:
 # list (this module cannot import bluetooth_proxy to derive it).
 SOURCE_FILE_FRAMEWORKS: dict[str, set[PlatformFramework]] = {
     "bluetooth_connection_bluedroid.cpp": frameworks_for_platforms([PLATFORM_ESP32]),
+    "gatt_service_table_bluedroid.cpp": frameworks_for_platforms([PLATFORM_ESP32]),
     # Every hub platform the proxy admits (the file compiles empty where
     # USE_BLE_GATT_CLIENT is not defined), so a platform gaining a backend
     # cannot hit a missing-symbol trap here.

esphome/components/bluetooth_connection/bluetooth_connection.cpp

@@ -46,7 +46,7 @@ BatchClose close_service_batch(api::BluetoothGATTGetServicesResponse &resp, size
 
 #endif  // USE_BLUETOOTH_PROXY_CONNECTIONS
 
-#if defined(USE_ESP32) && defined(USE_BLE_GATT_CLIENT)
+#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
 namespace esphome::bluetooth_connection {
 
 // Address-scoped Bluedroid maintenance. Gated with the connection surface:
@@ -65,4 +65,4 @@ conn_err_t clear_gatt_cache(uint64_t address) {
 }
 
 }  // namespace esphome::bluetooth_connection
-#endif  // USE_ESP32 && USE_BLE_GATT_CLIENT
+#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT

esphome/components/bluetooth_connection/bluetooth_connection.h

@@ -48,15 +48,16 @@ static constexpr conn_err_t CONN_OK = 0;
 // GATT contract so backend and wrapper cannot drift.
 static constexpr conn_err_t GATT_NOT_CONNECTED = ble_device_base::GATT_ERR_NOT_CONNECTED;
 
-// What the platform's connection backend supports beyond GATT operations;
-// the proxy derives its feature flags and legacy version from these.
-#if defined(USE_ESP32)
+// What the build's connection backend supports beyond GATT operations; the
+// proxy derives its feature flags and legacy version from these. Keyed on
+// the backend define, never the platform, so a second backend on one
+// platform carries its own facts.
+#if defined(USE_BLE_GATT_BACKEND_BLUEDROID)
 static constexpr bool SUPPORTS_PAIRING = true;
 static constexpr bool SUPPORTS_CACHE_CLEARING = true;
-#elif defined(USE_RP2040_BLE) && defined(USE_BLE_GATT_CLIENT)
+#elif defined(USE_BLE_GATT_BACKEND_RP2)
 // The rp2 BTstack backend pairs (just works + bonding); it has no service
-// cache to clear. Keyed on the backend, not the generic client define, so a
-// future backend without pairing keeps the stub arm below.
+// cache to clear.
 static constexpr bool SUPPORTS_PAIRING = true;
 static constexpr bool SUPPORTS_CACHE_CLEARING = false;
 #else
@@ -64,13 +65,14 @@ static constexpr bool SUPPORTS_PAIRING = false;
 static constexpr bool SUPPORTS_CACHE_CLEARING = false;
 #endif
 
-// Address-scoped (not connection-scoped) maintenance requests.
-#if (defined(USE_ESP32) || defined(USE_RP2040_BLE)) && defined(USE_BLE_GATT_CLIENT)
+// Address-scoped (not connection-scoped) maintenance requests; keyed on the
+// stack (the calls need no backend instance).
+#if (defined(USE_ESP32_BLE) || defined(USE_RP2040_BLE)) && defined(USE_BLE_GATT_CLIENT)
 conn_err_t unpair_device(uint64_t address);
 #else
 inline conn_err_t unpair_device(uint64_t) { return GATT_NOT_CONNECTED; }
 #endif
-#if defined(USE_ESP32) && defined(USE_BLE_GATT_CLIENT)
+#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
 conn_err_t clear_gatt_cache(uint64_t address);
 #else
 inline conn_err_t clear_gatt_cache(uint64_t) { return GATT_NOT_CONNECTED; }

esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.cpp

@@ -2,10 +2,11 @@
 
 #if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
 
+#include "bluetooth_connection.h"
+
 // The in-place streamer serves the proxy's service-discovery API; backend-only
 // builds compile without the proxy headers or the streamer.
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
-#include "bluetooth_connection.h"
 #include "bluetooth_connection_hub.h"
 
 #include "esphome/components/bluetooth_proxy/bluetooth_proxy.h"
@@ -348,6 +349,9 @@ int BluedroidGattClient::update_connection_params(uint16_t min_interval, uint16_
 
 void BluedroidGattClient::release_services() {
   this->service_total_ = 0;
+#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
+  this->table_.free();
+#endif
   // Always set: terminates any in-flight stream on every cache config.
   this->services_released_ = true;
 #ifndef CONFIG_BT_GATTC_CACHE_NVS_FLASH
@@ -360,6 +364,24 @@ void BluedroidGattClient::release_services() {
 #endif
 }
 
+#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
+ble_device_base::GattServiceTable BluedroidGattClient::get_service_table() {
+  // Lifetime: every teardown path (CLOSE_EVT, the safety timeout, stack-down,
+  // passive DISCONNECT) routes through release_services(), so a materialized
+  // table cannot outlive its link.
+  if (this->table_.empty() &&
+      (this->services_released_ || this->service_total_ == 0 ||
+       !this->table_.build(this->gattc_if_, this->conn_id_, this->service_total_, this->connection_index_))) {
+    // Released / no services / failed build all collapse to empty; the
+    // build failures warned above, log the quiet two.
+    ESP_LOGD(TAG, "[%d] No service table (released=%d, services=%u)", this->connection_index_, this->services_released_,
+             this->service_total_);
+    return {};
+  }
+  return this->table_.view();
+}
+#endif  // USE_BLUEDROID_GATT_SERVICE_TABLE
+
 // ---- internals ----
 
 bool BluedroidGattClient::check_addr_(const esp_bd_addr_t &addr) const {
@@ -406,6 +428,11 @@ void BluedroidGattClient::log_gattc_warning_(const char *operation, int code) {
 // ---- service streaming ----
 
 int BluedroidGattClient::handle_search_cmpl_(esp_gatt_status_t status) {
+#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
+  // Re-discovery moves the counts the table view derives offsets from; free
+  // the stale table.
+  this->table_.free();
+#endif
   // Step down from the fast discovery params.
   this->update_conn_params_(MEDIUM_MIN_CONN_INTERVAL, MEDIUM_MAX_CONN_INTERVAL, 0, MEDIUM_CONN_TIMEOUT, "medium");
   if (status != ESP_GATT_OK) {

esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.h

@@ -11,6 +11,9 @@
 
 #if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
 
+#include "bluetooth_connection.h"
+#include "gatt_service_table_bluedroid.h"
+
 #include "esphome/components/ble_device_base/ble_gatt_client.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/component.h"
@@ -76,11 +79,16 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public
   int notify_characteristic(uint16_t handle, bool enable);
   int pair();
   int update_connection_params(uint16_t min_interval, uint16_t max_interval, uint16_t latency, uint16_t timeout);
-  // Contract stub: the proxy streams in place; the on-demand materializer
-  // for direct consumers lands with #18205. NOTE: a direct consumer reaching
-  // this stub gets an empty table indistinguishable from a service-less
-  // peer - do not ship one against this backend before the materializer.
+  // On-demand table for direct consumers; the proxy streams instead, so the
+  // materializer compiles only under USE_BLUEDROID_GATT_SERVICE_TABLE (emitted by
+  // direct-consumer codegen, never by the proxy).
+#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
+  ble_device_base::GattServiceTable get_service_table();
+#else
+  // A direct consumer reaching this stub misconfigured its codegen
+  // (service_table=False): the empty table reads as a service-less peer.
   ble_device_base::GattServiceTable get_service_table() { return {}; }
+#endif
   void release_services();
 
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
@@ -110,6 +118,9 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public
 
   // Group 1: pointers / composed objects
   ble_device_base::GattClientListener *listener_{nullptr};
+#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
+  BluedroidServiceTable table_;
+#endif
   // Group 2: 4-byte types
   uint32_t disconnecting_started_{0};
 

esphome/components/bluetooth_connection/bluetooth_connection_gatt_backend.h

@@ -12,10 +12,12 @@
 
 #include "esphome/components/ble_device_base/ble_gatt_client.h"
 
-#if defined(USE_RP2040_BLE)
+// Arms are keyed on codegen-emitted per-backend defines (_PLATFORM_BACKENDS
+// in __init__.py), so they are order-independent.
+#if defined(USE_BLE_GATT_BACKEND_RP2)
 #include "bluetooth_connection_rp2.h"
 #define ESPHOME_BLE_GATT_CONNECTION_TYPE bluetooth_connection::RP2GattClient
-#elif defined(USE_ESP32_BLE)
+#elif defined(USE_BLE_GATT_BACKEND_BLUEDROID)
 #include "bluetooth_connection_bluedroid.h"
 #define ESPHOME_BLE_GATT_CONNECTION_TYPE bluetooth_connection::BluedroidGattClient
 #elif defined(USE_BLE_GATT_CLIENT_STUB_BACKEND)

esphome/components/bluetooth_connection/gatt_service_table_bluedroid.cpp

@@ -0,0 +1,198 @@
+#include "gatt_service_table_bluedroid.h"
+
+#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT) && defined(USE_BLUEDROID_GATT_SERVICE_TABLE)
+
+#include "esphome/core/log.h"
+
+namespace esphome::bluetooth_connection {
+
+ESPHOME_LOG_TAG(TAG, "bluetooth_connection");
+
+// A stack that never reports end-of-range would otherwise walk forever.
+static constexpr uint16_t MAX_DESCRIPTORS_PER_CHARACTERISTIC = 64;
+
+// Shared enumeration for both build passes: an identical walk order is what
+// lets the counting pass size the block the filling pass fills.
+// INVALID_OFFSET/NOT_FOUND mean end-of-range; anything else is a failure.
+template<typename ServiceFn, typename CharFn, typename DescFn>
+bool BluedroidServiceTable::walk_(ServiceFn &&on_service, CharFn &&on_char, DescFn &&on_desc) {
+  for (uint16_t s = 0; s < this->service_total_; s++) {
+    esp_gattc_service_elem_t svc;
+    uint16_t svc_count = 1;
+    auto svc_status = esp_ble_gattc_get_service(this->gattc_if_, this->conn_id_, nullptr, &svc, &svc_count, s);
+    if (svc_status != ESP_GATT_OK || svc_count == 0) {
+      this->log_walk_warning_("esp_ble_gattc_get_service", svc_status);
+      return false;
+    }
+    if (!on_service(s, svc)) {
+      return false;
+    }
+    uint16_t svc_chars = 0;
+    auto count_status = esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_CHARACTERISTIC,
+                                                     svc.start_handle, svc.end_handle, 0, &svc_chars);
+    if (count_status != ESP_GATT_OK) {
+      this->log_walk_warning_("esp_ble_gattc_get_attr_count", count_status);
+      return false;
+    }
+    for (uint16_t c = 0; c < svc_chars; c++) {
+      esp_gattc_char_elem_t chr;
+      uint16_t char_count = 1;
+      auto status = esp_ble_gattc_get_all_char(this->gattc_if_, this->conn_id_, svc.start_handle, svc.end_handle, &chr,
+                                               &char_count, c);
+      if (status != ESP_GATT_OK || char_count == 0) {
+        // An early terminator contradicts svc_chars from the same cache;
+        // never build a silently truncated table.
+        this->log_walk_warning_("esp_ble_gattc_get_all_char", status);
+        return false;
+      }
+      if (!on_char(svc, chr)) {
+        return false;
+      }
+      for (uint16_t d = 0;; d++) {
+        if (d == MAX_DESCRIPTORS_PER_CHARACTERISTIC) {
+          // A stack that never reports end-of-range; fail like every other
+          // inconsistency instead of truncating the table silently.
+          ESP_LOGW(TAG, "[%d] Descriptor walk exceeded %u entries", this->log_index_,
+                   MAX_DESCRIPTORS_PER_CHARACTERISTIC);
+          return false;
+        }
+        esp_gattc_descr_elem_t desc;
+        uint16_t desc_count = 1;
+        auto desc_status =
+            esp_ble_gattc_get_all_descr(this->gattc_if_, this->conn_id_, chr.char_handle, &desc, &desc_count, d);
+        if (desc_status == ESP_GATT_INVALID_OFFSET || desc_status == ESP_GATT_NOT_FOUND) {
+          break;
+        }
+        if (desc_status != ESP_GATT_OK || desc_count == 0) {
+          this->log_walk_warning_("esp_ble_gattc_get_all_descr", desc_status);
+          return false;
+        }
+        if (!on_desc(chr, desc)) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool BluedroidServiceTable::count_services(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t *total) {
+  uint16_t primary = 0;
+  uint16_t secondary = 0;
+  if (esp_ble_gattc_get_attr_count(gattc_if, conn_id, ESP_GATT_DB_PRIMARY_SERVICE, 0x0001, 0xFFFF, 0, &primary) !=
+          ESP_GATT_OK ||
+      esp_ble_gattc_get_attr_count(gattc_if, conn_id, ESP_GATT_DB_SECONDARY_SERVICE, 0x0001, 0xFFFF, 0, &secondary) !=
+          ESP_GATT_OK) {
+    // A failed count must not read as an authoritative empty database.
+    return false;
+  }
+  *total = primary + secondary;
+  return true;
+}
+
+bool BluedroidServiceTable::build(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t service_total, uint8_t log_index) {
+  this->free();
+  this->gattc_if_ = gattc_if;
+  this->conn_id_ = conn_id;
+  this->service_total_ = service_total;
+  this->log_index_ = log_index;
+
+  // Pass 1: count, so one exact-size block holds the whole table.
+  uint16_t char_total = 0;
+  uint16_t desc_total = 0;
+  bool counted = this->walk_([](uint16_t, const esp_gattc_service_elem_t &) { return true; },
+                             [&](const esp_gattc_service_elem_t &, const esp_gattc_char_elem_t &) {
+                               char_total++;
+                               return true;
+                             },
+                             [&](const esp_gattc_char_elem_t &, const esp_gattc_descr_elem_t &) {
+                               desc_total++;
+                               return true;
+                             });
+  if (!counted) {
+    ESP_LOGW(TAG, "[%d] Service table walk failed during count", this->log_index_);
+    this->free();
+    return false;
+  }
+
+  // The arrays share one block; carving stays aligned because each struct's
+  // strictest member is the UUID and array sizes are multiples of it.
+  static_assert(alignof(ble_device_base::GattService) >= alignof(ble_device_base::GattCharacteristic) &&
+                alignof(ble_device_base::GattCharacteristic) >= alignof(ble_device_base::GattDescriptor));
+  size_t svc_bytes = this->service_total_ * sizeof(ble_device_base::GattService);
+  size_t char_bytes = char_total * sizeof(ble_device_base::GattCharacteristic);
+  size_t total_bytes = svc_bytes + char_bytes + desc_total * sizeof(ble_device_base::GattDescriptor);
+  RAMAllocator<uint8_t> allocator(RAMAllocator<uint8_t>::ALLOC_INTERNAL);
+  this->storage_ = allocator.allocate(total_bytes);
+  if (this->storage_ == nullptr) {
+    ESP_LOGW(TAG, "[%d] Service table allocation failed (%u bytes)", this->log_index_,
+             static_cast<unsigned>(total_bytes));
+    this->free();
+    return false;
+  }
+  auto *services = reinterpret_cast<ble_device_base::GattService *>(this->storage_);
+  auto *characteristics = reinterpret_cast<ble_device_base::GattCharacteristic *>(this->storage_ + svc_bytes);
+  auto *descriptors = reinterpret_cast<ble_device_base::GattDescriptor *>(this->storage_ + svc_bytes + char_bytes);
+
+  // Pass 2: fill, bounded by the pass-1 totals. A bound trip or a shortfall
+  // means the cached database changed between the passes; fail the build
+  // rather than serve an inconsistent table (the consumer retries).
+  uint16_t char_index = 0;
+  uint16_t desc_index = 0;
+  ble_device_base::GattService *cur_service = nullptr;
+  ble_device_base::GattCharacteristic *cur_char = nullptr;
+  bool filled = this->walk_(
+      [&](uint16_t s, const esp_gattc_service_elem_t &svc) {
+        cur_service = &services[s];
+        cur_service->uuid = ble_device_base::ESPBTUUID::from_uuid(svc.uuid);
+        cur_service->start_handle = svc.start_handle;
+        cur_service->end_handle = svc.end_handle;
+        cur_service->first_characteristic = char_index;
+        cur_service->characteristic_count = 0;
+        return true;
+      },
+      [&](const esp_gattc_service_elem_t &svc, const esp_gattc_char_elem_t &chr) {
+        if (char_index >= char_total) {
+          return false;
+        }
+        cur_char = &characteristics[char_index++];
+        cur_char->uuid = ble_device_base::ESPBTUUID::from_uuid(chr.uuid);
+        cur_char->value_handle = chr.char_handle;
+        // Bluedroid addresses descriptors by characteristic handle, so the
+        // table's end_handle only needs the service-bounded upper bound.
+        cur_char->end_handle = svc.end_handle;
+        cur_char->properties = chr.properties;
+        cur_char->first_descriptor = desc_index;
+        cur_char->descriptor_count = 0;
+        cur_service->characteristic_count++;
+        return true;
+      },
+      [&](const esp_gattc_char_elem_t &, const esp_gattc_descr_elem_t &desc) {
+        if (desc_index >= desc_total) {
+          return false;
+        }
+        descriptors[desc_index].uuid = ble_device_base::ESPBTUUID::from_uuid(desc.uuid);
+        descriptors[desc_index].handle = desc.handle;
+        desc_index++;
+        cur_char->descriptor_count++;
+        return true;
+      });
+  if (!filled || char_index != char_total || desc_index != desc_total) {
+    // Walk error or the database changed between passes; better an empty
+    // table than a corrupt one.
+    ESP_LOGW(TAG, "[%d] Service table walk mismatch, discarding", this->log_index_);
+    this->free();
+    return false;
+  }
+  this->char_total_ = char_total;
+  this->desc_total_ = desc_total;
+  return true;
+}
+
+void BluedroidServiceTable::log_walk_warning_(const char *operation, int code) {
+  ESP_LOGW(TAG, "[%d] %s failed, status=%d", this->log_index_, operation, code);
+}
+
+}  // namespace esphome::bluetooth_connection
+
+#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT && USE_BLUEDROID_GATT_SERVICE_TABLE

esphome/components/bluetooth_connection/gatt_service_table_bluedroid.h

@@ -0,0 +1,82 @@
+// Owning two-pass materializer of one Bluedroid GATT database snapshot into
+// the neutral GattServiceTable layout, shared by the BluedroidGattClient
+// backend and ble_client's esp32 engine.
+
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT) && defined(USE_BLUEDROID_GATT_SERVICE_TABLE)
+
+#include "esphome/components/ble_device_base/ble_gatt_client.h"
+#include "esphome/core/helpers.h"
+
+#include <esp_gattc_api.h>
+
+namespace esphome::bluetooth_connection {
+
+class BluedroidServiceTable {
+ public:
+  ~BluedroidServiceTable() { this->free(); }
+  // Owns storage_; a copy would double-free. The default constructor is user
+  // provided, not "= default", so value-initializing the enclosing backend
+  // cannot zero-fill .bss that is already zero.
+  BluedroidServiceTable() {}
+  BluedroidServiceTable(const BluedroidServiceTable &) = delete;
+  BluedroidServiceTable &operator=(const BluedroidServiceTable &) = delete;
+
+  /// The service count build() requires: the stack's PRIMARY+SECONDARY
+  /// attribute totals, never the SEARCH_RES event count.
+  static bool count_services(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t *total);
+
+  /// Two-pass build from the stack's cached database (service_total from
+  /// count_services()). log_index labels warnings. Frees any previous table
+  /// first; on failure the table is left empty.
+  bool build(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t service_total, uint8_t log_index);
+
+  // The view is carved from the storage block and the counts on each call
+  // (a cold path) rather than cached, saving a per-instance table member.
+  ble_device_base::GattServiceTable view() const {
+    size_t svc_bytes = this->service_total_ * sizeof(ble_device_base::GattService);
+    size_t char_bytes = this->char_total_ * sizeof(ble_device_base::GattCharacteristic);
+    return {reinterpret_cast<const ble_device_base::GattService *>(this->storage_),
+            reinterpret_cast<const ble_device_base::GattCharacteristic *>(this->storage_ + svc_bytes),
+            reinterpret_cast<const ble_device_base::GattDescriptor *>(this->storage_ + svc_bytes + char_bytes),
+            this->service_total_,
+            this->char_total_,
+            this->desc_total_};
+  }
+
+  // Always resets the counts: a failed build must never leave a non-zero
+  // service_total_ behind a null table.
+  void free() {
+    if (this->storage_ != nullptr) {
+      RAMAllocator<uint8_t> allocator(RAMAllocator<uint8_t>::ALLOC_INTERNAL);
+      allocator.deallocate(this->storage_, 0);
+      this->storage_ = nullptr;
+    }
+    this->service_total_ = 0;
+    this->char_total_ = 0;
+    this->desc_total_ = 0;
+  }
+
+  bool empty() const { return this->storage_ == nullptr; }
+
+ private:
+  template<typename ServiceFn, typename CharFn, typename DescFn>
+  bool walk_(ServiceFn &&on_service, CharFn &&on_char, DescFn &&on_desc);
+  void log_walk_warning_(const char *operation, int code);
+
+  uint8_t *storage_{nullptr};
+  uint16_t service_total_{0};
+  uint16_t char_total_{0};
+  uint16_t desc_total_{0};
+  // Walk context, set by build().
+  uint16_t conn_id_{0};
+  esp_gatt_if_t gattc_if_{};  // uint8_t width
+  uint8_t log_index_{0};
+};
+
+}  // namespace esphome::bluetooth_connection
+
+#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT && USE_BLUEDROID_GATT_SERVICE_TABLE

esphome/components/bluetooth_proxy/__init__.py

@@ -99,9 +99,15 @@ def _esp32_config_schema() -> cv.All:
                 raise cv.Invalid(
                     "Connections can only be used if the proxy is set to active"
                 )
+            # Explicit entries claim slots like the generated ones; dev
+            # historically skipped this, letting an explicit-connections
+            # config evade the controller budget.
+            bluetooth_connection.consume_gatt_slot(
+                "bluetooth_proxy", len(config[CONF_CONNECTIONS])
+            )(config)
         elif config[CONF_ACTIVE]:
             connection_slots: int = config[CONF_CONNECTION_SLOTS]
-            esp32_ble.consume_connection_slots(connection_slots, "bluetooth_proxy")(
+            bluetooth_connection.consume_gatt_slot("bluetooth_proxy", connection_slots)(
                 config
             )
 
@@ -158,14 +164,14 @@ def _rp2_config_schema() -> cv.All:
     connection_schema = bluetooth_connection.hub_connection_schema(PLATFORM_RP2)
 
     def populate_connections(config: ConfigType) -> ConfigType:
-        from esphome.components import rp2040_ble
-
         # One wrapper + backend pair per slot, declared during validation so
         # their ids exist for codegen (the esp32 arm's `connections` pattern).
         if not config[CONF_ACTIVE]:
             return config
         connection_slots: int = config[CONF_CONNECTION_SLOTS]
-        rp2040_ble.consume_connection_slots(connection_slots, "bluetooth_proxy")(config)
+        bluetooth_connection.consume_gatt_slot("bluetooth_proxy", connection_slots)(
+            config
+        )
         return {
             **config,
             CONF_CONNECTIONS: [connection_schema({}) for _ in range(connection_slots)],
@@ -215,7 +221,9 @@ async def _connections_to_code(var: cg.MockObj, config: ConfigType) -> None:
         # sends those requests and their handlers and encoders are dead.
         cg.add_define("USE_BLUETOOTH_PROXY_CONNECTIONS")
     for connection_conf in connections:
-        backend = await bluetooth_connection.new_gatt_backend(connection_conf)
+        backend = await bluetooth_connection.new_gatt_backend(
+            connection_conf, service_table=False
+        )
         connection = cg.new_Pvariable(connection_conf[CONF_ID])
         cg.add(connection.set_backend(backend))
         cg.add(var.register_connection(connection))

esphome/components/bme280_i2c/bme280_i2c.h

@@ -2,10 +2,11 @@
 
 #include "esphome/components/bme280_base/bme280_base.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/core/log.h"
 
 namespace esphome::bme280_i2c {
 
-static const char *const TAG = "bme280_i2c.sensor";
+ESPHOME_LOG_TAG(TAG, "bme280_i2c.sensor");
 
 class BME280I2CComponent final : public esphome::bme280_base::BME280Component, public i2c::I2CDevice {
   bool read_byte(uint8_t a_register, uint8_t *data) override;

esphome/components/bmp280_i2c/bmp280_i2c.h

@@ -2,10 +2,11 @@
 
 #include "esphome/components/bmp280_base/bmp280_base.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/core/log.h"
 
 namespace esphome::bmp280_i2c {
 
-static const char *const TAG = "bmp280_i2c.sensor";
+ESPHOME_LOG_TAG(TAG, "bmp280_i2c.sensor");
 
 /// This class implements support for the BMP280 Temperature+Pressure i2c sensor.
 class BMP280I2CComponent final : public esphome::bmp280_base::BMP280Component, public i2c::I2CDevice {

esphome/components/bmp581_i2c/bmp581_i2c.h

@@ -2,10 +2,11 @@
 
 #include "esphome/components/bmp581_base/bmp581_base.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/core/log.h"
 
 namespace esphome::bmp581_i2c {
 
-static const char *const TAG = "bmp581_i2c.sensor";
+ESPHOME_LOG_TAG(TAG, "bmp581_i2c.sensor");
 
 /// This class implements support for the BMP581 Temperature+Pressure i2c sensor.
 class BMP581I2CComponent final : public esphome::bmp581_base::BMP581Component, public i2c::I2CDevice {

esphome/components/chsc6x/chsc6x_touchscreen.h

@@ -8,7 +8,7 @@
 
 namespace esphome::chsc6x {
 
-static const char *const TAG = "chsc6x.touchscreen";
+ESPHOME_LOG_TAG(TAG, "chsc6x.touchscreen");
 
 static const uint8_t CHSC6X_REG_STATUS = 0x00;
 static const uint8_t CHSC6X_REG_STATUS_TOUCH = 0x00;

esphome/components/cst816/touchscreen/cst816_touchscreen.h

@@ -8,7 +8,7 @@
 
 namespace esphome::cst816 {
 
-static const char *const TAG = "cst816.touchscreen";
+ESPHOME_LOG_TAG(TAG, "cst816.touchscreen");
 
 static const uint8_t REG_STATUS = 0x00;
 static const uint8_t REG_TOUCH_NUM = 0x02;

esphome/components/cst9220/touchscreen/cst9220_touchscreen.h

@@ -8,7 +8,7 @@
 
 namespace esphome::cst9220 {
 
-static const char *const TAG = "cst9220.touchscreen";
+ESPHOME_LOG_TAG(TAG, "cst9220.touchscreen");
 
 // The CST92xx family uses 16-bit (big-endian) register addresses.
 static const uint16_t REG_TOUCH_DATA = 0xD000;  // touch report

esphome/components/emontx/__init__.py

@@ -23,11 +23,18 @@ DEPENDENCIES = ["uart"]
 
 emontx_ns = cg.esphome_ns.namespace("emontx")
 EmonTx = emontx_ns.class_("EmonTx", cg.Component, uart.UARTDevice)
+LockOnReboot = emontx_ns.enum("LockOnReboot", is_class=True)
 
 CONF_EMONTX_ID = "emontx_id"
 CONF_TAG_NAME = "tag_name"
 CONF_ON_JSON = "on_json"
 CONF_LOCK_ON_REBOOT = "lock_on_reboot"
+LOCK_ON_REBOOT_AUTO = "auto"
+LOCK_ON_REBOOT_MODES = {
+    LOCK_ON_REBOOT_AUTO: LockOnReboot.LOCK_ON_REBOOT_AUTO,
+    True: LockOnReboot.LOCK_ON_REBOOT_ALWAYS,
+    False: LockOnReboot.LOCK_ON_REBOOT_NEVER,
+}
 
 DOMAIN = "emontx"
 
@@ -59,7 +66,9 @@ CONFIG_SCHEMA = (
             cv.GenerateID(): cv.declare_id(EmonTx),
             cv.Optional(CONF_ON_JSON): _synchronous_automation_schema(),
             cv.Optional(CONF_ON_DATA): _synchronous_automation_schema(),
-            cv.Optional(CONF_LOCK_ON_REBOOT, default=False): cv.boolean,
+            cv.Optional(CONF_LOCK_ON_REBOOT, default=LOCK_ON_REBOOT_AUTO): cv.Any(
+                cv.boolean, cv.one_of(LOCK_ON_REBOOT_AUTO, lower=True)
+            ),
         }
     )
     .extend(cv.COMPONENT_SCHEMA)
@@ -135,8 +144,11 @@ async def to_code(config: ConfigType) -> None:
     await uart.register_uart_device(var, config)
     await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
-    if config[CONF_LOCK_ON_REBOOT]:
-        cg.add(var.set_lock_on_reboot(True))
+    lock = config[CONF_LOCK_ON_REBOOT]
+    cg.add(var.set_lock_on_reboot(LOCK_ON_REBOOT_MODES[lock]))
+    if lock == LOCK_ON_REBOOT_AUTO:
+        # Locking depends on the firmware version the emonTx reports
+        cg.add_define("USE_EMONTX_VERSION")
 
 
 # Action: emontx.send_command

esphome/components/emontx/emontx.cpp

@@ -7,30 +7,85 @@ namespace esphome::emontx {
 
 ESPHOME_LOG_TAG(TAG, "emontx");
 
+static constexpr uint32_t UNLOCK_ID = 0;
+// The emonTx joins bytes received while a command is pending into that command, so the next one waits
+static constexpr uint32_t COMMAND_GAP_MS = 250;
+
 #ifdef USE_EMONTX_VERSION
-static constexpr uint32_t VERSION_REQUEST_ID = 0;
-// The emonTx joins bytes received while a command is pending into that command, so 'v' waits
-static constexpr uint32_t VERSION_REQUEST_DELAY_MS = 250;
+static constexpr uint32_t VERSION_REQUEST_ID = 1;
+// Without a reply, 'v' is sent again every VERSION_RETRY_FRAMES data lines, VERSION_MAX_ATTEMPTS times in all
+static constexpr uint8_t VERSION_RETRY_FRAMES = 2;
+static constexpr uint8_t VERSION_MAX_ATTEMPTS = 3;
 // Line of the 'v' reply (and of the boot banner) carrying the release, e.g. "  - Version:    v1.1.1"
 static const char VERSION_PREFIX[] PROGMEM = "  - Version:";
+// Every data line starts with the message counter, in JSON or text format
+static const char MSG_JSON_PREFIX[] PROGMEM = "{\"MSG\":";
+static const char MSG_TEXT_PREFIX[] PROGMEM = "MSG:";
+// First firmware with 'emonlock' and 'emonunlock'; older firmware takes them for the bootloader command
+static constexpr uint32_t LOCK_MIN_MAJOR = 1;
+static constexpr uint32_t LOCK_MIN_MINOR = 2;
+
+// True if line starts with the PROGMEM prefix and has more after it
+static bool starts_with(const char *line, size_t len, const char *prefix, size_t prefix_len) {
+  return len > prefix_len && ESPHOME_strncmp_P(line, prefix, prefix_len) == 0;
+}
+
+// Reads the decimal number (up to 9 digits) at pos and moves pos past it; false if there is none
+static bool read_number(const char *&pos, const char *end, uint32_t &value) {
+  const char *start = pos;
+  value = 0;
+  while (pos < end && pos - start < 9 && *pos >= '0' && *pos <= '9')
+    value = value * 10 + (*pos++ - '0');
+  return pos != start;
+}
+
+// True for a release such as "v1.2.0" or "v1.3.0-rc1" from LOCK_MIN_MAJOR.LOCK_MIN_MINOR on
+static bool supports_lock(const char *version, const char *end) {
+  if (version < end && (*version == 'v' || *version == 'V'))
+    version++;
+  uint32_t major;
+  if (!read_number(version, end, major) || version == end || *version != '.')
+    return false;
+  version++;
+  uint32_t minor;
+  if (!read_number(version, end, minor))
+    return false;
+  return major > LOCK_MIN_MAJOR || (major == LOCK_MIN_MAJOR && minor >= LOCK_MIN_MINOR);
+}
 #endif
 
 void EmonTx::setup() {
   this->buffer_pos_ = 0;
-  if (this->lock_on_reboot_) {
-    // The line feed ends any boot noise first
-    ESP_LOGI(TAG, "Unlocking emonTx after boot");
+  if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_ALWAYS) {
+    // The line feed ends any boot noise
     this->write_byte('\n');
-    this->send_command("emonunlock");
+    this->set_timeout(UNLOCK_ID, COMMAND_GAP_MS, [this]() {
+      this->unlock_();
+#ifdef USE_EMONTX_VERSION
+      if (this->wants_version_())
+        this->request_version_();
+#endif
+    });
+    return;
   }
 #ifdef USE_EMONTX_VERSION
-  if (this->version_text_sensor_ != nullptr)
+  // With AUTO, the reply decides whether to unlock
+  if (this->wants_version_())
     this->request_version_();
 #endif
 }
 
+void EmonTx::unlock_() {
+  ESP_LOGI(TAG, "Unlocking emonTx");
+  this->send_command("emonunlock");
+}
+
 void EmonTx::on_shutdown() {
-  if (!this->lock_on_reboot_)
+  bool lock = this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_ALWAYS;
+#ifdef USE_EMONTX_VERSION
+  lock |= this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO && this->lock_supported_;
+#endif
+  if (!lock)
     return;
   if (this->is_paused()) {
     ESP_LOGW(TAG, "Not locking emonTx before shutdown, UART is paused");
@@ -63,7 +118,7 @@ void EmonTx::loop() {
       this->discarding_line_ = dropped != '\n';
 #ifdef USE_EMONTX_VERSION
     // The emonTx may have been flashed, or a request dropped, during the pause
-    if (this->version_text_sensor_ != nullptr)
+    if (this->wants_version_())
       this->request_version_();
 #endif
   }
@@ -96,8 +151,10 @@ void EmonTx::loop() {
           this->parse_json_(this->buffer_.data(), len);
         }
 #ifdef USE_EMONTX_VERSION
-        if (this->version_text_sensor_ != nullptr)
+        if (this->wants_version_()) {
+          this->parse_msg_number_(this->buffer_.data(), len);
           this->parse_version_line_(this->buffer_.data(), len);
+        }
 #endif
       }
     } else if (received == '\r' || this->discarding_line_) {
@@ -124,16 +181,6 @@ void EmonTx::parse_json_(const char *data, size_t len) {
       }
     }
 #endif
-#ifdef USE_EMONTX_VERSION
-    auto msg = root["MSG"];
-    if (this->version_text_sensor_ != nullptr && msg.is<uint32_t>()) {
-      // MSG restarts at 1 when the emonTx reboots, as it does after a firmware update
-      uint32_t msg_number = msg;
-      if (msg_number <= this->last_msg_number_)
-        this->request_version_();
-      this->last_msg_number_ = msg_number;
-    }
-#endif
 
     this->json_callbacks_.call(root, StringRef(data, len));
     return true;
@@ -145,17 +192,50 @@ void EmonTx::parse_json_(const char *data, size_t len) {
 }
 
 #ifdef USE_EMONTX_VERSION
-// The line feed ends any pending input; the reply is picked up in loop() by parse_version_line_()
 void EmonTx::request_version_() {
+  // The firmware may have changed; until the reply, an unknown version gets no lock commands
+  this->lock_supported_ = false;
+  this->version_frames_left_ = VERSION_RETRY_FRAMES * VERSION_MAX_ATTEMPTS;
+  this->send_version_request_();
+}
+
+// The line feed ends any pending input; the reply is picked up in loop() by parse_version_line_()
+void EmonTx::send_version_request_() {
   if (this->is_paused())
     return;
   this->write_byte('\n');
-  this->set_timeout(VERSION_REQUEST_ID, VERSION_REQUEST_DELAY_MS, [this]() { this->send_command("v"); });
+  this->set_timeout(VERSION_REQUEST_ID, COMMAND_GAP_MS, [this]() { this->send_command("v"); });
+}
+
+void EmonTx::parse_msg_number_(const char *line, size_t len) {
+  const char *pos;
+  if (starts_with(line, len, MSG_JSON_PREFIX, sizeof(MSG_JSON_PREFIX) - 1)) {
+    pos = line + sizeof(MSG_JSON_PREFIX) - 1;
+  } else if (starts_with(line, len, MSG_TEXT_PREFIX, sizeof(MSG_TEXT_PREFIX) - 1)) {
+    pos = line + sizeof(MSG_TEXT_PREFIX) - 1;
+  } else {
+    return;
+  }
+  uint32_t msg_number;
+  if (!read_number(pos, line + len, msg_number))
+    return;
+
+  // MSG restarts at 1 when the emonTx reboots, as it does after a firmware update
+  if (msg_number <= this->last_msg_number_) {
+    this->request_version_();
+  } else if (this->version_frames_left_ > 0) {
+    if (--this->version_frames_left_ == 0) {
+      ESP_LOGW(TAG, "No firmware version from the emonTx, it may still be locked");
+    } else if (this->version_frames_left_ % VERSION_RETRY_FRAMES == 0) {
+      this->send_version_request_();
+    }
+  }
+  this->last_msg_number_ = msg_number;
 }
 
 void EmonTx::parse_version_line_(const char *line, size_t len) {
   constexpr size_t prefix_len = sizeof(VERSION_PREFIX) - 1;
-  if (len <= prefix_len || ESPHOME_strncmp_P(line, VERSION_PREFIX, prefix_len) != 0)
+  if (!starts_with(line, len, VERSION_PREFIX, prefix_len))
     return;
   const char *version = line + prefix_len;
   const char *end = line + len;
@@ -164,7 +244,23 @@ void EmonTx::parse_version_line_(const char *line, size_t len) {
   if (version == end)
     return;
   ESP_LOGI(TAG, "emonTx firmware version: %.*s", static_cast<int>(end - version), version);
-  this->version_text_sensor_->publish_state(version, end - version);
+  this->version_frames_left_ = 0;
+#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
+  if (this->version_text_sensor_ != nullptr)
+    this->version_text_sensor_->publish_state(version, end - version);
+#endif
+
+  bool supported = supports_lock(version, end);
+  if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO && supported && !this->unlock_sent_) {
+    // Once the rest of the reply has gone out; a pause drops it, and the version request on resume retries
+    this->set_timeout(UNLOCK_ID, COMMAND_GAP_MS, [this]() {
+      if (this->is_paused())
+        return;
+      this->unlock_();
+      this->unlock_sent_ = true;
+    });
+  }
+  this->lock_supported_ = supported;
 }
 #endif
 
@@ -173,7 +269,13 @@ void EmonTx::parse_version_line_(const char *line, size_t len) {
  */
 void EmonTx::dump_config() {
   ESP_LOGCONFIG(TAG, "EmonTx:");
-  ESP_LOGCONFIG(TAG, "  Lock on reboot: %s", YESNO(this->lock_on_reboot_));
+  const char *lock = LOG_STR_LITERAL("no");
+  if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_ALWAYS) {
+    lock = LOG_STR_LITERAL("yes");
+  } else if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO) {
+    lock = LOG_STR_LITERAL("auto");
+  }
+  ESP_LOGCONFIG(TAG, "  Lock on reboot: %s", lock);
 
 #ifdef USE_SENSOR
   ESP_LOGCONFIG(TAG, "  Registered sensors: %zu", this->sensors_.size());
@@ -183,7 +285,7 @@ void EmonTx::dump_config() {
 #else
   ESP_LOGCONFIG(TAG, "  Sensor support: DISABLED");
 #endif
-#ifdef USE_EMONTX_VERSION
+#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
   LOG_TEXT_SENSOR("  ", "Firmware version", this->version_text_sensor_);
 #endif
 }

esphome/components/emontx/emontx.h

@@ -13,7 +13,7 @@
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"
 #endif
-#ifdef USE_EMONTX_VERSION
+#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
 #include "esphome/components/text_sensor/text_sensor.h"
 #endif
 
@@ -22,6 +22,12 @@ namespace esphome::emontx {
 /// Maximum line length in bytes (plus one byte reserved for null terminator)
 static constexpr size_t MAX_LINE_LENGTH = 1024;
 
+enum class LockOnReboot : uint8_t {
+  LOCK_ON_REBOOT_NEVER,
+  LOCK_ON_REBOOT_ALWAYS,
+  LOCK_ON_REBOOT_AUTO,  // Only when the emonTx reports firmware v1.2.0 or later
+};
+
 /**
  * @class EmonTx
  * @brief Main class for the EmonTx component.
@@ -30,7 +36,7 @@ static constexpr size_t MAX_LINE_LENGTH = 1024;
  * extracts tags and values, and publishes them to registered sensors.
  */
 class EmonTx final : public Component, public uart::UARTDevice {
-#ifdef USE_EMONTX_VERSION
+#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
   SUB_TEXT_SENSOR(version)
 #endif
  public:
@@ -56,8 +62,8 @@ class EmonTx final : public Component, public uart::UARTDevice {
   bool is_paused() const { return this->paused_.load(std::memory_order_relaxed); }
 
   /// Lock the emonTx ('emonlock') before a reboot, so serial garbage during the reboot is not taken
-  /// as a command, and unlock it in setup(). Needs emonTx firmware v1.2.0 or later.
-  void set_lock_on_reboot(bool lock_on_reboot) { this->lock_on_reboot_ = lock_on_reboot; }
+  /// as a command, and unlock it after boot. Needs emonTx firmware v1.2.0 or later, which AUTO checks.
+  void set_lock_on_reboot(LockOnReboot lock_on_reboot) { this->lock_on_reboot_ = lock_on_reboot; }
 
 #ifdef USE_SENSOR
   void init_sensors(size_t count) { this->sensors_.init(count); }
@@ -66,8 +72,18 @@ class EmonTx final : public Component, public uart::UARTDevice {
 
  protected:
   void parse_json_(const char *data, size_t len);
+  void unlock_();
 #ifdef USE_EMONTX_VERSION
+  bool wants_version_() const {
+#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
+    if (this->version_text_sensor_ != nullptr)
+      return true;
+#endif
+    return this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO;
+  }
   void request_version_();
+  void send_version_request_();
+  void parse_msg_number_(const char *line, size_t len);
   void parse_version_line_(const char *line, size_t len);
 #endif
 
@@ -79,9 +95,12 @@ class EmonTx final : public Component, public uart::UARTDevice {
   uint16_t buffer_pos_{0};
   std::atomic<bool> paused_{false};
   bool was_paused_{false};
-  bool lock_on_reboot_{false};
+  LockOnReboot lock_on_reboot_{LockOnReboot::LOCK_ON_REBOOT_NEVER};
   bool discarding_line_{false};  // Set after an overflow or a pause until the end of that line
 #ifdef USE_EMONTX_VERSION
+  bool lock_supported_{false};      // The last version reported is v1.2.0 or later
+  bool unlock_sent_{false};         // AUTO has sent 'emonunlock' since boot
+  uint8_t version_frames_left_{0};  // Data lines still to wait for a version reply; 0 when none is owed
   uint32_t last_msg_number_{0};
 #endif
   std::array<char, MAX_LINE_LENGTH + 1> buffer_{};

esphome/components/emontx/text_sensor/__init__.py

@@ -21,3 +21,4 @@ async def to_code(config: ConfigType) -> None:
     text_sensors = text_sensor.sub_text_sensors(config)
     if await text_sensors(CONF_VERSION, hub.set_version_text_sensor) is not None:
         cg.add_define("USE_EMONTX_VERSION")
+        cg.add_define("USE_EMONTX_VERSION_TEXT_SENSOR")

esphome/components/epaper_spi/epaper_spi.cpp

@@ -131,9 +131,7 @@ void EPaperBase::update() {
 }
 
 void EPaperBase::wait_for_idle_(bool should_wait) {
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   this->waiting_for_idle_start_ = millis();
-#endif
   this->waiting_for_idle_ = should_wait;
 }
 
@@ -156,6 +154,10 @@ void EPaperBase::loop() {
       ESP_LOGV(TAG, "Screen was busy for %u ms", (unsigned) (millis() - this->waiting_for_idle_start_));
 #endif
     } else {
+      if (now - this->waiting_for_idle_start_ > this->busy_timeout_seconds_ * 1000u) {
+        this->abandon_update_();
+        return;
+      }
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
       if (now - this->waiting_for_idle_last_print_ >= 1000) {
         ESP_LOGV(TAG, "Waiting for idle in state %s", this->epaper_state_to_string_());
@@ -168,6 +170,20 @@ void EPaperBase::loop() {
   this->process_state_();
 }
 
+// The busy pin never cleared: give up on this update so later ones are not refused, and make the next one full
+void EPaperBase::abandon_update_() {
+  ESP_LOGE(TAG, "Display stayed busy for %u s in state %s; check the busy pin", (unsigned) this->busy_timeout_seconds_,
+           this->epaper_state_to_string_());
+  this->status_set_warning(LOG_STR("Busy pin timeout"));
+  if (this->state_ == EPaperState::TRANSFER_DATA)
+    this->abort_transfer();
+  // Leave the panel powered down rather than with its high-voltage drivers enabled
+  this->power_off();
+  this->full_update_requested_ = true;
+  this->current_data_index_ = 0;
+  this->set_state_(EPaperState::IDLE);
+}
+
 /**
  * Process the state machine.
  * Typical state sequence:
@@ -242,6 +258,7 @@ void EPaperBase::process_state_() {
       break;
     case EPaperState::DEEP_SLEEP:
       this->deep_sleep();
+      this->status_clear_warning();
       this->set_state_(EPaperState::IDLE);
       ESP_LOGD(TAG, "Display update took %" PRIu32 " ms", millis() - this->update_start_time_);
       break;

esphome/components/epaper_spi/epaper_spi.h

@@ -127,6 +127,7 @@ class EPaperBase : public Display,
   virtual bool initialise(bool partial);
   void send_init_sequence_(const uint8_t *sequence, size_t length);
   void wait_for_idle_(bool should_wait);
+  void abandon_update_();
   bool init_buffer_(size_t buffer_length);
   void update_effective_transform_();
   bool rotate_coordinates_(int &x, int &y);
@@ -143,6 +144,8 @@ class EPaperBase : public Display,
    * @return true if done, false if it should be called next loop
    */
   virtual bool transfer_data() = 0;
+  // Called when an update is abandoned in the middle of transfer_data(), to release anything it left open
+  virtual void abort_transfer() {}
   /**
    * Refresh the screen after data transfer
    */
@@ -193,18 +196,20 @@ class EPaperBase : public Display,
   // point to the pixel past the last one updated, i.e. may range up to width/height.
   uint16_t x_low_{}, y_low_{}, x_high_{}, y_high_{};
 
+  uint32_t waiting_for_idle_start_{};
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   uint32_t waiting_for_idle_last_print_{};
-  uint32_t waiting_for_idle_start_{};
 #endif
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
   uint32_t update_start_time_{};
 #endif
 
   // properties with specific initialisers go last
-  EPaperState state_{EPaperState::IDLE};
   uint32_t reset_duration_{10};
+  // Longer than any panel takes to refresh; past it the busy pin is assumed stuck
+  uint16_t busy_timeout_seconds_{120};
   uint8_t full_update_every_{1};
+  EPaperState state_{EPaperState::IDLE};
 };
 
 }  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi_t133a01.cpp

@@ -364,6 +364,15 @@ bool HOT EPaperT133A01::transfer_data() {
   return true;
 }
 
+void EPaperT133A01::abort_transfer() {
+  // A data stream is open, with one of the chip selects held low, whenever transfer_data() has started sending rows
+  if (this->current_data_index_ == 0)
+    return;
+  this->disable();
+  this->cs_pin_->digital_write(true);
+  this->cs1_pin_->digital_write(true);
+}
+
 void EPaperT133A01::dump_config() {
   EPaperBase::dump_config();
   LOG_PIN("  CS Pin: ", this->cs_pin_);

esphome/components/epaper_spi/epaper_spi_t133a01.h

@@ -46,6 +46,7 @@ class EPaperT133A01 : public EPaperBase {
   void deep_sleep() override;
 
   bool transfer_data() override;
+  void abort_transfer() override;
 
   /**
    * Send a command (and optional data) selecting one or both controllers.

esphome/components/ezo/ezo.h

@@ -3,11 +3,12 @@
 #include "esphome/core/component.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/core/log.h"
 #include <deque>
 
 namespace esphome::ezo {
 
-static const char *const TAG = "ezo.sensor";
+ESPHOME_LOG_TAG(TAG, "ezo.sensor");
 
 enum EzoCommandType : uint8_t {
   EZO_READ = 0,

esphome/components/file/image.py

@@ -330,7 +330,9 @@ async def write_image(
         if byte_order is not None:
             # Check for valid type has already been done in validate_settings
             encoder.set_big_endian(byte_order == "BIG_ENDIAN")
-        pixels = encoder.convert(image.resize((width, height)), path).getdata()
+        pixels = encoder.convert(
+            image.resize((width, height)), path
+        ).get_flattened_data()
         for row in range(height):
             for col in range(width):
                 encoder.encode(pixels[row * width + col])

esphome/components/ili9xxx/ili9xxx_display.h

@@ -2,12 +2,13 @@
 #include "esphome/components/spi/spi.h"
 #include "esphome/components/display/display_buffer.h"
 #include "esphome/components/display/display_color_utils.h"
+#include "esphome/core/log.h"
 #include "ili9xxx_defines.h"
 #include "ili9xxx_init.h"
 
 namespace esphome::ili9xxx {
 
-static const char *const TAG = "ili9xxx";
+ESPHOME_LOG_TAG(TAG, "ili9xxx");
 const size_t ILI9XXX_TRANSFER_BUFFER_SIZE = 126;  // ensure this is divisible by 6
 
 enum ILI9XXXColorMode {

esphome/components/lvgl/lvgl_esphome.h

@@ -214,7 +214,7 @@ enum class Orientation : uint8_t {
 };
 
 class LvglComponent final : public PollingComponent {
-  constexpr static const char *const TAG = "lvgl";
+  constexpr static const char *const TAG = "lvgl";  // NOLINT: lvgl does not build for ESP8266
 
  public:
   LvglComponent(std::vector<display::Display *> displays, float buffer_frac, bool full_refresh, int draw_rounding,

esphome/components/mapping/mapping.h

@@ -19,7 +19,7 @@ using alloc_string_t = std::basic_string<char, std::char_traits<char>, RAMAlloca
  * @tparam V The type of the value in the mapping. Should be a basic type or pointer.
  */
 
-static const char *const TAG = "mapping";
+ESPHOME_LOG_TAG(TAG, "mapping");
 
 template<typename K, typename V> class Mapping {
  public:

esphome/components/mdns/mdns_component.cpp

@@ -20,6 +20,10 @@
 #ifdef USE_DASHBOARD_IMPORT
 #include "esphome/components/dashboard_import/dashboard_import.h"
 #endif
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+#include "esphome/components/ethernet/ethernet_component.h"
+#include "esphome/components/wifi/wifi_component.h"
+#endif
 
 namespace esphome::mdns {
 
@@ -39,6 +43,45 @@ MDNS_STATIC_CONST_CHAR(SERVICE_TCP, "_tcp");
 // Wrap build-time defines into flash storage
 MDNS_STATIC_CONST_CHAR(VALUE_VERSION, ESPHOME_VERSION);
 
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
+MDNS_STATIC_CONST_CHAR(NETWORK_ETHERNET, "ethernet");
+
+// Same order as the default route in NetworkComponent::loop()
+const char *MDNSComponent::connected_network_() const {
+  const bool ethernet = ethernet::global_eth_component->is_connected();
+  const bool wifi = wifi::global_wifi_component->is_connected();
+#ifdef USE_NETWORK_PRIMARY_INTERFACE_WIFI
+  if (wifi)
+    return NETWORK_WIFI;
+#endif
+  if (ethernet)
+    return NETWORK_ETHERNET;
+  if (wifi)
+    return NETWORK_WIFI;
+  return nullptr;
+}
+
+void MDNSComponent::update_network_txt_() {
+  if (this->network_txt_ == nullptr)
+    return;
+  // With no interface connected, keep the last value instead of flapping to wifi
+  const char *network = this->connected_network_();
+  if (network == nullptr || network == this->network_txt_)
+    return;
+  if (!this->publish_network_txt_(network)) {
+    // The _esphomelib service is missing, so a retry would fail too
+    this->network_txt_ = nullptr;
+    return;
+  }
+  ESP_LOGD(TAG, "Network TXT: %s", network);
+  this->network_txt_ = network;
+#ifdef USE_MDNS_STORE_SERVICES
+  this->network_record_->value = MDNS_STR(network);
+#endif
+}
+#endif
+
 void MDNSComponent::setup_buffers_and_register_(PlatformRegisterFn platform_register) {
 #ifdef USE_MDNS_STORE_SERVICES
   auto &services = this->services_;
@@ -160,7 +203,15 @@ void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUN
 
     txt_records.push_back({MDNS_STR(TXT_BOARD), MDNS_STR(VALUE_BOARD)});
 
-#if defined(USE_WIFI)
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+    const char *network = this->connected_network_();
+    this->network_txt_ = network != nullptr ? network : NETWORK_WIFI;
+    txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(this->network_txt_)});
+#ifdef USE_MDNS_STORE_SERVICES
+    // services is services_ here, which never reallocates
+    this->network_record_ = &txt_records.back();
+#endif
+#elif defined(USE_WIFI)
     MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
     txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_WIFI)});
 #elif defined(USE_ETHERNET)

esphome/components/mdns/mdns_component.h

@@ -32,6 +32,12 @@
 #define USE_MDNS_DEVICE_INFO_TXT
 #endif
 
+// With both wifi and ethernet, the _esphomelib "network" TXT value follows the connected interface.
+// OpenThread hands its services to the SRP client once, so it keeps the fixed value.
+#if defined(USE_API) && defined(USE_WIFI) && defined(USE_ETHERNET) && !defined(USE_OPENTHREAD)
+#define USE_MDNS_DYNAMIC_NETWORK_TXT
+#endif
+
 namespace esphome::mdns {
 
 // Helper struct that identifies strings that may be stored in flash storage (similar to LogString)
@@ -150,6 +156,22 @@ class MDNSComponent final : public Component
 
   void setup_buffers_and_register_(PlatformRegisterFn platform_register);
 
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+  static constexpr uint32_t NETWORK_TXT_CHECK_INTERVAL_MS = 1000;
+  /// The first connected interface in network: priority order ("ethernet" or "wifi"), else nullptr.
+  const char *connected_network_() const;
+  /// Check the connected interface and publish a changed "network" TXT value.
+  void update_network_txt_();
+  /// Platform-specific: replace the "network" TXT value of the registered _esphomelib service.
+  bool publish_network_txt_(const char *network);
+  /// Advertised value; nullptr until the _esphomelib service is registered, and after a failed publish.
+  const char *network_txt_{nullptr};
+#ifdef USE_MDNS_STORE_SERVICES
+  /// The "network" record in services_, kept in step with network_txt_.
+  MDNSTXTRecord *network_record_{nullptr};
+#endif
+#endif
+
 #ifdef USE_MDNS_DYNAMIC_TXT
   /// Storage for runtime-generated TXT values from user lambdas
   /// Pre-sized at compile time via MDNS_DYNAMIC_TXT_COUNT to avoid heap allocations.

esphome/components/mdns/mdns_esp32.cpp

@@ -89,7 +89,24 @@ bool MDNSComponent::set_service_enabled(const char *service_type, const char *pr
 }
 #endif  // USE_MDNS_SUPPORTS_ENABLE_DISABLE && !USE_OPENTHREAD
 
-void MDNSComponent::setup() { this->setup_buffers_and_register_(register_esp32); }
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+bool MDNSComponent::publish_network_txt_(const char *network) {
+  // ESP-IDF copies the value and announces the changed record
+  esp_err_t err = mdns_service_txt_item_set("_esphomelib", "_tcp", "network", network);
+  if (err != ESP_OK) {
+    ESP_LOGW(TAG, "Failed to update network TXT: %s", esp_err_to_name(err));
+    return false;
+  }
+  return true;
+}
+#endif
+
+void MDNSComponent::setup() {
+  this->setup_buffers_and_register_(register_esp32);
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS, [this]() { this->update_network_txt_(); });
+#endif
+}
 
 void MDNSComponent::on_shutdown() {
 #ifndef USE_OPENTHREAD

esphome/components/mdns/mdns_rp2.cpp

@@ -46,7 +46,26 @@ void MDNSComponent::start_polling_window_() {
 }
 #endif
 
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+ESPHOME_LOG_TAG(TAG, "mdns");
+
+bool MDNSComponent::publish_network_txt_(const char *network) {
+  // LEAmDNS replaces the value of an existing key; announce() sends the change
+  if (!MDNS.addServiceTxt("esphomelib", "tcp", "network", network)) {
+    ESP_LOGW(TAG, "Failed to update network TXT");
+    return false;
+  }
+  MDNS.announce();
+  this->start_polling_window_();
+  return true;
+}
+#endif
+
 void MDNSComponent::setup() {
+#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
+  // No-op until the first IP-up event registers the services
+  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS, [this]() { this->update_network_txt_(); });
+#endif
   // arduino-pico stubs out LwipIntf::stateUpCB (the netif status callback LEAmDNS uses
   // on ESP8266 for auto-restart), so we must drive begin()/notifyAPChange() from our
   // own IP state listener. Both WiFi and Ethernet have the same listener signature —

esphome/components/midea/ac_adapter.cpp

@@ -5,7 +5,7 @@
 
 namespace esphome::midea::ac {
 
-const char *const Constants::TAG = "midea";
+const char Constants::TAG[] PROGMEM = "midea";
 const char *const Constants::FREEZE_PROTECTION = "Freeze Protection";
 const char *const Constants::SILENT = "Silent";
 const char *const Constants::TURBO = "Turbo";

esphome/components/midea/ac_adapter.h

@@ -17,7 +17,7 @@ using MideaPreset = dudanov::midea::ac::Preset;
 
 class Constants {
  public:
-  static const char *const TAG;
+  static const char TAG[];  // PROGMEM, like ESPHOME_LOG_TAG
   static const char *const FREEZE_PROTECTION;
   static const char *const SILENT;
   static const char *const TURBO;

esphome/components/mipi_dsi/mipi_dsi.h

@@ -18,7 +18,7 @@
 
 namespace esphome::mipi_dsi {
 
-constexpr static const char *const TAG = "display.mipi_dsi";
+ESPHOME_LOG_TAG(TAG, "display.mipi_dsi");
 const uint8_t SW_RESET_CMD = 0x01;
 const uint8_t SLEEP_OUT = 0x11;
 const uint8_t SDIR_CMD = 0xC7;

esphome/components/mipi_rgb/mipi_rgb.h

@@ -2,6 +2,7 @@
 
 #if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S31)
 #include "esphome/core/gpio.h"
+#include "esphome/core/log.h"
 #include "esphome/components/display/display.h"
 #include <esp_lcd_panel_rgb.h>
 #ifdef USE_SPI
@@ -10,7 +11,7 @@
 
 namespace esphome::mipi_rgb {
 
-constexpr static const char *const TAG = "display.mipi_rgb";
+ESPHOME_LOG_TAG(TAG, "display.mipi_rgb");
 const uint8_t SW_RESET_CMD = 0x01;
 const uint8_t SLEEP_OUT = 0x11;
 const uint8_t SDIR_CMD = 0xC7;

esphome/components/mipi_spi/mipi_spi.h

@@ -7,10 +7,11 @@
 #include "esphome/components/display/display_color_utils.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 namespace esphome::mipi_spi {
 
-constexpr static const char *const TAG = "display.mipi_spi";
+ESPHOME_LOG_TAG(TAG, "display.mipi_spi");
 
 // Maximum bytes to log for commands (truncated if larger)
 static constexpr size_t MIPI_SPI_MAX_CMD_LOG_BYTES = 64;

esphome/components/nrf52/__init__.py

@@ -1040,11 +1040,13 @@ def run_compile(args, config: ConfigType) -> bool:
     framework_ver = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
     bootloader = zephyr_data()[KEY_BOOTLOADER]
 
-    # (dev_type, sd_req) per bootloader — values from Nordic SoftDevice release notes
+    # (dev_type, sd_req) per bootloader — values from Nordic SoftDevice release notes.
+    # The bootloader resets on a package whose sd_req does not list its SoftDevice,
+    # so v7 accepts S140 7.0.1, 7.2.0 and 7.3.0 (e.g. Seeed XIAO nRF52840).
     _GENPKG_PARAMS = {
         BOOTLOADER_ADAFRUIT_NRF52_SD132: ("0x0051", "0x009D"),
         BOOTLOADER_ADAFRUIT_NRF52_SD140_V6: ("0x0052", "0x00B6"),
-        BOOTLOADER_ADAFRUIT_NRF52_SD140_V7: ("0x0052", "0x00CA"),
+        BOOTLOADER_ADAFRUIT_NRF52_SD140_V7: ("0x0052", "0x00CA,0x0100,0x0123"),
     }
     # UF2 family IDs — nRF52832 vs nRF52840 per SoftDevice variant
     _UF2_FAMILY_IDS = {

esphome/components/pca9505/__init__.py

@@ -0,0 +1,79 @@
+from esphome import pins
+import esphome.codegen as cg
+from esphome.components import i2c
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    CONF_INPUT,
+    CONF_INTERRUPT_PIN,
+    CONF_INVERTED,
+    CONF_MODE,
+    CONF_NUMBER,
+    CONF_OUTPUT,
+)
+from esphome.cpp_generator import MockObj
+from esphome.types import ConfigType
+
+AUTO_LOAD = ["gpio_expander"]
+CODEOWNERS = ["@ssieb", "@ajfriesen"]
+DEPENDENCIES = ["i2c"]
+DOMAIN = "pca9505"
+MULTI_CONF = True
+
+pca9505_ns = cg.esphome_ns.namespace("pca9505")
+
+PCA9505Component = pca9505_ns.class_("PCA9505Component", cg.Component, i2c.I2CDevice)
+PCA9505GPIOPin = pca9505_ns.class_(
+    "PCA9505GPIOPin", cg.GPIOPin, cg.Parented.template(PCA9505Component)
+)
+
+CONF_PCA9505 = "pca9505"
+CONFIG_SCHEMA = (
+    cv.Schema(
+        {
+            cv.Required(CONF_ID): cv.declare_id(PCA9505Component),
+            cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
+        }
+    )
+    .extend(cv.COMPONENT_SCHEMA)
+    .extend(i2c.i2c_device_schema(0x20))
+)
+
+
+async def to_code(config: ConfigType) -> None:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    await i2c.register_i2c_device(var, config)
+    if interrupt_pin := config.get(CONF_INTERRUPT_PIN):
+        cg.add(var.set_interrupt_pin(await cg.gpio_pin_expression(interrupt_pin)))
+
+
+def validate_mode(value: ConfigType) -> ConfigType:
+    if not (value[CONF_INPUT] or value[CONF_OUTPUT]):
+        raise cv.Invalid("Mode must be either input or output")
+    if value[CONF_INPUT] and value[CONF_OUTPUT]:
+        raise cv.Invalid("Mode must be either input or output")
+    return value
+
+
+PCA9505_PIN_SCHEMA = pins.gpio_base_schema(
+    PCA9505GPIOPin,
+    cv.int_range(min=0, max=39),
+    modes=[CONF_INPUT, CONF_OUTPUT],
+    mode_validator=validate_mode,
+).extend(
+    {
+        cv.Required(CONF_PCA9505): cv.use_id(PCA9505Component),
+    }
+)
+
+
+@pins.PIN_SCHEMA_REGISTRY.register(CONF_PCA9505, PCA9505_PIN_SCHEMA)
+async def pca9505_pin_to_code(config: ConfigType) -> MockObj:
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_parented(var, config[CONF_PCA9505])
+
+    cg.add(var.set_pin(config[CONF_NUMBER]))
+    cg.add(var.set_inverted(config[CONF_INVERTED]))
+    cg.add(var.set_flags(pins.gpio_flags_expr(config[CONF_MODE])))
+    return var

esphome/components/pca9505/pca9505.cpp

@@ -0,0 +1,165 @@
+#include "pca9505.h"
+#include "esphome/core/log.h"
+
+namespace esphome::pca9505 {
+
+// Each register block holds one byte per port. Add the port number to reach a single
+// port, or set the auto-increment bit to transfer the whole block in one go.
+static constexpr uint8_t INPUT_REG = 0x00;
+static constexpr uint8_t OUTPUT_REG = 0x08;
+static constexpr uint8_t INVERT_REG = 0x10;
+static constexpr uint8_t CONFIG_REG = 0x18;
+static constexpr uint8_t MASK_REG = 0x20;
+static constexpr uint8_t AUTO_INCREMENT = 0x80;
+
+ESPHOME_LOG_TAG(TAG, "pca9505");
+
+void PCA9505Component::setup() {
+  // Test to see if device exists
+  if (!this->read_bank_(0)) {
+    ESP_LOGE(TAG, "PCA9505 not detected at 0x%02X", this->address_);
+    this->mark_failed();
+    return;
+  }
+
+  // No polarity inversion
+  this->write_all_banks_(INVERT_REG, 0x00);
+  // All outputs low, before anything is switched to being an output
+  this->write_all_banks_(OUTPUT_REG, 0x00);
+  // All inputs at initialization. The part sees a 1 as an input, so this is the
+  // inverse of config_, which is all zeroes here.
+  this->write_all_banks_(CONFIG_REG, 0xFF);
+
+  // Mask every interrupt. This must be written, not assumed: the chip keeps its
+  // registers through an MCU reboot, so a previous run may have left pins unmasked.
+  for (uint8_t &bank : this->mask_) {
+    bank = 0xFF;
+  }
+  this->write_all_banks_(MASK_REG, 0xFF);
+
+  if (this->interrupt_pin_ != nullptr) {
+    this->interrupt_pin_->setup();
+    this->interrupt_pin_->attach_interrupt(&PCA9505Component::gpio_intr, this, gpio::INTERRUPT_FALLING_EDGE);
+    // Don't invalidate cache on read - only invalidate when interrupt fires
+    this->set_invalidate_on_read_(false);
+  }
+
+  // Nothing to poll until pin_mode() registers an input pin.
+  this->disable_loop();
+}
+
+void IRAM_ATTR PCA9505Component::gpio_intr(PCA9505Component *arg) { arg->enable_loop_soon_any_context(); }
+
+void PCA9505Component::loop() {
+  // Invalidate the cache so the next digital_read() triggers a fresh I2C read
+  this->reset_pin_cache_();
+  // Only disable the loop once INT has actually gone HIGH. Input transitions that straddle the
+  // I2C read leave INT asserted without re-firing a falling edge, which would strand us with
+  // stale state forever; keep looping until the line is released so we self-heal.
+  if (this->interrupt_pin_ != nullptr && this->interrupt_pin_->digital_read()) {
+    this->disable_loop();
+  }
+}
+
+void PCA9505Component::dump_config() {
+  ESP_LOGCONFIG(TAG, "PCA9505:");
+  LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
+  LOG_I2C_DEVICE(this)
+  if (this->is_failed()) {
+    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
+  }
+}
+
+bool PCA9505Component::digital_read_hw(uint8_t pin) { return this->read_bank_(pin / 8); }
+
+bool PCA9505Component::digital_read_cache(uint8_t pin) { return this->input_[pin / 8] & (1 << (pin % 8)); }
+
+void PCA9505Component::digital_write_hw(uint8_t pin, bool value) {
+  const uint8_t bank = pin / 8;
+  const uint8_t mask = 1 << (pin % 8);
+  if (value) {
+    this->output_[bank] |= mask;
+  } else {
+    this->output_[bank] &= ~mask;
+  }
+  this->write_bank_(OUTPUT_REG, bank, this->output_[bank]);
+}
+
+void PCA9505Component::pin_mode(uint8_t pin, gpio::Flags flags) {
+  const uint8_t bank = pin / 8;
+  const uint8_t mask = 1 << (pin % 8);
+  if (flags & gpio::FLAG_INPUT) {
+    this->config_[bank] &= ~mask;
+    // An input may raise INT; the polling loop is only needed when there is no interrupt pin.
+    this->mask_[bank] &= ~mask;
+    if (this->interrupt_pin_ == nullptr) {
+      this->enable_loop();
+    }
+  } else if (flags & gpio::FLAG_OUTPUT) {
+    this->config_[bank] |= mask;
+    // An output must never raise INT.
+    this->mask_[bank] |= mask;
+  }
+  // Invert as the part sees a 1 as an input
+  this->write_bank_(CONFIG_REG, bank, ~this->config_[bank]);
+  // Without an interrupt pin INT is unconnected, so the masks written at setup can stay
+  if (this->interrupt_pin_ != nullptr) {
+    this->write_bank_(MASK_REG, bank, this->mask_[bank]);
+  }
+}
+
+bool PCA9505Component::read_bank_(uint8_t bank) {
+  if (this->is_failed())
+    return false;
+
+  if (this->read_register(INPUT_REG + bank, &this->input_[bank], 1) != i2c::ERROR_OK) {
+    this->status_set_warning(LOG_STR("Failed to read input register"));
+    return false;
+  }
+  this->status_clear_warning();
+  return true;
+}
+
+bool PCA9505Component::write_bank_(uint8_t reg, uint8_t bank, uint8_t value) {
+  if (this->is_failed())
+    return false;
+
+  if (this->write_register(reg + bank, &value, 1) != i2c::ERROR_OK) {
+    this->status_set_warning(LOG_STR("Failed to write register"));
+    return false;
+  }
+  this->status_clear_warning();
+  return true;
+}
+
+bool PCA9505Component::write_all_banks_(uint8_t reg, uint8_t value) {
+  if (this->is_failed())
+    return false;
+
+  uint8_t values[BANK_COUNT];
+  for (uint8_t &bank : values) {
+    bank = value;
+  }
+  if (this->write_register(reg | AUTO_INCREMENT, values, sizeof(values)) != i2c::ERROR_OK) {
+    this->status_set_warning(LOG_STR("Failed to write register"));
+    return false;
+  }
+  this->status_clear_warning();
+  return true;
+}
+
+float PCA9505Component::get_setup_priority() const { return setup_priority::IO; }
+
+void PCA9505GPIOPin::setup() { this->pin_mode(this->flags_); }
+
+void PCA9505GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
+
+bool PCA9505GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
+
+void PCA9505GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
+
+size_t PCA9505GPIOPin::dump_summary(char *buffer, size_t len) const {
+  return buf_append_printf(buffer, len, 0, "%u via PCA9505", this->pin_);
+}
+
+}  // namespace esphome::pca9505

esphome/components/pca9505/pca9505.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/core/hal.h"
+#include "esphome/core/helpers.h"
+#include "esphome/components/gpio_expander/cached_gpio.h"
+#include "esphome/components/i2c/i2c.h"
+
+namespace esphome::pca9505 {
+
+/// Number of I/O pins on the PCA9505 and PCA9506.
+static constexpr uint8_t PIN_COUNT = 40;
+/// The pins are grouped into five ports of eight, each with its own set of registers.
+static constexpr uint8_t BANK_COUNT = PIN_COUNT / 8;
+
+class PCA9505Component final : public Component,
+                               public i2c::I2CDevice,
+                               public gpio_expander::CachedGpioExpander<uint8_t, PIN_COUNT> {
+ public:
+  void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
+
+  void setup() override;
+  void loop() override;
+  void pin_mode(uint8_t pin, gpio::Flags flags);
+
+  float get_setup_priority() const override;
+
+  void dump_config() override;
+
+ protected:
+  static void IRAM_ATTR gpio_intr(PCA9505Component *arg);
+
+  bool digital_read_hw(uint8_t pin) override;
+  bool digital_read_cache(uint8_t pin) override;
+  void digital_write_hw(uint8_t pin, bool value) override;
+
+  bool read_bank_(uint8_t bank);
+  bool write_bank_(uint8_t reg, uint8_t bank, uint8_t value);
+  bool write_all_banks_(uint8_t reg, uint8_t value);
+
+  /// The pin config per bank - 1 means OUTPUT, 0 means INPUT
+  uint8_t config_[BANK_COUNT]{};
+  /// The output state per bank - 1 means HIGH, 0 means LOW
+  uint8_t output_[BANK_COUNT]{};
+  /// The input pin states per bank - 1 means HIGH, 0 means LOW
+  uint8_t input_[BANK_COUNT]{};
+  /// Which pins may pull INT low - 1 means masked, matching the chip
+  uint8_t mask_[BANK_COUNT]{};
+  InternalGPIOPin *interrupt_pin_{nullptr};
+};
+
+class PCA9505GPIOPin final : public GPIOPin, public Parented<PCA9505Component> {
+ public:
+  void setup() override;
+  void pin_mode(gpio::Flags flags) override;
+  bool digital_read() override;
+  void digital_write(bool value) override;
+  size_t dump_summary(char *buffer, size_t len) const override;
+
+  void set_pin(uint8_t pin) { this->pin_ = pin; }
+  void set_inverted(bool inverted) { this->inverted_ = inverted; }
+  void set_flags(gpio::Flags flags) { this->flags_ = flags; }
+
+  gpio::Flags get_flags() const override { return this->flags_; }
+
+ protected:
+  uint8_t pin_{0};
+  bool inverted_{false};
+  gpio::Flags flags_{};
+};
+
+}  // namespace esphome::pca9505

esphome/components/qr_code/__init__.py

@@ -35,7 +35,7 @@ CONFIG_SCHEMA = cv.ensure_list(
 
 
 async def to_code(config: list[ConfigType]) -> None:
-    cg.add_library("wjtje/qr-code-generator-library", "^1.7.0")
+    cg.add_library("wjtje/qr-code-generator-library", "1.7.0")
 
     for entry in config:
         var = cg.new_Pvariable(entry[CONF_ID])

esphome/components/qspi_dbi/qspi_dbi.h

@@ -8,12 +8,13 @@
 #include "esphome/components/display/display.h"
 #include "esphome/components/display/display_buffer.h"
 #include "esphome/components/display/display_color_utils.h"
+#include "esphome/core/log.h"
 
 #include "esp_lcd_panel_rgb.h"
 
 namespace esphome::qspi_dbi {
 
-constexpr static const char *const TAG = "display.qspi_dbi";
+ESPHOME_LOG_TAG(TAG, "display.qspi_dbi");
 static const uint8_t SW_RESET_CMD = 0x01;
 static const uint8_t SLEEP_OUT = 0x11;
 static const uint8_t NORON = 0x13;

esphome/components/radon_eye_rd200/radon_eye_rd200.cpp

@@ -1,123 +1,150 @@
 #include "radon_eye_rd200.h"
-#include "esphome/components/esp32_ble/ble_uuid.h"
+
+#ifdef USE_BLE_CLIENT_GATT_NODES
+
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
 
 #include <cstring>
 
-#ifdef USE_ESP32
-
 namespace esphome::radon_eye_rd200 {
 
 ESPHOME_LOG_TAG(TAG, "radon_eye_rd200");
 
-static const esp32_ble_tracker::ESPBTUUID SERVICE_UUID_V1 =
-    esp32_ble_tracker::ESPBTUUID::from_raw("00001523-1212-efde-1523-785feabcd123");
-static const esp32_ble_tracker::ESPBTUUID WRITE_CHARACTERISTIC_UUID_V1 =
-    esp32_ble_tracker::ESPBTUUID::from_raw("00001524-1212-efde-1523-785feabcd123");
-static const esp32_ble_tracker::ESPBTUUID READ_CHARACTERISTIC_UUID_V1 =
-    esp32_ble_tracker::ESPBTUUID::from_raw("00001525-1212-efde-1523-785feabcd123");
+using ble_device_base::ESPBTUUID;
+
+// V1 (RD200 firmware < 2.0) exposes a vendor service; V2 (>= 2.0) moved to
+// Bluetooth-base (16-bit) UUIDs with a different command byte and payload
+// layout.
+static const char *const SERVICE_UUID_V1 = "00001523-1212-efde-1523-785feabcd123";
+static const char *const WRITE_CHARACTERISTIC_UUID_V1 = "00001524-1212-efde-1523-785feabcd123";
+static const char *const READ_CHARACTERISTIC_UUID_V1 = "00001525-1212-efde-1523-785feabcd123";
 static const uint8_t WRITE_COMMAND_V1 = 0x50;
 
-static const esp32_ble_tracker::ESPBTUUID SERVICE_UUID_V2 =
-    esp32_ble_tracker::ESPBTUUID::from_raw("00001523-0000-1000-8000-00805f9b34fb");
-static const esp32_ble_tracker::ESPBTUUID WRITE_CHARACTERISTIC_UUID_V2 =
-    esp32_ble_tracker::ESPBTUUID::from_raw("00001524-0000-1000-8000-00805f9b34fb");
-static const esp32_ble_tracker::ESPBTUUID READ_CHARACTERISTIC_UUID_V2 =
-    esp32_ble_tracker::ESPBTUUID::from_raw("00001525-0000-1000-8000-00805f9b34fb");
+static const uint16_t SERVICE_UUID_V2 = 0x1523;
+static const uint16_t WRITE_CHARACTERISTIC_UUID_V2 = 0x1524;
+static const uint16_t READ_CHARACTERISTIC_UUID_V2 = 0x1525;
 static const uint8_t WRITE_COMMAND_V2 = 0x40;
 
-void RadonEyeRD200::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
-                                        esp_ble_gattc_cb_param_t *param) {
-  switch (event) {
-    case ESP_GATTC_OPEN_EVT: {
-      if (param->open.status == ESP_GATT_OK) {
-        ESP_LOGI(TAG, "Connected successfully!");
-      }
-      break;
-    }
+// Minimum notification payload carrying all three measurements.
+static const uint16_t MESSAGE_MIN_LEN_V1 = 20;
+static const uint16_t MESSAGE_MIN_LEN_V2 = 68;
 
-    case ESP_GATTC_DISCONNECT_EVT: {
-      ESP_LOGW(TAG, "Disconnected!");
-      break;
-    }
+RadonEyeRD200::RadonEyeRD200() : PollingComponent(10000) {}
 
-    case ESP_GATTC_SEARCH_CMPL_EVT: {
-      if (this->parent()->get_service(SERVICE_UUID_V1) != nullptr) {
-        service_uuid_ = SERVICE_UUID_V1;
-        sensors_write_characteristic_uuid_ = WRITE_CHARACTERISTIC_UUID_V1;
-        sensors_read_characteristic_uuid_ = READ_CHARACTERISTIC_UUID_V1;
-        write_command_ = WRITE_COMMAND_V1;
-      } else if (this->parent()->get_service(SERVICE_UUID_V2) != nullptr) {
-        service_uuid_ = SERVICE_UUID_V2;
-        sensors_write_characteristic_uuid_ = WRITE_CHARACTERISTIC_UUID_V2;
-        sensors_read_characteristic_uuid_ = READ_CHARACTERISTIC_UUID_V2;
-        write_command_ = WRITE_COMMAND_V2;
-      } else {
-        ESP_LOGW(TAG, "No supported device has been found, disconnecting");
-        parent()->set_enabled(false);
-        break;
-      }
-
-      this->read_handle_ = 0;
-      auto *chr = this->parent()->get_characteristic(service_uuid_, sensors_read_characteristic_uuid_);
-      if (chr == nullptr) {
-        char service_buf[esp32_ble::UUID_STR_LEN];
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGW(TAG, "No sensor read characteristic found at service %s char %s", service_uuid_.to_str(service_buf),
-                 sensors_read_characteristic_uuid_.to_str(char_buf));
-        break;
-      }
-      this->read_handle_ = chr->handle;
-
-      auto *write_chr = this->parent()->get_characteristic(service_uuid_, sensors_write_characteristic_uuid_);
-      if (write_chr == nullptr) {
-        char service_buf[esp32_ble::UUID_STR_LEN];
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        ESP_LOGW(TAG, "No sensor write characteristic found at service %s char %s", service_uuid_.to_str(service_buf),
-                 sensors_write_characteristic_uuid_.to_str(char_buf));
-        break;
-      }
-      this->write_handle_ = write_chr->handle;
-
-      esp_err_t status =
-          esp_ble_gattc_register_for_notify(gattc_if, this->parent()->get_remote_bda(), this->read_handle_);
-      if (status) {
-        ESP_LOGW(TAG, "Error registering for sensor notify, status=%d", status);
-      }
-      break;
-    }
-
-    case ESP_GATTC_WRITE_DESCR_EVT: {
-      if (param->write.status != ESP_GATT_OK) {
-        ESP_LOGE(TAG, "write descr failed, error status = %x", param->write.status);
-        break;
-      }
-      ESP_LOGV(TAG, "Write descr success, writing 0x%02X at write_handle=%d", this->write_command_,
-               this->write_handle_);
-      esp_err_t status =
-          esp_ble_gattc_write_char(gattc_if, this->parent()->get_conn_id(), this->write_handle_, sizeof(write_command_),
-                                   (uint8_t *) &write_command_, ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
-      if (status) {
-        ESP_LOGW(TAG, "Error writing 0x%02x command, status=%d", write_command_, status);
-      }
-      break;
-    }
-
-    case ESP_GATTC_NOTIFY_EVT: {
-      if (param->notify.is_notify) {
-        ESP_LOGV(TAG, "ESP_GATTC_NOTIFY_EVT, receive notify value, %d bytes", param->notify.value_len);
-      } else {
-        ESP_LOGV(TAG, "ESP_GATTC_NOTIFY_EVT, receive indicate value, %d bytes", param->notify.value_len);
-      }
-      read_sensors_(param->notify.value, param->notify.value_len);
-      break;
-    }
-
-    default:
-      break;
+void RadonEyeRD200::update() {
+  if (this->parent()->connected())
+    return;
+  if (!this->parent()->enabled) {
+    ESP_LOGW(TAG, "Reconnecting to device");
+    this->parent()->set_enabled(true);
+  } else {
+    ESP_LOGW(TAG, "Connection in progress");
   }
 }
 
-void RadonEyeRD200::read_sensors_(uint8_t *value, uint16_t value_len) {
+void RadonEyeRD200::on_connected(const ble_device_base::GattServiceTable &table) {
+  if (!this->resolve_handles_(table)) {
+    // Retried on the next poll (update() re-enables the client).
+    this->parent()->set_enabled(false);
+    return;
+  }
+  // Local notification registration; the CCCD write follows in
+  // on_notify_state (the contract leaves the CCCD to the node).
+  if (this->parent()->notify_characteristic(this->read_handle_, true) != 0) {
+    this->parent()->set_enabled(false);
+  }
+}
+
+bool RadonEyeRD200::resolve_handles_(const ble_device_base::GattServiceTable &table) {
+  struct Variant {
+    ESPBTUUID service;
+    ESPBTUUID write_chr;
+    ESPBTUUID read_chr;
+    uint8_t command;
+  };
+  // Built on the stack per (cold) discovery so the UUID objects stay out of
+  // static RAM; the V1 strings live in flash.
+  const Variant variants[] = {
+      {ESPBTUUID::from_raw(SERVICE_UUID_V1), ESPBTUUID::from_raw(WRITE_CHARACTERISTIC_UUID_V1),
+       ESPBTUUID::from_raw(READ_CHARACTERISTIC_UUID_V1), WRITE_COMMAND_V1},
+      {ESPBTUUID::from_uint16(SERVICE_UUID_V2), ESPBTUUID::from_uint16(WRITE_CHARACTERISTIC_UUID_V2),
+       ESPBTUUID::from_uint16(READ_CHARACTERISTIC_UUID_V2), WRITE_COMMAND_V2},
+  };
+  for (const auto &variant : variants) {
+    const auto *service = ble_device_base::find_service(table, variant.service);
+    if (service == nullptr) {
+      continue;
+    }
+    const auto *read_chr = ble_device_base::find_characteristic(table, *service, variant.read_chr);
+    const auto *write_chr = ble_device_base::find_characteristic(table, *service, variant.write_chr);
+    if (read_chr == nullptr || write_chr == nullptr) {
+      ESP_LOGW(TAG, "Service found but a sensor characteristic is missing");
+      return false;
+    }
+    this->cccd_handle_ = ble_device_base::find_cccd(table, *read_chr);
+    if (this->cccd_handle_ == 0) {
+      ESP_LOGW(TAG, "Sensor read characteristic has no CCCD");
+      return false;
+    }
+    this->read_handle_ = read_chr->value_handle;
+    this->write_handle_ = write_chr->value_handle;
+    this->write_command_ = variant.command;
+    return true;
+  }
+  ESP_LOGW(TAG, "No supported device has been found, disconnecting");
+  return false;
+}
+
+void RadonEyeRD200::on_notify_state(uint16_t handle, bool enabled, int error) {
+  if (handle != this->read_handle_) {
+    return;
+  }
+  if (error != 0) {
+    ESP_LOGW(TAG, "Error registering for sensor notify, status=%d", error);
+    this->parent()->set_enabled(false);
+    return;
+  }
+  if (!enabled) {
+    return;
+  }
+  static const uint8_t ENABLE_NOTIFY[2] = {0x01, 0x00};
+  if (this->parent()->write_descriptor(this->cccd_handle_, ENABLE_NOTIFY, sizeof(ENABLE_NOTIFY)) != 0) {
+    this->parent()->set_enabled(false);
+  }
+}
+
+void RadonEyeRD200::on_write_result(uint16_t handle, int error) {
+  // The command write (no response) also lands here; only the CCCD
+  // completion advances the sequence.
+  if (handle != this->cccd_handle_) {
+    return;
+  }
+  if (error != 0) {
+    ESP_LOGE(TAG, "CCCD write on handle 0x%04x failed, status=%d", handle, error);
+    this->parent()->set_enabled(false);
+    return;
+  }
+  ESP_LOGV(TAG, "Write descr success, writing 0x%02X at write_handle=%d", this->write_command_, this->write_handle_);
+  if (this->parent()->write_characteristic(this->write_handle_, &this->write_command_, sizeof(this->write_command_),
+                                           false) != 0) {
+    ESP_LOGW(TAG, "Error writing 0x%02x command", this->write_command_);
+    this->parent()->set_enabled(false);
+  }
+}
+
+void RadonEyeRD200::on_notify(uint16_t handle, const uint8_t *data, uint16_t len) {
+  if (handle != this->read_handle_) {
+    return;
+  }
+  ESP_LOGV(TAG, "Received notify value, %d bytes", len);
+  this->read_sensors_(data, len);
+  // This instance must not stay connected so other clients can connect to it
+  // (e.g. the mobile app).
+  this->parent()->set_enabled(false);
+}
+
+void RadonEyeRD200::read_sensors_(const uint8_t *value, uint16_t value_len) {
   if (value_len < 1) {
     ESP_LOGW(TAG, "Unexpected empty message");
     return;
@@ -125,7 +152,8 @@ void RadonEyeRD200::read_sensors_(uint8_t *value, uint16_t value_len) {
 
   uint8_t command = value[0];
 
-  if ((command == WRITE_COMMAND_V1 && value_len < 20) || (command == WRITE_COMMAND_V2 && value_len < 68)) {
+  if ((command == WRITE_COMMAND_V1 && value_len < MESSAGE_MIN_LEN_V1) ||
+      (command == WRITE_COMMAND_V2 && value_len < MESSAGE_MIN_LEN_V2)) {
     ESP_LOGW(TAG, "Unexpected command 0x%02X message length %d", command, value_len);
     return;
   }
@@ -134,8 +162,11 @@ void RadonEyeRD200::read_sensors_(uint8_t *value, uint16_t value_len) {
   // 501085EBB9400000000000000000220025000000
   // Example data V2:
   // 4042323230313033525532303338330652443230304e56322e302e3200014a00060a00080000000300010079300000e01108001c00020000003822005c8f423fa4709d3f
-  ESP_LOGV(TAG, "radon sensors raw bytes");
-  ESP_LOG_BUFFER_HEX_LEVEL(TAG, value, value_len, ESP_LOG_VERBOSE);
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
+  // Sized for the V2 minimum payload; format_hex_to truncates longer messages.
+  char hex_buf[format_hex_size(MESSAGE_MIN_LEN_V2)];
+  ESP_LOGV(TAG, "radon sensors raw bytes: %s", format_hex_to(hex_buf, value, value_len));
+#endif
 
   // Convert from pCi/L to Bq/m³
   constexpr float convert_to_bwpm3 = 37.0;
@@ -185,22 +216,6 @@ void RadonEyeRD200::read_sensors_(uint8_t *value, uint16_t value_len) {
            "  Measurements (pCi/L) now: %0.03f, day: %0.03f, month: %0.03f",
            radon_now, radon_day, radon_month, radon_now / convert_to_bwpm3, radon_day / convert_to_bwpm3,
            radon_month / convert_to_bwpm3);
-
-  // This instance must not stay connected
-  // so other clients can connect to it (e.g. the
-  // mobile app).
-  parent()->set_enabled(false);
-}
-
-void RadonEyeRD200::update() {
-  if (this->node_state != esp32_ble_tracker::ClientState::ESTABLISHED) {
-    if (!parent()->enabled) {
-      ESP_LOGW(TAG, "Reconnecting to device");
-      parent()->set_enabled(true);
-    } else {
-      ESP_LOGW(TAG, "Connection in progress");
-    }
-  }
 }
 
 void RadonEyeRD200::dump_config() {
@@ -208,8 +223,6 @@ void RadonEyeRD200::dump_config() {
   LOG_SENSOR("  ", "Radon Long Term", this->radon_long_term_sensor_);
 }
 
-RadonEyeRD200::RadonEyeRD200() : PollingComponent(10000) {}
-
 }  // namespace esphome::radon_eye_rd200
 
-#endif  // USE_ESP32
+#endif  // USE_BLE_CLIENT_GATT_NODES

esphome/components/radon_eye_rd200/radon_eye_rd200.h

@@ -1,15 +1,29 @@
+// RD200 radon sensor on the platform-neutral ble_client node interface -
+// one implementation for every platform with a GATT client engine (esp32
+// and rp2 / Pico W today).
+//
+// Poll cycle: enable the client (it connects on the peer's next sighting) →
+// resolve the V1/V2 variant and handles from the service table during
+// on_connected() → local notify registration → explicit CCCD write (the
+// contract makes the CCCD the node's job) → write the read command → parse
+// the notification → disable. The link is dropped after every reading so the
+// vendor mobile app can connect between polls.
+
 #pragma once
 
-#ifdef USE_ESP32
+#include "esphome/core/defines.h"
 
-#include <esp_gattc_api.h>
-#include <algorithm>
-#include <iterator>
-#include "esphome/components/ble_client/ble_client.h"
-#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+#ifdef USE_BLE_CLIENT_GATT_NODES
+
+#include "esphome/components/ble_client/ble_client_node.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/core/component.h"
-#include "esphome/core/log.h"
+
+#ifdef USE_ESP32
+#include "esphome/components/ble_client/ble_client.h"
+#else
+#include "esphome/components/ble_client/ble_client_gatt.h"
+#endif
 
 namespace esphome::radon_eye_rd200 {
 
@@ -20,26 +34,28 @@ class RadonEyeRD200 final : public PollingComponent, public ble_client::BLEClien
   void dump_config() override;
   void update() override;
 
-  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
-                           esp_ble_gattc_cb_param_t *param) override;
+  void set_radon(sensor::Sensor *radon) { this->radon_sensor_ = radon; }
+  void set_radon_long_term(sensor::Sensor *radon_long_term) { this->radon_long_term_sensor_ = radon_long_term; }
 
-  void set_radon(sensor::Sensor *radon) { radon_sensor_ = radon; }
-  void set_radon_long_term(sensor::Sensor *radon_long_term) { radon_long_term_sensor_ = radon_long_term; }
+  // ---- ble_client::BLEClientNode (unused events keep the no-op defaults) ----
+  void on_connected(const ble_device_base::GattServiceTable &table) override;
+  void on_notify(uint16_t handle, const uint8_t *data, uint16_t len) override;
+  void on_notify_state(uint16_t handle, bool enabled, int error) override;
+  void on_write_result(uint16_t handle, int error) override;
 
  protected:
-  void read_sensors_(uint8_t *value, uint16_t value_len);
+  bool resolve_handles_(const ble_device_base::GattServiceTable &table);
+  void read_sensors_(const uint8_t *value, uint16_t value_len);
 
   sensor::Sensor *radon_sensor_{nullptr};
   sensor::Sensor *radon_long_term_sensor_{nullptr};
 
-  uint8_t write_command_;
-  uint16_t read_handle_;
-  uint16_t write_handle_;
-  esp32_ble_tracker::ESPBTUUID service_uuid_;
-  esp32_ble_tracker::ESPBTUUID sensors_write_characteristic_uuid_;
-  esp32_ble_tracker::ESPBTUUID sensors_read_characteristic_uuid_;
+  uint16_t read_handle_{0};
+  uint16_t write_handle_{0};
+  uint16_t cccd_handle_{0};
+  uint8_t write_command_{0};
 };
 
 }  // namespace esphome::radon_eye_rd200
 
-#endif  // USE_ESP32
+#endif  // USE_BLE_CLIENT_GATT_NODES

esphome/components/radon_eye_rd200/sensor.py

@@ -37,7 +37,7 @@ CONFIG_SCHEMA = cv.All(
         }
     )
     .extend(cv.polling_component_schema("5min"))
-    .extend(ble_client.BLE_CLIENT_SCHEMA),
+    .extend(ble_client.NODE_BLE_CLIENT_SCHEMA),
 )
 
 
@@ -45,7 +45,7 @@ async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
-    await ble_client.register_ble_node(var, config)
+    await ble_client.register_gatt_node(var, config)
 
     sensors = sensor.sub_sensors(config)
     await sensors(CONF_RADON, var.set_radon)

esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.h

@@ -16,7 +16,7 @@
 
 namespace esphome::rpi_dpi_rgb {
 
-constexpr static const char *const TAG = "rpi_dpi_rgb";
+ESPHOME_LOG_TAG(TAG, "rpi_dpi_rgb");
 
 class RpiDpiRgb final : public display::Display {
  public:

esphome/components/rtttl/__init__.py

@@ -14,6 +14,8 @@ _LOGGER = logging.getLogger(__name__)
 CODEOWNERS = ["@glmnet", "@ximex"]
 DOMAIN = "rtttl"
 CONF_RTTTL = "rtttl"
+# The player keeps the song length in 16 bits
+MAX_SONG_LENGTH = 65535
 CONF_ON_FINISHED_PLAYBACK = "on_finished_playback"
 
 rtttl_ns = cg.esphome_ns.namespace("rtttl")
@@ -97,16 +99,23 @@ async def to_code(config: ConfigType) -> None:
         await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
 
+def _static_song(config: ConfigType, value: str) -> str:
+    # A constant song plays straight from static storage, flash on ESP8266, with no copy per play
+    return f"esphome::rtttl::StaticSong{{{cg.FlashStringLiteral(value)}}}"
+
+
 automation.register_apply_action(
     "rtttl.play",
     cv.maybe_simple_value(
         {
             cv.GenerateID(CONF_ID): cv.use_id(Rtttl),
-            cv.Required(CONF_RTTTL): cv.templatable(cv.string),
+            cv.Required(CONF_RTTTL): cv.templatable(
+                cv.All(cv.string, cv.ByteLength(max=MAX_SONG_LENGTH))
+            ),
         },
         key=CONF_RTTTL,
     ),
-    automation.ApplyField(CONF_RTTTL, "play", cg.std_string),
+    automation.ApplyField(CONF_RTTTL, "play", cg.std_string, const_fn=_static_song),
 )
 
 automation.register_apply_action(

esphome/components/rtttl/rtttl.cpp

@@ -1,5 +1,8 @@
 #include "rtttl.h"
+#include <algorithm>
 #include <cmath>
+#include <cstring>
+#include <limits>
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 #include "esphome/core/progmem.h"
@@ -147,14 +150,14 @@ void Rtttl::loop() {
 #endif  // USE_SPEAKER
 
   // Align to note: most rtttl's out there does not add any space after the ',' separator but just in case
-  while (this->position_ < this->rtttl_.length()) {
-    char c = this->rtttl_[this->position_];
+  while (this->position_ < this->song_len_) {
+    char c = this->song_at_(this->position_);
     if (c != ',' && c != ' ')
       break;
     this->position_++;
   }
 
-  if (this->position_ >= this->rtttl_.length()) {
+  if (this->position_ >= this->song_len_) {
     this->finish_();
     return;
   }
@@ -169,12 +172,12 @@ void Rtttl::loop() {
     this->note_duration_ = this->wholenote_duration_ / this->default_note_denominator_;
   }
 
-  uint8_t note_index_in_octave = note_index_from_char(this->rtttl_[this->position_]);
+  uint8_t note_index_in_octave = note_index_from_char(this->song_at_(this->position_));
 
   this->position_++;
 
   // Now, get optional '#' sharp
-  if (this->rtttl_[this->position_] == '#') {
+  if (this->song_at_(this->position_) == '#') {
     note_index_in_octave++;
     this->position_++;
   }
@@ -192,7 +195,7 @@ void Rtttl::loop() {
   }
 
   // Now, get optional '.' dotted note
-  if (this->rtttl_[this->position_] == '.') {
+  if (this->song_at_(this->position_) == '.') {
     this->note_duration_ += this->note_duration_ / 2;  // Duration +50%
     this->position_++;
   }
@@ -264,15 +267,68 @@ void Rtttl::loop() {
 }
 
 void Rtttl::play(std::string rtttl) {
-  if (this->state_ != State::STOPPED && this->state_ != State::STOPPING) {
-    size_t pos = this->rtttl_.find(':');
-    size_t len = (pos != std::string::npos) ? pos : this->rtttl_.length();
-    ESP_LOGW(TAG, "Already playing: %.*s", (int) len, this->rtttl_.c_str());
+  if (this->is_busy_()) {
     return;
   }
+  this->owned_song_ = std::move(rtttl);
+  this->set_song_(this->owned_song_.data(), this->owned_song_.size());
+  this->start_();
+}
 
-  this->rtttl_ = std::move(rtttl);
+void Rtttl::play(StaticSong song) {
+  if (this->is_busy_()) {
+    return;
+  }
+  // Release a previously owned song; the static one needs no storage.
+  std::string().swap(this->owned_song_);
+  const char *data = reinterpret_cast<const char *>(song.rtttl);
+  this->set_song_(data, ESPHOME_strlen_P(data));
+  this->start_();
+}
 
+void Rtttl::set_song_(const char *song, size_t len) {
+  this->song_ = song;
+  // Anything past what the 16 bit length holds is dropped; the validator keeps configured songs shorter.
+  this->song_len_ = static_cast<uint16_t>(std::min<size_t>(len, std::numeric_limits<uint16_t>::max()));
+}
+
+bool Rtttl::is_busy_() const {
+  if (this->state_ == State::STOPPED || this->state_ == State::STOPPING) {
+    return false;
+  }
+  char name[SONG_NAME_LENGTH_LIMIT + 1];
+  this->song_name_(name, sizeof(name), this->song_find_(':', 0, this->song_len_));
+  ESP_LOGW(TAG, "Already playing: %s", name);
+  return true;
+}
+
+size_t Rtttl::song_find_(char c, size_t from, size_t end) const {
+  for (size_t pos = from; pos < end; pos++) {
+    if (this->song_at_(pos) == c)
+      return pos;
+  }
+  return end;
+}
+
+size_t Rtttl::song_find_control_(char key, size_t from, size_t end) const {
+  size_t pos = from;
+  while ((pos = this->song_find_(key, pos, end)) < end) {
+    if (this->song_at_(pos + 1) == '=')
+      return pos;
+    pos++;
+  }
+  return end;
+}
+
+void Rtttl::song_name_(char *buf, size_t size, size_t name_len) const {
+  size_t len = std::min(name_len, size - 1);
+  for (size_t pos = 0; pos < len; pos++) {
+    buf[pos] = this->song_at_(pos);
+  }
+  buf[len] = '\0';
+}
+
+void Rtttl::start_() {
   this->default_note_denominator_ = DEFAULT_NOTE_DENOMINATOR;
   this->default_octave_ = DEFAULT_OCTAVE;
   this->note_duration_ = 0;
@@ -281,9 +337,9 @@ void Rtttl::play(std::string rtttl) {
   uint16_t num;  // Used for: default note-denominator, default octave, BPM
 
   // Get name
-  this->position_ = this->rtttl_.find(':');
+  this->position_ = this->song_find_(':', 0, this->song_len_);
 
-  if (this->position_ == std::string::npos) {
+  if (this->position_ == this->song_len_) {
     ESP_LOGE(TAG, "Unable to determine name; missing ':'");
     return;
   }
@@ -292,18 +348,20 @@ void Rtttl::play(std::string rtttl) {
              static_cast<unsigned>(SONG_NAME_LENGTH_LIMIT));
     return;
   }
-  ESP_LOGD(TAG, "Playing song %.*s", (int) this->position_, this->rtttl_.c_str());
+  char name[SONG_NAME_LENGTH_LIMIT + 1];
+  this->song_name_(name, sizeof(name), this->position_);
+  ESP_LOGD(TAG, "Playing song %s", name);
 
   size_t name_end_position = this->position_;
-  size_t control_end = this->rtttl_.find(':', name_end_position + 1);
-  if (control_end == std::string::npos) {
+  size_t control_end = this->song_find_(':', name_end_position + 1, this->song_len_);
+  if (control_end == this->song_len_) {
     ESP_LOGE(TAG, "Missing second ':'");
     return;
   }
 
   // Get default duration
-  size_t pos = this->rtttl_.find("d=", name_end_position);
-  if (pos == std::string::npos || pos >= control_end) {
+  size_t pos = this->song_find_control_('d', name_end_position, control_end);
+  if (pos == control_end) {
     ESP_LOGW(TAG, "Missing 'd='; use default duration %d", this->default_note_denominator_);
   } else {
     this->position_ = pos + 2;
@@ -317,8 +375,8 @@ void Rtttl::play(std::string rtttl) {
   }
 
   // Get default octave
-  pos = this->rtttl_.find("o=", name_end_position);
-  if (pos == std::string::npos || pos >= control_end) {
+  pos = this->song_find_control_('o', name_end_position, control_end);
+  if (pos == control_end) {
     ESP_LOGW(TAG, "Missing 'o='; use default octave %d", this->default_octave_);
   } else {
     this->position_ = pos + 2;
@@ -332,8 +390,8 @@ void Rtttl::play(std::string rtttl) {
   }
 
   // Get BPM
-  pos = this->rtttl_.find("b=", name_end_position);
-  if (pos == std::string::npos || pos >= control_end) {
+  pos = this->song_find_control_('b', name_end_position, control_end);
+  if (pos == control_end) {
     ESP_LOGW(TAG, "Missing 'b='; use default BPM %d", bpm);
   } else {
     this->position_ = pos + 2;
@@ -387,7 +445,7 @@ void Rtttl::stop() {
   }
 #endif  // USE_SPEAKER
 
-  this->position_ = this->rtttl_.length();
+  this->position_ = this->song_len_;
   this->note_duration_ = 0;
 }
 
@@ -411,7 +469,7 @@ void Rtttl::finish_() {
 #endif  // USE_SPEAKER
 
   // Ensure no more notes are played in case finish_() is called for an error.
-  this->position_ = this->rtttl_.length();
+  this->position_ = this->song_len_;
   this->note_duration_ = 0;
 }
 

esphome/components/rtttl/rtttl.h

@@ -3,6 +3,7 @@
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/progmem.h"
 
 #ifdef USE_OUTPUT
 #include "esphome/components/output/float_output.h"
@@ -14,6 +15,10 @@
 
 namespace esphome::rtttl {
 
+namespace testing {
+class RtttlParserAccess;
+}  // namespace testing
+
 inline constexpr uint8_t DEFAULT_NOTE_DENOMINATOR = 4;  // Default note-denominator (quarter note)
 inline constexpr uint8_t DEFAULT_OCTAVE =
     6;  // Default octave for a note (see: `MIN_OCTAVE`, `MAX_OCTAVE` in `rtttl.cpp`)
@@ -26,6 +31,11 @@ enum class State : uint8_t {
   STOPPING,
 };
 
+/// A song in storage that outlives playback, such as a literal from generated code; PROGMEM on ESP8266.
+struct StaticSong {
+  ProgmemStr rtttl;
+};
+
 class Rtttl final : public Component {
  public:
 #ifdef USE_OUTPUT
@@ -38,7 +48,10 @@ class Rtttl final : public Component {
 
   void dump_config() override;
   void loop() override;
+  /// Play a song; the string is copied so it may come from anywhere.
   void play(std::string rtttl);
+  /// Play a song from static storage without copying it.
+  void play(StaticSong song);
   void stop();
 
   float get_gain() { return this->gain_; }
@@ -55,11 +68,29 @@ class Rtttl final : public Component {
  protected:
   inline uint16_t get_integer_() {
     uint16_t ret = 0;
-    while (isdigit(this->rtttl_[this->position_])) {
-      ret = (ret * 10) + (this->rtttl_[this->position_++] - '0');
+    while (isdigit(this->song_at_(this->position_))) {
+      ret = (ret * 10) + (this->song_at_(this->position_++) - '0');
     }
     return ret;
   }
+  /// The byte of the song at pos, or NUL past its end; the read is flash safe for a PROGMEM song on ESP8266.
+  char song_at_(size_t pos) const {
+    if (pos >= this->song_len_)
+      return '\0';
+    return static_cast<char>(progmem_read_byte(reinterpret_cast<const uint8_t *>(this->song_) + pos));
+  }
+  /// Index of the first `c` in [from, end), or `end` when absent.
+  size_t song_find_(char c, size_t from, size_t end) const;
+  /// Index of `key` followed by '=' in [from, end), or `end` when absent.
+  size_t song_find_control_(char key, size_t from, size_t end) const;
+  /// Copies the first name_len bytes of the song, its name, into buf for logging.
+  void song_name_(char *buf, size_t size, size_t name_len) const;
+  /// Points the view at a song, clamped to what song_len_ can hold.
+  void set_song_(const char *song, size_t len);
+  /// Parses the header and starts playback of the song the view points at.
+  void start_();
+  /// Logs and returns true when a song is still playing, so a new one must wait.
+  bool is_busy_() const;
   /**
    * @brief Finalizes the playback of the RTTTL string.
    *
@@ -70,26 +101,30 @@ class Rtttl final : public Component {
   void finish_();
   void set_state_(State state);
 
-  /// The RTTTL string to play.
-  std::string rtttl_;
-  /// The current position in the RTTTL string.
-  size_t position_{0};
-  /// The default duration of a note (e.g. 4 for a quarter note).
-  uint8_t default_note_denominator_{DEFAULT_NOTE_DENOMINATOR};
-  /// The default octave for a note.
-  uint8_t default_octave_{DEFAULT_OCTAVE};
-  /// The duration of the current note in milliseconds.
-  uint16_t note_duration_{0};
-  /// The duration of a whole note in milliseconds.
-  uint16_t wholenote_duration_;
-  /// The current state of the RTTTL player.
-  State state_{State::STOPPED};
+  /// The song being played; points at owned_song_ or at static storage.
+  const char *song_{nullptr};
+  /// Backing store for play(std::string).
+  std::string owned_song_;
   /// The time in milliseconds since microcontroller boot when the last note was started.
   uint32_t last_note_start_time_;
   /// The frequency of the current note in Hz.
   uint32_t output_freq_{0};
   /// The gain of the output.
   float gain_{0.6f};
+  /// Length of the song in bytes; songs are a few hundred bytes, so 16 bits is ample.
+  uint16_t song_len_{0};
+  /// The current position in the song.
+  uint16_t position_{0};
+  /// The duration of the current note in milliseconds.
+  uint16_t note_duration_{0};
+  /// The duration of a whole note in milliseconds.
+  uint16_t wholenote_duration_;
+  /// The default duration of a note (e.g. 4 for a quarter note).
+  uint8_t default_note_denominator_{DEFAULT_NOTE_DENOMINATOR};
+  /// The default octave for a note.
+  uint8_t default_octave_{DEFAULT_OCTAVE};
+  /// The current state of the RTTTL player.
+  State state_{State::STOPPED};
 
 #ifdef USE_OUTPUT
   /// The output to write the sound to.
@@ -113,6 +148,8 @@ class Rtttl final : public Component {
   /// The callback to call when playback is finished.
   CallbackManager<void()> on_finished_playback_callback_;
 #endif
+
+  friend class testing::RtttlParserAccess;
 };
 
 }  // namespace esphome::rtttl

esphome/components/runtime_image/__init__.py

@@ -115,7 +115,7 @@ class PNGFormat(Format):
 
     def actions(self) -> None:
         cg.add_define("USE_RUNTIME_IMAGE_PNG")
-        cg.add_library("pngle", "1.1.0")
+        cg.add_library("kikuchan98/pngle", "1.1.0")
 
 
 class QOIFormat(Format):

esphome/components/runtime_stats/runtime_stats.h

@@ -15,7 +15,7 @@ class Component;  // Forward declaration
 
 namespace runtime_stats {
 
-static const char *const TAG = "runtime_stats";
+ESPHOME_LOG_TAG(TAG, "runtime_stats");
 
 class RuntimeStatsCollector final {
  public:

esphome/components/sdl/sdl_esphome.h

@@ -13,7 +13,7 @@
 
 namespace esphome::sdl {
 
-constexpr static const char *const TAG = "sdl";
+ESPHOME_LOG_TAG(TAG, "sdl");
 
 class Sdl final : public display::Display, public snapshot::Snapshot {
  public:

esphome/components/spi_led_strip/spi_led_strip.h

@@ -7,7 +7,7 @@
 
 namespace esphome::spi_led_strip {
 
-static const char *const TAG = "spi_led_strip";
+ESPHOME_LOG_TAG(TAG, "spi_led_strip");
 class SpiLedStrip final : public light::AddressableLight,
                           public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_HIGH,
                                                 spi::CLOCK_PHASE_TRAILING, spi::DATA_RATE_1MHZ> {

esphome/components/st7701s/st7701s.h

@@ -8,13 +8,14 @@
 #include "esphome/core/component.h"
 #include "esphome/components/spi/spi.h"
 #include "esphome/components/display/display.h"
+#include "esphome/core/log.h"
 #include "esp_lcd_panel_ops.h"
 
 #include "esp_lcd_panel_rgb.h"
 
 namespace esphome::st7701s {
 
-constexpr static const char *const TAG = "display.st7701s";
+ESPHOME_LOG_TAG(TAG, "display.st7701s");
 const uint8_t SW_RESET_CMD = 0x01;
 const uint8_t SLEEP_OUT = 0x11;
 const uint8_t SDIR_CMD = 0xC7;

esphome/components/syslog/esphome_syslog.cpp

@@ -2,12 +2,13 @@
 
 #include "esphome/components/logger/logger.h"
 #include "esphome/core/application.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/time.h"
 
 namespace esphome::syslog {
 
 // Map log levels to syslog severity using an array, indexed by ESPHome log level (1-7)
-constexpr int LOG_LEVEL_TO_SYSLOG_SEVERITY[] = {
+static constexpr uint8_t LOG_LEVEL_TO_SYSLOG_SEVERITY[] PROGMEM = {
     3,  // NONE
     3,  // ERROR
     4,  // WARN
@@ -35,7 +36,7 @@ void Syslog::log_(const int level, const char *tag, const char *message, size_t
   // Syslog PRI calculation: facility * 8 + severity
   int severity = 7;
   if ((unsigned) level <= 7) {
-    severity = LOG_LEVEL_TO_SYSLOG_SEVERITY[level];
+    severity = progmem_read_byte(&LOG_LEVEL_TO_SYSLOG_SEVERITY[level]);
   }
   int pri = this->facility_ * 8 + severity;
 

esphome/components/thermostat/climate.py

@@ -240,12 +240,6 @@ def validate_thermostat(config: ConfigType) -> ConfigType:
             CONF_SUPPLEMENTAL_HEATING_ACTION,
             CONF_SUPPLEMENTAL_HEATING_DELTA,
         ],
-        CONF_MIN_COOLING_OFF_TIME: [
-            CONF_COOL_ACTION,
-        ],
-        CONF_MIN_COOLING_RUN_TIME: [
-            CONF_COOL_ACTION,
-        ],
         CONF_MIN_FANNING_OFF_TIME: [
             CONF_FAN_ONLY_ACTION,
         ],
@@ -284,6 +278,17 @@ def validate_thermostat(config: ConfigType) -> ConfigType:
                     f"{req_trigger} must be defined to use {config_trigger}"
                 )
 
+    # Dry mode runs on the cooling timers, so a dehumidifier needs no cool_action.
+    for timer in (CONF_MIN_COOLING_OFF_TIME, CONF_MIN_COOLING_RUN_TIME):
+        if (
+            timer in config
+            and CONF_COOL_ACTION not in config
+            and CONF_DRY_ACTION not in config
+        ):
+            raise cv.Invalid(
+                f"{CONF_COOL_ACTION} or {CONF_DRY_ACTION} must be defined to use {timer}"
+            )
+
     if CONF_FAN_ONLY_ACTION in config:
         # determine validation requirements based on fan_only_action_uses_fan_mode_timer setting
         if config[CONF_FAN_ONLY_ACTION_USES_FAN_MODE_TIMER] is True:

esphome/components/tmc2209/sensor/__init__.py

@@ -0,0 +1,87 @@
+import esphome.codegen as cg
+from esphome.components import sensor
+from esphome.components.tmc22xx import CONF_ANALOG_CURRENT_SCALE
+import esphome.config_validation as cv
+from esphome.const import (
+    CONF_ID,
+    DEVICE_CLASS_CURRENT,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    STATE_CLASS_MEASUREMENT,
+    UNIT_AMPERE,
+    UNIT_PERCENT,
+)
+import esphome.final_validate as fv
+from esphome.types import ConfigType
+
+from .. import TMC2209Stepper, tmc2209_ns
+
+CONF_ACTUAL_CURRENT = "actual_current"
+CONF_MOTOR_LOAD = "motor_load"
+CONF_PWM_GRAD_AUTO = "pwm_grad_auto"
+CONF_PWM_OFS_AUTO = "pwm_ofs_auto"
+CONF_PWM_SCALE_AUTO = "pwm_scale_auto"
+CONF_PWM_SCALE_SUM = "pwm_scale_sum"
+CONF_STALLGUARD_RESULT = "stallguard_result"
+CONF_TMC2209_ID = "tmc2209_id"
+
+TMC2209Sensor = tmc2209_ns.class_("TMC2209Sensor", cg.PollingComponent)
+
+_diagnostic_schema = sensor.sensor_schema(
+    accuracy_decimals=0,
+    state_class=STATE_CLASS_MEASUREMENT,
+    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+)
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(TMC2209Sensor),
+        cv.GenerateID(CONF_TMC2209_ID): cv.use_id(TMC2209Stepper),
+        cv.Optional(CONF_ACTUAL_CURRENT): sensor.sensor_schema(
+            unit_of_measurement=UNIT_AMPERE,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_CURRENT,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_MOTOR_LOAD): sensor.sensor_schema(
+            unit_of_measurement=UNIT_PERCENT,
+            accuracy_decimals=0,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_STALLGUARD_RESULT): _diagnostic_schema,
+        cv.Optional(CONF_PWM_SCALE_SUM): _diagnostic_schema,
+        cv.Optional(CONF_PWM_SCALE_AUTO): _diagnostic_schema,
+        cv.Optional(CONF_PWM_OFS_AUTO): _diagnostic_schema,
+        cv.Optional(CONF_PWM_GRAD_AUTO): _diagnostic_schema,
+    }
+).extend(cv.polling_component_schema("60s"))
+
+
+def _final_validate(config: ConfigType) -> ConfigType:
+    if CONF_ACTUAL_CURRENT not in config:
+        return config
+    full_config = fv.full_config.get()
+    path = full_config.get_path_for_id(config[CONF_TMC2209_ID])[:-1]
+    if full_config.get_config_for_path(path).get(CONF_ANALOG_CURRENT_SCALE):
+        raise cv.Invalid(
+            f"'{CONF_ACTUAL_CURRENT}' can't be used with '{CONF_ANALOG_CURRENT_SCALE}', "
+            "the current then depends on VREF",
+            path=[CONF_ACTUAL_CURRENT],
+        )
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _final_validate
+
+
+async def to_code(config: ConfigType) -> None:
+    hub = await cg.get_variable(config[CONF_TMC2209_ID])
+    var = cg.new_Pvariable(config[CONF_ID], hub)
+    await cg.register_component(var, config)
+    sensors = sensor.sub_sensors(config)
+    await sensors(CONF_ACTUAL_CURRENT, var.set_actual_current_sensor)
+    await sensors(CONF_STALLGUARD_RESULT, var.set_stallguard_result_sensor)
+    await sensors(CONF_MOTOR_LOAD, var.set_motor_load_sensor)
+    await sensors(CONF_PWM_SCALE_SUM, var.set_pwm_scale_sum_sensor)
+    await sensors(CONF_PWM_SCALE_AUTO, var.set_pwm_scale_auto_sensor)
+    await sensors(CONF_PWM_OFS_AUTO, var.set_pwm_ofs_auto_sensor)
+    await sensors(CONF_PWM_GRAD_AUTO, var.set_pwm_grad_auto_sensor)

esphome/components/tmc2209/sensor/tmc2209_sensor.cpp

@@ -0,0 +1,95 @@
+#include "tmc2209_sensor.h"
+#include "esphome/core/log.h"
+
+#include <cmath>
+
+namespace esphome::tmc2209 {
+
+ESPHOME_LOG_TAG(TAG, "tmc2209.sensor");
+
+using tmc22xx::TMC22XXStepper;
+
+// Highest StallGuard result, reached with no load
+static constexpr float STALLGUARD_RESULT_MAX = 510.0f;
+
+static void publish_field(sensor::Sensor *sensor, const optional<uint32_t> &data, const RegisterField &field) {
+  if (sensor == nullptr)
+    return;
+  if (!data.has_value()) {
+    sensor->publish_state(NAN);
+    return;
+  }
+  uint32_t value = TMC22XXStepper::extract_field(*data, field);
+  sensor->publish_state(field.is_signed ? static_cast<float>(static_cast<int32_t>(value)) : static_cast<float>(value));
+}
+
+void TMC2209Sensor::update() {
+  if (this->parent_->is_failed())
+    return;
+
+  // Each failed read blocks the loop for the UART timeout. Leave the bus alone while the driver is known to be
+  // unreachable or after the first failed read; the remaining sensors then publish NaN.
+  bool reachable = !this->parent_->is_unreachable();
+  auto read = [this, &reachable](uint8_t reg) -> optional<uint32_t> {
+    if (!reachable)
+      return {};
+    auto data = this->parent_->read_register(reg);
+    reachable = data.has_value();
+    return data;
+  };
+
+  if (this->actual_current_sensor_ != nullptr) {
+    auto drv_status = read(tmc22xx::REG_DRV_STATUS);
+    float current = NAN;
+    if (drv_status.has_value()) {
+      auto scale = static_cast<uint8_t>(TMC22XXStepper::extract_field(*drv_status, tmc22xx::CS_ACTUAL));
+      current = this->parent_->scale_to_current(scale);
+    }
+    this->actual_current_sensor_->publish_state(current);
+  }
+
+  // StallGuard only measures the load while the motor turns
+  bool moving = !this->parent_->has_reached_target();
+  if (this->stallguard_result_sensor_ != nullptr || (this->motor_load_sensor_ != nullptr && moving)) {
+    auto sg_result = read(REG_SG_RESULT);
+    publish_field(this->stallguard_result_sensor_, sg_result, SG_RESULT);
+    if (this->motor_load_sensor_ != nullptr) {
+      // 100% is the load at which a stall is reported, where the result drops below twice the threshold
+      float stall_result = 2.0f * this->parent_->get_stallguard_threshold();
+      float load = NAN;
+      if (moving && sg_result.has_value() && stall_result < STALLGUARD_RESULT_MAX) {
+        float result = TMC22XXStepper::extract_field(*sg_result, SG_RESULT);
+        load = (STALLGUARD_RESULT_MAX - result) / (STALLGUARD_RESULT_MAX - stall_result) * 100.0f;
+      }
+      this->motor_load_sensor_->publish_state(load);
+    }
+  } else if (this->motor_load_sensor_ != nullptr) {
+    this->motor_load_sensor_->publish_state(NAN);
+  }
+
+  if (this->pwm_scale_sum_sensor_ != nullptr || this->pwm_scale_auto_sensor_ != nullptr) {
+    auto pwm_scale = read(tmc22xx::REG_PWM_SCALE);
+    publish_field(this->pwm_scale_sum_sensor_, pwm_scale, tmc22xx::PWM_SCALE_SUM);
+    publish_field(this->pwm_scale_auto_sensor_, pwm_scale, tmc22xx::PWM_SCALE_AUTO);
+  }
+
+  if (this->pwm_ofs_auto_sensor_ != nullptr || this->pwm_grad_auto_sensor_ != nullptr) {
+    auto pwm_auto = read(tmc22xx::REG_PWM_AUTO);
+    publish_field(this->pwm_ofs_auto_sensor_, pwm_auto, tmc22xx::PWM_OFS_AUTO);
+    publish_field(this->pwm_grad_auto_sensor_, pwm_auto, tmc22xx::PWM_GRAD_AUTO);
+  }
+}
+
+void TMC2209Sensor::dump_config() {
+  ESP_LOGCONFIG(TAG, "TMC2209 Sensor:");
+  LOG_UPDATE_INTERVAL(this);
+  LOG_SENSOR("  ", "Actual Current", this->actual_current_sensor_);
+  LOG_SENSOR("  ", "StallGuard Result", this->stallguard_result_sensor_);
+  LOG_SENSOR("  ", "Motor Load", this->motor_load_sensor_);
+  LOG_SENSOR("  ", "PWM Scale Sum", this->pwm_scale_sum_sensor_);
+  LOG_SENSOR("  ", "PWM Scale Auto", this->pwm_scale_auto_sensor_);
+  LOG_SENSOR("  ", "PWM Offset Auto", this->pwm_ofs_auto_sensor_);
+  LOG_SENSOR("  ", "PWM Gradient Auto", this->pwm_grad_auto_sensor_);
+}
+
+}  // namespace esphome::tmc2209

esphome/components/tmc2209/sensor/tmc2209_sensor.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "esphome/components/sensor/sensor.h"
+#include "esphome/components/tmc2209/tmc2209.h"
+#include "esphome/core/component.h"
+
+namespace esphome::tmc2209 {
+
+class TMC2209Sensor : public PollingComponent {
+ public:
+  explicit TMC2209Sensor(TMC2209Stepper *parent) : parent_(parent) {}
+
+  void update() override;
+  void dump_config() override;
+
+  void set_actual_current_sensor(sensor::Sensor *sensor) { this->actual_current_sensor_ = sensor; }
+  void set_stallguard_result_sensor(sensor::Sensor *sensor) { this->stallguard_result_sensor_ = sensor; }
+  void set_motor_load_sensor(sensor::Sensor *sensor) { this->motor_load_sensor_ = sensor; }
+  void set_pwm_scale_sum_sensor(sensor::Sensor *sensor) { this->pwm_scale_sum_sensor_ = sensor; }
+  void set_pwm_scale_auto_sensor(sensor::Sensor *sensor) { this->pwm_scale_auto_sensor_ = sensor; }
+  void set_pwm_ofs_auto_sensor(sensor::Sensor *sensor) { this->pwm_ofs_auto_sensor_ = sensor; }
+  void set_pwm_grad_auto_sensor(sensor::Sensor *sensor) { this->pwm_grad_auto_sensor_ = sensor; }
+
+ protected:
+  TMC2209Stepper *parent_;
+  sensor::Sensor *actual_current_sensor_{nullptr};
+  sensor::Sensor *stallguard_result_sensor_{nullptr};
+  sensor::Sensor *motor_load_sensor_{nullptr};
+  sensor::Sensor *pwm_scale_sum_sensor_{nullptr};
+  sensor::Sensor *pwm_scale_auto_sensor_{nullptr};
+  sensor::Sensor *pwm_ofs_auto_sensor_{nullptr};
+  sensor::Sensor *pwm_grad_auto_sensor_{nullptr};
+};
+
+}  // namespace esphome::tmc2209

esphome/components/tmc2209/tmc2209.h

@@ -9,10 +9,12 @@ using tmc22xx::RegisterField;
 // StallGuard and CoolStep registers, which the TMC2208 does not have
 static constexpr uint8_t REG_TCOOLTHRS = 0x14;
 static constexpr uint8_t REG_SGTHRS = 0x40;
+static constexpr uint8_t REG_SG_RESULT = 0x41;
 static constexpr uint8_t REG_COOLCONF = 0x42;
 
 static constexpr RegisterField TCOOLTHRS{REG_TCOOLTHRS, 0, 20, false};
 static constexpr RegisterField SGTHRS{REG_SGTHRS, 0, 8, false};
+static constexpr RegisterField SG_RESULT{REG_SG_RESULT, 0, 10, false};
 static constexpr RegisterField SEMIN{REG_COOLCONF, 0, 4, false};
 static constexpr RegisterField SEUP{REG_COOLCONF, 5, 2, false};
 static constexpr RegisterField SEMAX{REG_COOLCONF, 8, 4, false};
@@ -30,6 +32,7 @@ class TMC2209Stepper : public tmc22xx::TMC22XXStepper {
 
   /// A stall is reported when the StallGuard result drops below twice this value.
   void set_stallguard_threshold(uint8_t threshold) { this->write_field(SGTHRS, threshold); }
+  uint8_t get_stallguard_threshold() const { return extract_field(this->sgthrs_, SGTHRS); }
   /// Lower velocity limit, as TSTEP, for CoolStep and the StallGuard output on DIAG.
   void set_tcool_threshold(uint32_t threshold) { this->write_field(TCOOLTHRS, threshold); }
   void set_semin(uint8_t semin) { this->write_field(SEMIN, semin); }

esphome/components/tmc22xx/tmc22xx.h

@@ -33,6 +33,8 @@ static constexpr uint8_t REG_VACTUAL = 0x22;
 static constexpr uint8_t REG_CHOPCONF = 0x6C;
 static constexpr uint8_t REG_DRV_STATUS = 0x6F;
 static constexpr uint8_t REG_PWMCONF = 0x70;
+static constexpr uint8_t REG_PWM_SCALE = 0x71;
+static constexpr uint8_t REG_PWM_AUTO = 0x72;
 
 // Readable registers that a driver reset sets back to their defaults; the last written values are restored
 static constexpr std::array<uint8_t, 4> RESTORED_REGISTERS{REG_GCONF, REG_FACTORY_CONF, REG_CHOPCONF, REG_PWMCONF};
@@ -59,7 +61,12 @@ static constexpr RegisterField VSENSE{REG_CHOPCONF, 17, 1, false};
 static constexpr RegisterField MRES{REG_CHOPCONF, 24, 4, false};
 static constexpr RegisterField INTPOL{REG_CHOPCONF, 28, 1, false};
 static constexpr RegisterField DEDGE{REG_CHOPCONF, 29, 1, false};
+static constexpr RegisterField CS_ACTUAL{REG_DRV_STATUS, 16, 5, false};
 static constexpr RegisterField FREEWHEEL{REG_PWMCONF, 20, 2, false};
+static constexpr RegisterField PWM_SCALE_SUM{REG_PWM_SCALE, 0, 8, false};
+static constexpr RegisterField PWM_SCALE_AUTO{REG_PWM_SCALE, 16, 9, true};
+static constexpr RegisterField PWM_OFS_AUTO{REG_PWM_AUTO, 0, 8, false};
+static constexpr RegisterField PWM_GRAD_AUTO{REG_PWM_AUTO, 16, 8, false};
 
 enum StandstillMode : uint8_t {
   STANDSTILL_MODE_NORMAL = 0,
@@ -129,6 +136,8 @@ class TMC22XXStepper : public stepper::Stepper, public Component, public uart::U
   /// Enable or disable the motor outputs, using the ENN pin when configured and TOFF otherwise.
   void set_enabled(bool enabled);
   bool is_enabled() const { return this->enabled_; }
+  /// True while the driver does not answer, until the status poll reads it again (every 10 s).
+  bool is_unreachable() const { return this->status_poll_skip_ > 0; }
 
   /// Called with the condition and whether it became active or cleared.
   template<typename F> void add_on_status_callback(F &&callback) {

esphome/components/toshiba/toshiba.cpp

@@ -3,8 +3,6 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 
-#include <vector>
-
 namespace esphome::toshiba {
 
 struct RacPt1411hwruFanSpeed {
@@ -69,8 +67,8 @@ const uint8_t RAC_PT1411HWRU_CS_FOOTER_COOL = 0x72;
 const uint8_t RAC_PT1411HWRU_CS_FOOTER_HEAT = 0x7E;
 // RAC-PT1411HWRU Swing
 const uint8_t RAC_PT1411HWRU_SWING_HEADER = 0xB9;
-const std::vector<uint8_t> RAC_PT1411HWRU_SWING_VERTICAL{0xB9, 0x46, 0xF5, 0x0A, 0x04, 0xFB};
-const std::vector<uint8_t> RAC_PT1411HWRU_SWING_OFF{0xB9, 0x46, 0xF5, 0x0A, 0x05, 0xFA};
+static constexpr uint8_t RAC_PT1411HWRU_SWING_VERTICAL[] PROGMEM = {0xB9, 0x46, 0xF5, 0x0A, 0x04, 0xFB};
+static constexpr uint8_t RAC_PT1411HWRU_SWING_OFF[] PROGMEM = {0xB9, 0x46, 0xF5, 0x0A, 0x05, 0xFA};
 // RAC-PT1411HWRU Fan speeds
 const uint8_t RAC_PT1411HWRU_FAN_OFF = 0x7B;
 constexpr RacPt1411hwruFanSpeed RAC_PT1411HWRU_FAN_AUTO{0xBF, 0x66};
@@ -92,12 +90,12 @@ const uint8_t RAC_PT1411HWRU_TEMPERATURE_FAN_ONLY = 0x0E;
 //  Hence these look-up tables. In addition, the upper nibble is used here for additional
 //  "negative" and "fractional value" flags as required for some temperatures.
 // RAC-PT1411HWRU °C Temperatures (short codes)
-const std::vector<uint8_t> RAC_PT1411HWRU_TEMPERATURE_C{0x10, 0x00, 0x01, 0x03, 0x02, 0x06, 0x07, 0x05,
-                                                        0x04, 0x0C, 0x0D, 0x09, 0x08, 0x0A, 0x0B};
+static constexpr uint8_t RAC_PT1411HWRU_TEMPERATURE_C[] PROGMEM = {0x10, 0x00, 0x01, 0x03, 0x02, 0x06, 0x07, 0x05,
+                                                                   0x04, 0x0C, 0x0D, 0x09, 0x08, 0x0A, 0x0B};
 // RAC-PT1411HWRU °F Temperatures (short codes)
-const std::vector<uint8_t> RAC_PT1411HWRU_TEMPERATURE_F{0x10, 0x30, 0x00, 0x20, 0x01, 0x21, 0x03, 0x23, 0x02,
-                                                        0x22, 0x06, 0x26, 0x07, 0x05, 0x25, 0x04, 0x24, 0x0C,
-                                                        0x2C, 0x0D, 0x2D, 0x09, 0x08, 0x28, 0x0A, 0x2A, 0x0B};
+static constexpr uint8_t RAC_PT1411HWRU_TEMPERATURE_F[] PROGMEM = {
+    0x10, 0x30, 0x00, 0x20, 0x01, 0x21, 0x03, 0x23, 0x02, 0x22, 0x06, 0x26, 0x07, 0x05,
+    0x25, 0x04, 0x24, 0x0C, 0x2C, 0x0D, 0x2D, 0x09, 0x08, 0x28, 0x0A, 0x2A, 0x0B};
 
 // RAS-2819T protocol constants
 const uint16_t RAS_2819T_HEADER1 = 0xC23D;
@@ -213,7 +211,7 @@ static constexpr uint8_t SEIYA_SWING_HORIZONTAL = 0x09;
 static constexpr uint8_t SEIYA_SWING_NEUTRAL = 0x17;  // no swing change in this frame
 
 // RAS-2819T temperature codes for 18-30°C
-static const uint8_t RAS_2819T_TEMP_CODES[] = {
+static constexpr uint8_t RAS_2819T_TEMP_CODES[] PROGMEM = {
     0x10,  // 18°C
     0x30,  // 19°C
     0x20,  // 20°C
@@ -328,7 +326,7 @@ static uint8_t get_ras_2819t_temp_code(float temperature) {
     return 0x40;  // Default to 24°C
   }
 
-  return RAS_2819T_TEMP_CODES[temp_index];
+  return progmem_read_byte(&RAS_2819T_TEMP_CODES[temp_index]);
 }
 
 /**
@@ -339,7 +337,7 @@ static float decode_ras_2819t_temperature(uint8_t temp_code) {
 
   // Find the code in the temperature array
   for (size_t temp_index = 0; temp_index < sizeof(RAS_2819T_TEMP_CODES); temp_index++) {
-    if (RAS_2819T_TEMP_CODES[temp_index] == base_temp_code) {
+    if (progmem_read_byte(&RAS_2819T_TEMP_CODES[temp_index]) == base_temp_code) {
       return static_cast<float>(temp_index + 18);  // 18°C is the minimum
     }
   }
@@ -680,10 +678,10 @@ void ToshibaClimate::transmit_rac_pt1411hwru_() {
   index = static_cast<uint8_t>(roundf(temp_adjd));
 
   if (this->model_ == MODEL_RAC_PT1411HWRU_F) {
-    code = RAC_PT1411HWRU_TEMPERATURE_F[index];
+    code = progmem_read_byte(&RAC_PT1411HWRU_TEMPERATURE_F[index]);
     message[9] |= RAC_PT1411HWRU_FLAG_FAH;
   } else {
-    code = RAC_PT1411HWRU_TEMPERATURE_C[index];
+    code = progmem_read_byte(&RAC_PT1411HWRU_TEMPERATURE_C[index]);
   }
   if ((this->mode == climate::CLIMATE_MODE_FAN_ONLY) || (this->mode == climate::CLIMATE_MODE_OFF)) {
     code = RAC_PT1411HWRU_TEMPERATURE_FAN_ONLY;
@@ -752,15 +750,11 @@ void ToshibaClimate::transmit_rac_pt1411hwru_() {
   // Swing Mode
   data->reset();
   data->space(TOSHIBA_PACKET_SPACE);
-  switch (this->swing_mode) {
-    case climate::CLIMATE_SWING_VERTICAL:
-      this->encode_(data, &RAC_PT1411HWRU_SWING_VERTICAL[0], RAC_PT1411HWRU_MESSAGE_LENGTH, 1);
-      break;
-
-    case climate::CLIMATE_SWING_OFF:
-    default:
-      this->encode_(data, &RAC_PT1411HWRU_SWING_OFF[0], RAC_PT1411HWRU_MESSAGE_LENGTH, 1);
-  }
+  const uint8_t *swing_frame =
+      this->swing_mode == climate::CLIMATE_SWING_VERTICAL ? RAC_PT1411HWRU_SWING_VERTICAL : RAC_PT1411HWRU_SWING_OFF;
+  uint8_t swing[RAC_PT1411HWRU_MESSAGE_LENGTH];
+  progmem_memcpy(swing, swing_frame, sizeof(swing));
+  this->encode_(data, swing, sizeof(swing), 1);
 
   data->space(TOSHIBA_PACKET_SPACE);
   transmit.perform();
@@ -1300,14 +1294,14 @@ bool ToshibaClimate::on_receive(remote_base::RemoteReceiveData data) {
         temperature_code =
             (message[4] >> 4) | (message[14] & RAC_PT1411HWRU_FLAG_FRAC) | (message[15] & RAC_PT1411HWRU_FLAG_NEG);
         if (message[15] & RAC_PT1411HWRU_FLAG_FAH) {
-          for (size_t i = 0; i < RAC_PT1411HWRU_TEMPERATURE_F.size(); i++) {
-            if (RAC_PT1411HWRU_TEMPERATURE_F[i] == temperature_code) {
+          for (size_t i = 0; i < sizeof(RAC_PT1411HWRU_TEMPERATURE_F); i++) {
+            if (progmem_read_byte(&RAC_PT1411HWRU_TEMPERATURE_F[i]) == temperature_code) {
               this->target_temperature = static_cast<float>((i + TOSHIBA_RAC_PT1411HWRU_TEMP_F_MIN - 32) * 5) / 9;
             }
           }
         } else {
-          for (size_t i = 0; i < RAC_PT1411HWRU_TEMPERATURE_C.size(); i++) {
-            if (RAC_PT1411HWRU_TEMPERATURE_C[i] == temperature_code) {
+          for (size_t i = 0; i < sizeof(RAC_PT1411HWRU_TEMPERATURE_C); i++) {
+            if (progmem_read_byte(&RAC_PT1411HWRU_TEMPERATURE_C[i]) == temperature_code) {
               this->target_temperature = i + TOSHIBA_RAC_PT1411HWRU_TEMP_C_MIN;
             }
           }
@@ -1333,7 +1327,7 @@ bool ToshibaClimate::on_receive(remote_base::RemoteReceiveData data) {
       break;
     // Swing mode
     case RAC_PT1411HWRU_SWING_HEADER:
-      if (message[4] == RAC_PT1411HWRU_SWING_VERTICAL[4]) {
+      if (message[4] == progmem_read_byte(&RAC_PT1411HWRU_SWING_VERTICAL[4])) {
         this->swing_mode = climate::CLIMATE_SWING_VERTICAL;
       } else {
         this->swing_mode = climate::CLIMATE_SWING_OFF;

esphome/components/usb_host/usb_host.h

@@ -12,6 +12,7 @@
 #include <freertos/task.h>
 #include "esphome/core/lock_free_queue.h"
 #include "esphome/core/event_pool.h"
+#include "esphome/core/log.h"
 #include <atomic>
 #include <span>
 
@@ -39,7 +40,7 @@ namespace esphome::usb_host {
 // - Main loop controls backpressure by deciding when to restart after consuming data
 // The atomic bitmask ensures thread-safe allocation/deallocation without mutex blocking.
 
-static const char *const TAG = "usb_host";
+ESPHOME_LOG_TAG(TAG, "usb_host");
 
 // Forward declarations
 struct TransferRequest;

esphome/components/usb_uart/usb_uart.h

@@ -9,6 +9,7 @@
 #include "esphome/components/usb_host/usb_host.h"
 #include "esphome/core/lock_free_queue.h"
 #include "esphome/core/event_pool.h"
+#include "esphome/core/log.h"
 #include <atomic>
 #include <functional>
 
@@ -19,7 +20,7 @@ class USBUartComponent;
 class USBUartChannelBase;
 class USBUartTypePL2303;
 
-static const char *const TAG = "usb_uart";
+ESPHOME_LOG_TAG(TAG, "usb_uart");
 
 static constexpr uint8_t USB_CDC_SUBCLASS_ACM = 0x02;
 static constexpr uint8_t USB_SUBCLASS_COMMON = 0x02;

esphome/components/zio_ultrasonic/zio_ultrasonic.h

@@ -3,8 +3,9 @@
 #include "esphome/core/component.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
+#include "esphome/core/log.h"
 
-static const char *const TAG = "Zio Ultrasonic";
+ESPHOME_LOG_TAG(TAG, "Zio Ultrasonic");
 
 namespace esphome::zio_ultrasonic {
 

esphome/core/defines.h

@@ -69,6 +69,7 @@
 #define USE_DISPLAY
 #define DISPLAY_PAGE_CHANGE_CALLBACK_COUNT 1
 #define USE_EMONTX_VERSION
+#define USE_EMONTX_VERSION_TEXT_SENSOR
 #define USE_ENTITY_DEVICE_CLASS
 #define USE_ENTITY_ICON
 #define USE_ENTITY_UNIT_OF_MEASUREMENT
@@ -436,6 +437,11 @@
 #define USE_ESP32_BLE_TRACKER
 #define USE_ESP32_BLE_TRACKER_DIRECT_CONN_GUARD
 #define USE_BLE_GATT_CLIENT
+#define USE_BLE_GATT_BACKEND_BLUEDROID
+#define USE_BLUEDROID_GATT_SERVICE_TABLE
+#define USE_BLE_CLIENT_GATT_NODES
+#define USE_BLE_CLIENT_LEGACY_ENGINE
+#define ESPHOME_BLE_CLIENT_MAX_NODES 1
 #define ESPHOME_BLE_GATT_CLIENT_COUNT 1
 #define ESPHOME_ESP32_BLE_TRACKER_LISTENER_COUNT 1
 #define ESPHOME_ESP32_BLE_TRACKER_CLIENT_COUNT 1
@@ -636,7 +642,10 @@
 #define ESPHOME_BLE_DEVICE_BASE_LISTENER_COUNT 1
 #define USE_BLE_SCAN_RESPONSE_MERGER
 #define USE_BLE_GATT_CLIENT
+#define USE_BLE_GATT_BACKEND_RP2
+#define USE_BLE_CLIENT_GATT_NODES
 #define ESPHOME_BLE_GATT_CLIENT_COUNT 3
+#define ESPHOME_BLE_CLIENT_MAX_NODES 1
 #define USE_RP2040_VARIANT_RP2040
 #define USE_SPI
 #ifndef USE_ETHERNET

esphome/core/helpers.cpp

@@ -11,6 +11,7 @@
 #include <cmath>
 #include <cstdarg>
 #include <cstdio>
+#include <cstdlib>
 #include <cstring>
 
 #ifdef USE_ESP32
@@ -315,6 +316,57 @@ size_t truncate_name_to(char *buffer, size_t buffer_size, const char *name, size
 
 // Parsing & formatting
 
+// A plain decimal converts exactly with one division: the digits accumulate
+// into an integer that stays below 2^24 and the fraction's scale is a power of
+// ten up to 1e9 (2^9 * 5^9), so both convert to float exactly and IEEE division
+// rounds the quotient correctly, the same result strtof produces.
+static constexpr uint32_t PARSE_FLOAT_MANTISSA_LIMIT = 1000000;  // one more digit stays below 2^24
+static constexpr uint32_t PARSE_FLOAT_MAX_FRACTION_DIGITS = 9;
+
+optional<float> parse_float(const char *str) {
+  const char *p = str;
+  const bool negative = *p == '-';
+  if (negative || *p == '+')
+    p++;
+  const char *digits = p;
+  const char *dot = nullptr;
+  uint32_t mantissa = 0;
+  for (;; p++) {
+    const uint32_t d = static_cast<unsigned char>(*p) - '0';
+    if (d > 9) {
+      if (*p == '.' && dot == nullptr) {
+        dot = p;
+        continue;
+      }
+      break;
+    }
+    if (mantissa >= PARSE_FLOAT_MANTISSA_LIMIT)
+      break;
+    mantissa = mantissa * 10 + d;
+  }
+  const uint32_t fraction_digits = dot != nullptr ? p - dot - 1 : 0;
+  const bool any_digit = p - digits > (dot != nullptr ? 1 : 0);
+  if (*p == '\0' && any_digit && fraction_digits <= PARSE_FLOAT_MAX_FRACTION_DIGITS) {
+    // The mantissa is exact in a float, so the sign goes on before the one rounding step
+    float value = static_cast<float>(mantissa);
+    if (negative)
+      value = -value;
+    if (fraction_digits != 0) {
+      uint32_t scale = 10;
+      for (uint32_t i = 1; i < fraction_digits; i++)
+        scale *= 10;
+      value /= static_cast<float>(scale);
+    }
+    return value;
+  }
+  // Exponents, hex, inf, nan, leading whitespace and longer inputs take the libc path.
+  char *end = nullptr;
+  const float value = ::strtof(str, &end);
+  if (end == str || *end != '\0' || value == HUGE_VALF)
+    return {};
+  return value;
+}
+
 size_t parse_hex(const char *str, size_t length, uint8_t *data, size_t count) {
   size_t chars = std::min(length, 2 * count);
   for (size_t i = 2 * count - chars; i < 2 * count; i++, str++) {

esphome/core/helpers.h

@@ -1299,13 +1299,11 @@ template<typename T, enable_if_t<(std::is_integral<T>::value && std::is_signed<T
 optional<T> parse_number(const std::string &str) {
   return parse_number<T>(str.c_str());
 }
+/// Parse a decimal floating-point number; plain decimals skip the libc parser.
+optional<float> parse_float(const char *str);
 /// Parse a decimal floating-point number from a null-terminated string.
 template<typename T, enable_if_t<(std::is_same<T, float>::value), int> = 0> optional<T> parse_number(const char *str) {
-  char *end = nullptr;
-  float value = ::strtof(str, &end);
-  if (end == str || *end != '\0' || value == HUGE_VALF)
-    return {};
-  return value;
+  return parse_float(str);
 }
 /// Parse a decimal floating-point number.
 template<typename T, enable_if_t<(std::is_same<T, float>::value), int> = 0>

esphome/core/log.h

@@ -190,8 +190,9 @@ struct LogString;
 
 #endif
 
-// Declares a static log tag at namespace scope in a .cpp file; on ESP8266 it lives in flash, so read it with
-// the _P functions, never strcmp/strlen.
+// Declares a static log tag at namespace scope, in a source file or a header; on ESP8266 it lives in flash, so
+// read it with the _P functions, never strcmp/strlen. Not usable for a class member: the ESP8266 form is a
+// PROGMEM array, which cannot be initialized in a class.
 #ifdef USE_ESP8266
 #define ESPHOME_LOG_TAG(name, tag) static const char name[] PROGMEM = tag
 #else

esphome/core/wake/wake_host.cpp

@@ -22,7 +22,7 @@ namespace esphome {
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 std::atomic<uint8_t> g_wake_requested{0};
 
-static const char *const TAG = "wake";
+ESPHOME_LOG_TAG(TAG, "wake");
 
 namespace internal {
 // File-scope state — referenced inline by wake_drain_notifications() and

esphome/idf_component.yml

@@ -21,6 +21,8 @@ dependencies:
     version: "1.8.2"
   espressif/esp-tflite-micro:
     version: 1.3.3~1
+  espressif/esp-nn:
+    version: 1.1.2
   espressif/esp32-camera:
     version: 2.1.7
   espressif/mdns:

platformio.ini

@@ -46,9 +46,9 @@ lib_deps =
     ${common.lib_deps_base}
     https://github.com/dudanov/MideaUART.git#eeea6c3e9b4474f067054592b435be1c4e466815 ; midea
     improv/Improv@1.2.7                    ; improv_serial / improv_ble
-    kikuchan98/pngle@1.1.0                 ; online_image
+    kikuchan98/pngle@1.1.0                 ; runtime_image
     ; Using the repository directly, otherwise ESP-IDF can't use the library
-    https://github.com/bitbank2/JPEGDEC.git#1.8.4    ; online_image
+    https://github.com/bitbank2/JPEGDEC.git#1.8.4    ; runtime_image
     ; This dependency is used only in unit tests.
     ; Must coincide with PLATFORMIO_GOOGLE_TEST_LIB in scripts/cpp_unit_test.py
     ; See scripts/cpp_unit_test.py and tests/components/README.md
@@ -82,7 +82,7 @@ lib_deps =
     esphome/noise-c@0.1.31                                ; noise (api, ota)
     SPI                                                   ; spi (Arduino built-in)
     Wire                                                  ; i2c (Arduino built-int)
-    heman/AsyncMqttClient-esphome@1.0.0                   ; mqtt
+    heman/AsyncMqttClient-esphome@2.0.0                   ; mqtt
     freekode/TM1651@1.0.1                                 ; tm1651
     tonia/HeatpumpIR@1.0.42                               ; heatpumpir
 build_flags =
@@ -252,8 +252,8 @@ lib_deps =
     DNSServer                             ; captive_portal
     heman/AsyncMqttClient-esphome@2.0.0   ; mqtt
     improv/Improv@1.2.7                   ; improv_serial
-    kikuchan98/pngle@1.1.0                ; online_image
-    https://github.com/bitbank2/JPEGDEC.git#1.8.4    ; online_image
+    kikuchan98/pngle@1.1.0                ; runtime_image
+    https://github.com/bitbank2/JPEGDEC.git#1.8.4    ; runtime_image
 build_flags =
     ${common:arduino.build_flags}
     -DUSE_LIBRETINY

script/ci-custom.py

@@ -1269,11 +1269,15 @@ def lint_no_std_nothrow(fname, match):
     )
 
 
+# Every C++ source and header; plain C files cannot use the macro
+LOG_TAG_INCLUDE = ["esphome/*.cpp", "esphome/*.h"]
+
+
 @lint_re_check(
-    r"^\s*(?:(?:static|constexpr|inline)\s+)*(?:const\s+)?char\s*(?:\*\s*(?:const\s+)?TAG|\s(?:const\s+)?TAG\s*\[\w*\])"
-    r"\s*(?:=\s*\{?|[{(])\s*\"",
+    r"^\s*(?:(?:static|constexpr|inline)\s+)*(?:const\s+)?char\s*(?:\*\s*(?:const\s+)?(?:\w+::)*TAG|\s(?:const\s+)?(?:\w+::)*TAG\s*\[\w*\])"
+    r"\s*(?:=\s*\{?|[{(])\s*\"" + CPP_RE_EOL,
     prefilter="TAG",
-    include=["esphome/components/*.cpp", "esphome/components/**/*.cpp"],
+    include=LOG_TAG_INCLUDE,
 )
 def lint_log_tag_macro(fname, match):
     return (
@@ -1281,6 +1285,8 @@ def lint_log_tag_macro(fname, match):
         f"ESP8266.\n"
         f"  Before: {highlight('static const char *const TAG = "name";')}\n"
         f"  After:  {highlight('ESPHOME_LOG_TAG(TAG, "name");')}\n"
+        f"A class member tag cannot use the macro; declare {highlight('static const char TAG[];')} in the class "
+        f"and define {highlight('const char Foo::TAG[] PROGMEM = "name";')} in the .cpp.\n"
         f"Never pass such a TAG to set_timeout/set_interval names or string functions.\n"
         f"(If strictly necessary, add `// NOLINT` to the end of the line)"
     )
@@ -1288,11 +1294,11 @@ def lint_log_tag_macro(fname, match):
 
 @lint_re_check(
     r"(?:\b(?:set_timeout|set_interval|set_retry|cancel_timeout|cancel_interval|cancel_retry|defer)"
-    r"|\b(?:strcmp|strncmp|strcasecmp|strlen|strcpy|strncpy)|std::string)\s*\((?:(?:[^();]|\([^()]*\))*,)?\s*TAG\b"
-    r"|\bstd::string\s+\w+\s*[={(]\s*TAG\b",
+    r"|\b(?:strcmp|strncmp|strcasecmp|strlen|strcpy|strncpy)|std::string)\s*\((?:(?:[^();]|\([^()]*\))*,)?\s*(?:\w+::)*TAG\b"
+    r"|\bstd::string\s+\w+\s*[={(]\s*(?:\w+::)*TAG\b",
     mask=True,
     prefilter="TAG",
-    include=["esphome/components/*.cpp", "esphome/components/**/*.cpp"],
+    include=LOG_TAG_INCLUDE,
 )
 def lint_log_tag_as_string(fname, match):
     return (

tests/benchmarks/components/homeassistant/bench_homeassistant_sensor.cpp

@@ -0,0 +1,196 @@
+#include "esphome/core/defines.h"
+#if defined(USE_API_PLAINTEXT) && defined(USE_API_HOMEASSISTANT_STATES) && defined(USE_SENSOR)
+
+#include <benchmark/benchmark.h>
+#include <sys/socket.h>
+
+#include <array>
+#include <memory>
+
+#include "esphome/components/api/api_connection.h"
+#include "esphome/components/api/api_server.h"
+#include "esphome/components/homeassistant/sensor/homeassistant_sensor.h"
+#include "esphome/components/socket/socket.h"
+#include "esphome/core/string_ref.h"
+
+namespace esphome::homeassistant::benchmarks {
+
+static constexpr int kInnerIterations = 2000;
+
+// Each benchmark gets its own API server so subscriptions from one do not
+// stay in the list scanned by the next. The constructor installs itself as
+// global_api_server, which is what HomeassistantSensor::setup() subscribes to.
+class ScopedApiServer {
+ public:
+  ScopedApiServer() : previous_(api::global_api_server) {}
+  ~ScopedApiServer() { api::global_api_server = this->previous_; }
+  api::APIServer *get() { return &this->server_; }
+
+ protected:
+  api::APIServer *previous_;
+  api::APIServer server_;
+};
+
+// The handler only reads the server's subscription list, so the connection is
+// never started and its socket never used.
+static std::unique_ptr<api::APIConnection> create_connection(api::APIServer *server) {
+  const int fd = ::socket(AF_INET, SOCK_STREAM, 0);
+  return std::make_unique<api::APIConnection>(std::make_unique<socket::Socket>(fd), server);
+}
+
+// State strings as Home Assistant sends them. The handler writes a terminator
+// one byte past the state, so the buffers are mutable and the terminator it
+// writes lands on the one the literal already has.
+static constexpr int kStateCount = 4;
+static constexpr size_t kStateBufferSize = 16;
+using StateBuffers = char[kStateCount][kStateBufferSize];
+using Messages = std::array<api::HomeAssistantStateResponse, kStateCount>;
+
+static StateBuffers NUMERIC_STATES = {"100.50", "101.25", "99.75", "100.00"};
+static StateBuffers INTEGER_STATES = {"100", "101", "99", "0"};
+static StateBuffers UNAVAILABLE_STATES = {"unavailable", "unknown", "unavailable", "unknown"};
+
+static Messages make_messages(const char *entity_id, const char *attribute, StateBuffers &states) {
+  Messages msgs;
+  for (int i = 0; i < kStateCount; i++) {
+    msgs[i].entity_id = StringRef(entity_id);
+    if (attribute != nullptr) {
+      msgs[i].attribute = StringRef(attribute);
+    }
+    msgs[i].state = StringRef(states[i]);
+  }
+  return msgs;
+}
+
+// --- One imported sensor, numeric state that changes every message ---
+// Exercises: subscription match, in-place terminator, parse_number, publish_state.
+
+static void HomeassistantSensor_StateResponse(benchmark::State &state) {
+  ScopedApiServer server;
+  auto conn = create_connection(server.get());
+  const Messages msgs = make_messages("sensor.power", nullptr, NUMERIC_STATES);
+
+  HomeassistantSensor sensor;
+  sensor.set_entity_id("sensor.power");
+  sensor.setup();
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      conn->on_home_assistant_state_response(msgs[i % kStateCount]);
+    }
+    benchmark::DoNotOptimize(sensor.state);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(HomeassistantSensor_StateResponse);
+
+// --- The same sensor with integer states such as a percentage or a count ---
+// Exercises: the same path with no fractional digits to parse. Only the state
+// differs from the decimal case, so the gap between the two is the parse.
+
+static void HomeassistantSensor_StateResponse_Integer(benchmark::State &state) {
+  ScopedApiServer server;
+  auto conn = create_connection(server.get());
+  const Messages msgs = make_messages("sensor.power", nullptr, INTEGER_STATES);
+
+  HomeassistantSensor sensor;
+  sensor.set_entity_id("sensor.power");
+  sensor.setup();
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      conn->on_home_assistant_state_response(msgs[i % kStateCount]);
+    }
+    benchmark::DoNotOptimize(sensor.state);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(HomeassistantSensor_StateResponse_Integer);
+
+// --- Attribute import: the subscription and the message both carry an attribute ---
+// Exercises: the extra attribute compare before the callback.
+
+static void HomeassistantSensor_StateResponse_Attribute(benchmark::State &state) {
+  ScopedApiServer server;
+  auto conn = create_connection(server.get());
+  const Messages msgs = make_messages("climate.living_room", "current_temperature", NUMERIC_STATES);
+
+  HomeassistantSensor sensor;
+  sensor.set_entity_id("climate.living_room");
+  sensor.set_attribute("current_temperature");
+  sensor.setup();
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      conn->on_home_assistant_state_response(msgs[i % kStateCount]);
+    }
+    benchmark::DoNotOptimize(sensor.state);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(HomeassistantSensor_StateResponse_Attribute);
+
+// --- Sixteen imported sensors, message for the last one ---
+// Exercises: the linear scan over the subscription list with a string compare
+// per entry, which is what a device with many imported entities pays per update.
+// The IDs share a length and differ only in the last two bytes, so every
+// entry runs a near-full compare, the worst case for the scan.
+
+static constexpr int kSensorCount = 16;
+
+static void HomeassistantSensor_StateResponse_ManySubscriptions(benchmark::State &state) {
+  ScopedApiServer server;
+  auto conn = create_connection(server.get());
+
+  static constexpr const char *const ENTITY_IDS[kSensorCount] = {
+      "sensor.import_00", "sensor.import_01", "sensor.import_02", "sensor.import_03",
+      "sensor.import_04", "sensor.import_05", "sensor.import_06", "sensor.import_07",
+      "sensor.import_08", "sensor.import_09", "sensor.import_10", "sensor.import_11",
+      "sensor.import_12", "sensor.import_13", "sensor.import_14", "sensor.import_15",
+  };
+  HomeassistantSensor sensors[kSensorCount];
+  for (int i = 0; i < kSensorCount; i++) {
+    sensors[i].set_entity_id(ENTITY_IDS[i]);
+    sensors[i].setup();
+  }
+  const Messages msgs = make_messages(ENTITY_IDS[kSensorCount - 1], nullptr, NUMERIC_STATES);
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      conn->on_home_assistant_state_response(msgs[i % kStateCount]);
+    }
+    benchmark::DoNotOptimize(sensors[kSensorCount - 1].state);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(HomeassistantSensor_StateResponse_ManySubscriptions);
+
+// --- Non-numeric state such as "unavailable" ---
+// Exercises: the failed parse, the warning the platform logs for it, and the
+// NAN publish. The benchmark logger runs at the production default level with
+// console output off, so a log line at DEBUG or above costs its formatting
+// here, the same as on a device, and a log level change in the platform shows
+// up as a delta.
+
+static void HomeassistantSensor_StateResponse_Unavailable(benchmark::State &state) {
+  ScopedApiServer server;
+  auto conn = create_connection(server.get());
+  const Messages msgs = make_messages("sensor.power", nullptr, UNAVAILABLE_STATES);
+
+  HomeassistantSensor sensor;
+  sensor.set_entity_id("sensor.power");
+  sensor.setup();
+
+  for (auto _ : state) {
+    for (int i = 0; i < kInnerIterations; i++) {
+      conn->on_home_assistant_state_response(msgs[i % kStateCount]);
+    }
+    benchmark::DoNotOptimize(sensor.state);
+  }
+  state.SetItemsProcessed(state.iterations() * kInnerIterations);
+}
+BENCHMARK(HomeassistantSensor_StateResponse_Unavailable);
+
+}  // namespace esphome::homeassistant::benchmarks
+
+#endif  // USE_API_PLAINTEXT && USE_API_HOMEASSISTANT_STATES && USE_SENSOR

tests/benchmarks/components/homeassistant/benchmark.yaml

@@ -0,0 +1,3 @@
+# The homeassistant platforms subscribe through the API server.
+api:
+sensor:

tests/benchmarks/components/homeassistant/sensor/__init__.py

@@ -0,0 +1,13 @@
+import esphome.codegen as cg
+from esphome.types import ConfigType
+from tests.testing_helpers import ComponentManifestOverride
+
+
+def override_manifest(manifest: ComponentManifestOverride) -> None:
+    # In production the platform's to_code emits this define; the host build
+    # suppresses that to_code, and the API server needs the define for the
+    # state subscription path the benchmarks drive.
+    async def to_code(config: ConfigType) -> None:
+        cg.add_define("USE_API_HOMEASSISTANT_STATES")
+
+    manifest.to_code = to_code

tests/component_tests/ble_client/test_validation.py

@@ -19,9 +19,21 @@ from esphome.const import (
     CONF_NOTIFY,
     CONF_SERVICE_UUID,
     CONF_TYPE,
+    PlatformFramework,
 )
+from esphome.core import CORE
 from esphome.types import ConfigType
 
+from ..types import SetCoreConfigCallable
+
+
+@pytest.fixture(autouse=True)
+def esp32_platform(set_core_config: SetCoreConfigCallable) -> None:
+    # The raw-gattc node family gates through BLE_CLIENT_SCHEMA's
+    # _legacy_engine_only choke point; these schema tests exercise the esp32 arm.
+    set_core_config(PlatformFramework.ESP32_IDF)
+
+
 DESCRIPTOR_CONFIG: ConfigType = {
     CONF_NAME: "test",
     CONF_SERVICE_UUID: "6E400001-B5A3-F393-E0A9-E50E24DCCA9E",
@@ -84,3 +96,72 @@ def test_on_notify_implies_notify() -> None:
 def test_notify_unchanged_without_on_notify() -> None:
     config: ConfigType = {CONF_NOTIFY: False}
     assert notify_from_on_notify(config)[CONF_NOTIFY] is False
+
+
+def test_legacy_node_choke_point_rejects_other_platforms(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    from esphome.components import ble_client
+    from esphome.core import ID
+
+    set_core_config(PlatformFramework.RP2_ARDUINO)
+    with pytest.raises(cv.Invalid, match="not been migrated"):
+        ble_client._legacy_engine_only(ID("x"))
+    # Through the public schema too, so removing the cv.All wiring fails here.
+    with pytest.raises(cv.Invalid, match="not been migrated"):
+        ble_client.BLE_CLIENT_SCHEMA({})
+
+
+def test_neutral_arm_rejects_esp32_only_keys(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    # Pins the schema split's rejection side: the legacy-only keys must not
+    # leak into the neutral arm. The hub is registered so the extra key is
+    # the only error - without it the missing-tracker error would satisfy
+    # the raises vacuously.
+    from esphome.components import ble_client, ble_device_base
+
+    set_core_config(PlatformFramework.RP2_ARDUINO)
+    ble_device_base.register_hub_provider("rp2_ble_tracker")
+    CORE.loaded_integrations.add("rp2_ble_tracker")
+    for key in ("name", "on_passkey_request", "on_passkey_notification"):
+        with pytest.raises(cv.Invalid, match="extra keys not allowed"):
+            ble_client.CONFIG_SCHEMA({"mac_address": "AA:BB:CC:DD:EE:FF", key: "x"})
+
+
+def test_security_actions_reject_platforms_without_the_feature(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    from esphome.components import ble_client
+
+    set_core_config(PlatformFramework.RP2_ARDUINO)
+    for schema in (
+        ble_client.BLE_PASSKEY_REPLY_ACTION_SCHEMA,
+        ble_client.BLE_NUMERIC_COMPARISON_REPLY_ACTION_SCHEMA,
+        ble_client.BLE_REMOVE_BOND_ACTION_SCHEMA,
+    ):
+        with pytest.raises(cv.Invalid, match="'security' feature, which rp2"):
+            schema({})
+
+
+def test_node_schema_passes_on_every_gatt_platform(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    # The neutral node schema carries no engine gate: raw_gattc components
+    # stay choked, gatt_node components validate wherever ble_client does.
+    from esphome.components import ble_client
+
+    for pf in (PlatformFramework.ESP32_IDF, PlatformFramework.RP2_ARDUINO):
+        set_core_config(pf)
+        assert ble_client.NODE_BLE_CLIENT_SCHEMA({})
+
+
+def test_feature_error_names_the_available_features(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    from esphome.components import ble_client
+    from esphome.core import ID
+
+    set_core_config(PlatformFramework.RP2_ARDUINO)
+    with pytest.raises(cv.Invalid, match="provides: gatt_node"):
+        ble_client._legacy_engine_only(ID("x"))

tests/component_tests/bluetooth_connection/test_slot_ledger.py

@@ -0,0 +1,79 @@
+"""Tests for the cross-component GATT slot ledger."""
+
+import pytest
+
+from esphome import config_validation as cv
+from esphome.components import (
+    ble_client,
+    ble_device_base,
+    bluetooth_connection,
+    bluetooth_proxy,
+    rp2040_ble,
+)
+from esphome.const import CONF_MAC_ADDRESS, PlatformFramework
+from esphome.core import CORE
+
+from ..types import SetCoreConfigCallable
+
+
+def test_gatt_slot_ledger_rejects_overcommit_on_rp2(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    # rp2 owns its budget: the stack's validation reports the overcommit and
+    # the neutral cap check stays silent (one message per misconfiguration).
+    set_core_config(PlatformFramework.RP2_ARDUINO)
+    bluetooth_connection.consume_gatt_slot("bluetooth_proxy", 3)({})
+    bluetooth_connection.consume_gatt_slot("ble_client")({})
+    bluetooth_connection.FINAL_VALIDATE_SCHEMA({})
+    with pytest.raises(cv.Invalid, match="rp2 maximum is 3"):
+        rp2040_ble.validate_connection_slots()
+
+
+def test_gatt_slot_ledger_skipped_in_testing_mode(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    # Grouped component builds merge fixtures past the cap; the check defers
+    # to testing mode like esp32_ble.validate_connection_slots.
+    set_core_config(PlatformFramework.RP2_ARDUINO)
+    bluetooth_connection.consume_gatt_slot("bluetooth_proxy", 3)({})
+    bluetooth_connection.consume_gatt_slot("ble_client")({})
+    CORE.testing_mode = True
+    try:
+        bluetooth_connection.FINAL_VALIDATE_SCHEMA({})
+        rp2040_ble.validate_connection_slots()
+    finally:
+        CORE.testing_mode = False
+
+
+def test_real_validators_charge_the_ledger_on_rp2(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    # End to end through the component CONFIG_SCHEMAs (no hand charges):
+    # removing either consumer's consume_gatt_slot call fails this test.
+    set_core_config(PlatformFramework.RP2_ARDUINO)
+    ble_device_base.register_hub_provider("rp2_ble_tracker")
+    CORE.loaded_integrations.add("rp2_ble_tracker")
+    bluetooth_proxy.CONFIG_SCHEMA({})
+    ble_client.CONFIG_SCHEMA({CONF_MAC_ADDRESS: "AA:BB:CC:DD:EE:FF"})
+    # The proxy defaults to 3 slots on rp2; ble_client's claim overcommits
+    # and rp2's own budget names every claimant.
+    with pytest.raises(
+        cv.Invalid,
+        match="Components: bluetooth_proxy, bluetooth_proxy, bluetooth_proxy, "
+        "ble_client",
+    ):
+        rp2040_ble.validate_connection_slots()
+
+
+def test_neutral_cap_check_guards_future_hub_platforms(
+    set_core_config: SetCoreConfigCallable, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    # Both current platforms defer to their stack budgets; pin the message
+    # and boundary of the branch a future budget-less hub platform takes.
+    set_core_config(PlatformFramework.RP2_ARDUINO)
+    monkeypatch.setattr(bluetooth_connection, "_STACK_BUDGETS", {})
+    bluetooth_connection.consume_gatt_slot("bluetooth_proxy", 3)({})
+    bluetooth_connection.FINAL_VALIDATE_SCHEMA({})
+    bluetooth_connection.consume_gatt_slot("ble_client")({})
+    with pytest.raises(cv.Invalid, match="supports at most 3 GATT client connection"):
+        bluetooth_connection.FINAL_VALIDATE_SCHEMA({})

tests/component_tests/bluetooth_proxy/test_platform_gates.py

@@ -186,6 +186,18 @@ def test_rp2_rejects_esp32_only_keys_by_name(
         bluetooth_proxy.CONFIG_SCHEMA({"connections": [{}]})
 
 
+def test_esp32_explicit_connections_claim_gatt_slots(
+    set_core_config: SetCoreConfigCallable,
+) -> None:
+    # Explicit `connections:` entries must charge the slot ledger like the
+    # generated ones; dev historically let them evade the budget.
+    set_core_config(PlatformFramework.ESP32_IDF)
+    bluetooth_proxy.CONFIG_SCHEMA({"active": True, "connections": [{}, {}]})
+    # Exact match (one entry per slot): catches a missed charge and a
+    # double charge alike.
+    assert bluetooth_connection._get_data().slot_consumers == ["bluetooth_proxy"] * 2
+
+
 def test_hub_source_filter_covers_every_hub_platform() -> None:
     # bluetooth_connection cannot import this module to derive the hub.cpp
     # framework set, so pin it here: a platform admitted to the proxy but
@@ -229,6 +241,12 @@ def test_every_registered_hub_platform_has_a_schema_arm() -> None:
     # Hub platforms must also be in the backend registry the shared codegen
     # helpers dispatch on.
     assert registered <= set(bluetooth_connection._PLATFORM_BACKENDS)
+    # Every non-esp32 backend platform must carry a slot cap: without one the
+    # ledger's FINAL_VALIDATE accepts unlimited claims silently (esp32's cap
+    # is the controller budget in esp32_ble).
+    assert set(bluetooth_connection._PLATFORM_BACKENDS) - {"esp32"} <= set(
+        bluetooth_connection.HUB_MAX_CONNECTIONS
+    )
     # The outer walkable schema's bound must stay the loosest platform cap.
     assert (
         max(bluetooth_connection.HUB_MAX_CONNECTIONS.values())

tests/component_tests/emontx/test_lock_on_reboot.py

@@ -0,0 +1,38 @@
+"""Tests for the emontx lock_on_reboot option: auto (the default), true or false."""
+
+import pytest
+
+from esphome import config_validation as cv
+from esphome.components.emontx import (
+    CONF_LOCK_ON_REBOOT,
+    CONFIG_SCHEMA,
+    LOCK_ON_REBOOT_AUTO,
+)
+
+
+def _lock_key() -> cv.Optional:
+    return next(key for key in CONFIG_SCHEMA.schema if key == CONF_LOCK_ON_REBOOT)
+
+
+def test_default_is_auto() -> None:
+    assert _lock_key().default() == LOCK_ON_REBOOT_AUTO
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [
+        ("auto", LOCK_ON_REBOOT_AUTO),
+        ("AUTO", LOCK_ON_REBOOT_AUTO),
+        (True, True),
+        (False, False),
+        ("yes", True),
+        ("off", False),
+    ],
+)
+def test_accepted_values(value: object, expected: object) -> None:
+    assert CONFIG_SCHEMA.schema[_lock_key()](value) == expected
+
+
+def test_other_values_rejected() -> None:
+    with pytest.raises(cv.Invalid):
+        CONFIG_SCHEMA.schema[_lock_key()]("sometimes")

tests/component_tests/lvgl/config/list_outside_block_test.yaml

@@ -30,7 +30,7 @@ display:
 
 image:
   - platform: file
-    file: mdi:battery
+    file: image.png
     id: my_image
     resize: 8x8
     type: binary

tests/component_tests/thermostat/config/cooling_timer_without_action.yaml

@@ -0,0 +1,27 @@
+---
+esphome:
+  name: test
+
+logger:
+
+esp32:
+  board: esp32dev
+
+sensor:
+  - platform: template
+    id: temp_sensor
+    lambda: return 21.0;
+
+climate:
+  - platform: thermostat
+    id: heater
+    name: Heater
+    sensor: temp_sensor
+    min_idle_time: 30s
+    min_heating_off_time: 300s
+    min_heating_run_time: 300s
+    min_cooling_off_time: 300s
+    heat_action:
+      - logger.log: heat
+    idle_action:
+      - logger.log: idle