esphome 2025.9.2__py3-none-any.whl → 2025.10.0b1__py3-none-any.whl

esphome/components/esp32/boards.py

@@ -1504,6 +1504,10 @@ BOARDS = {
         "name": "BPI-Bit",
         "variant": VARIANT_ESP32,
     },
+    "bpi-centi-s3": {
+        "name": "BPI-Centi-S3",
+        "variant": VARIANT_ESP32S3,
+    },
     "bpi_leaf_s3": {
         "name": "BPI-Leaf-S3",
         "variant": VARIANT_ESP32S3,
@@ -1664,10 +1668,46 @@ BOARDS = {
         "name": "Espressif ESP32-S3-DevKitC-1-N8 (8 MB QD, No PSRAM)",
         "variant": VARIANT_ESP32S3,
     },
+    "esp32-s3-devkitc-1-n32r8v": {
+        "name": "Espressif ESP32-S3-DevKitC-1-N32R8V (32 MB Flash Octal, 8 MB PSRAM Octal)",
+        "variant": VARIANT_ESP32S3,
+    },
+    "esp32-s3-devkitc1-n16r16": {
+        "name": "Espressif ESP32-S3-DevKitC-1-N16R16V (16 MB Flash Quad, 16 MB PSRAM Octal)",
+        "variant": VARIANT_ESP32S3,
+    },
+    "esp32-s3-devkitc1-n16r2": {
+        "name": "Espressif ESP32-S3-DevKitC-1-N16R2 (16 MB Flash Quad, 2 MB PSRAM Quad)",
+        "variant": VARIANT_ESP32S3,
+    },
+    "esp32-s3-devkitc1-n16r8": {
+        "name": "Espressif ESP32-S3-DevKitC-1-N16R8V (16 MB Flash Quad, 8 MB PSRAM Octal)",
+        "variant": VARIANT_ESP32S3,
+    },
+    "esp32-s3-devkitc1-n4r2": {
+        "name": "Espressif ESP32-S3-DevKitC-1-N4R2 (4 MB Flash Quad, 2 MB PSRAM Quad)",
+        "variant": VARIANT_ESP32S3,
+    },
+    "esp32-s3-devkitc1-n4r8": {
+        "name": "Espressif ESP32-S3-DevKitC-1-N4R8 (4 MB Flash Quad, 8 MB PSRAM Octal)",
+        "variant": VARIANT_ESP32S3,
+    },
+    "esp32-s3-devkitc1-n8r2": {
+        "name": "Espressif ESP32-S3-DevKitC-1-N8R2 (8 MB Flash Quad, 2 MB PSRAM quad)",
+        "variant": VARIANT_ESP32S3,
+    },
+    "esp32-s3-devkitc1-n8r8": {
+        "name": "Espressif ESP32-S3-DevKitC-1-N8R8 (8 MB Flash Quad, 8 MB PSRAM Octal)",
+        "variant": VARIANT_ESP32S3,
+    },
     "esp32-s3-devkitm-1": {
         "name": "Espressif ESP32-S3-DevKitM-1",
         "variant": VARIANT_ESP32S3,
     },
+    "esp32-s3-fh4r2": {
+        "name": "Espressif ESP32-S3-FH4R2 (4 MB QD, 2MB PSRAM)",
+        "variant": VARIANT_ESP32S3,
+    },
     "esp32-solo1": {
         "name": "Espressif Generic ESP32-solo1 4M Flash",
         "variant": VARIANT_ESP32,
@@ -1764,6 +1804,10 @@ BOARDS = {
         "name": "Franzininho WiFi MSC",
         "variant": VARIANT_ESP32S2,
     },
+    "freenove-esp32-s3-n8r8": {
+        "name": "Freenove ESP32-S3 WROOM N8R8 (8MB Flash / 8MB PSRAM)",
+        "variant": VARIANT_ESP32S3,
+    },
     "freenove_esp32_s3_wroom": {
         "name": "Freenove ESP32-S3 WROOM N8R8 (8MB Flash / 8MB PSRAM)",
         "variant": VARIANT_ESP32S3,
@@ -1964,6 +2008,10 @@ BOARDS = {
         "name": "M5Stack AtomS3",
         "variant": VARIANT_ESP32S3,
     },
+    "m5stack-atoms3u": {
+        "name": "M5Stack AtomS3U",
+        "variant": VARIANT_ESP32S3,
+    },
     "m5stack-core-esp32": {
         "name": "M5Stack Core ESP32",
         "variant": VARIANT_ESP32,
@@ -2084,6 +2132,10 @@ BOARDS = {
         "name": "Ai-Thinker NodeMCU-32S2 (ESP-12K)",
         "variant": VARIANT_ESP32S2,
     },
+    "nologo_esp32c3_super_mini": {
+        "name": "Nologo ESP32C3 SuperMini",
+        "variant": VARIANT_ESP32C3,
+    },
     "nscreen-32": {
         "name": "YeaCreate NSCREEN-32",
         "variant": VARIANT_ESP32,
@@ -2192,6 +2244,10 @@ BOARDS = {
         "name": "SparkFun LoRa Gateway 1-Channel",
         "variant": VARIANT_ESP32,
     },
+    "sparkfun_pro_micro_esp32c3": {
+        "name": "SparkFun Pro Micro ESP32-C3",
+        "variant": VARIANT_ESP32C3,
+    },
     "sparkfun_qwiic_pocket_esp32c6": {
         "name": "SparkFun ESP32-C6 Qwiic Pocket",
         "variant": VARIANT_ESP32C6,
@@ -2256,6 +2312,14 @@ BOARDS = {
         "name": "Turta IoT Node",
         "variant": VARIANT_ESP32,
     },
+    "um_bling": {
+        "name": "Unexpected Maker BLING!",
+        "variant": VARIANT_ESP32S3,
+    },
+    "um_edges3_d": {
+        "name": "Unexpected Maker EDGES3[D]",
+        "variant": VARIANT_ESP32S3,
+    },
     "um_feathers2": {
         "name": "Unexpected Maker FeatherS2",
         "variant": VARIANT_ESP32S2,
@@ -2268,10 +2332,18 @@ BOARDS = {
         "name": "Unexpected Maker FeatherS3",
         "variant": VARIANT_ESP32S3,
     },
+    "um_feathers3_neo": {
+        "name": "Unexpected Maker FeatherS3 Neo",
+        "variant": VARIANT_ESP32S3,
+    },
     "um_nanos3": {
         "name": "Unexpected Maker NanoS3",
         "variant": VARIANT_ESP32S3,
     },
+    "um_omgs3": {
+        "name": "Unexpected Maker OMGS3",
+        "variant": VARIANT_ESP32S3,
+    },
     "um_pros3": {
         "name": "Unexpected Maker PROS3",
         "variant": VARIANT_ESP32S3,
@@ -2280,6 +2352,14 @@ BOARDS = {
         "name": "Unexpected Maker RMP",
         "variant": VARIANT_ESP32S2,
     },
+    "um_squixl": {
+        "name": "Unexpected Maker SQUiXL",
+        "variant": VARIANT_ESP32S3,
+    },
+    "um_tinyc6": {
+        "name": "Unexpected Maker TinyC6",
+        "variant": VARIANT_ESP32C6,
+    },
     "um_tinys2": {
         "name": "Unexpected Maker TinyS2",
         "variant": VARIANT_ESP32S2,
@@ -2401,3 +2481,4 @@ BOARDS = {
         "variant": VARIANT_ESP32S3,
     },
 }
+# DO NOT ADD ANYTHING BELOW THIS LINE

esphome/components/esp32/preferences.cpp

@@ -17,7 +17,14 @@ static const char *const TAG = "esp32.preferences";
 
 struct NVSData {
   std::string key;
-  std::vector<uint8_t> data;
+  std::unique_ptr<uint8_t[]> data;
+  size_t len;
+
+  void set_data(const uint8_t *src, size_t size) {
+    data = std::make_unique<uint8_t[]>(size);
+    memcpy(data.get(), src, size);
+    len = size;
+  }
 };
 
 static std::vector<NVSData> s_pending_save;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -30,26 +37,26 @@ class ESP32PreferenceBackend : public ESPPreferenceBackend {
     // try find in pending saves and update that
     for (auto &obj : s_pending_save) {
       if (obj.key == key) {
-        obj.data.assign(data, data + len);
+        obj.set_data(data, len);
         return true;
       }
     }
     NVSData save{};
     save.key = key;
-    save.data.assign(data, data + len);
-    s_pending_save.emplace_back(save);
-    ESP_LOGVV(TAG, "s_pending_save: key: %s, len: %d", key.c_str(), len);
+    save.set_data(data, len);
+    s_pending_save.emplace_back(std::move(save));
+    ESP_LOGVV(TAG, "s_pending_save: key: %s, len: %zu", key.c_str(), len);
     return true;
   }
   bool load(uint8_t *data, size_t len) override {
     // try find in pending saves and load from that
     for (auto &obj : s_pending_save) {
       if (obj.key == key) {
-        if (obj.data.size() != len) {
+        if (obj.len != len) {
           // size mismatch
           return false;
         }
-        memcpy(data, obj.data.data(), len);
+        memcpy(data, obj.data.get(), len);
         return true;
       }
     }
@@ -61,7 +68,7 @@ class ESP32PreferenceBackend : public ESPPreferenceBackend {
       return false;
     }
     if (actual_len != len) {
-      ESP_LOGVV(TAG, "NVS length does not match (%u!=%u)", actual_len, len);
+      ESP_LOGVV(TAG, "NVS length does not match (%zu!=%zu)", actual_len, len);
       return false;
     }
     err = nvs_get_blob(nvs_handle, key.c_str(), data, &len);
@@ -69,7 +76,7 @@ class ESP32PreferenceBackend : public ESPPreferenceBackend {
       ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", key.c_str(), esp_err_to_name(err));
       return false;
     } else {
-      ESP_LOGVV(TAG, "nvs_get_blob: key: %s, len: %d", key.c_str(), len);
+      ESP_LOGVV(TAG, "nvs_get_blob: key: %s, len: %zu", key.c_str(), len);
     }
     return true;
   }
@@ -112,7 +119,7 @@ class ESP32Preferences : public ESPPreferences {
     if (s_pending_save.empty())
       return true;
 
-    ESP_LOGV(TAG, "Saving %d items...", s_pending_save.size());
+    ESP_LOGV(TAG, "Saving %zu items...", s_pending_save.size());
     // goal try write all pending saves even if one fails
     int cached = 0, written = 0, failed = 0;
     esp_err_t last_err = ESP_OK;
@@ -123,11 +130,10 @@ class ESP32Preferences : public ESPPreferences {
       const auto &save = s_pending_save[i];
       ESP_LOGVV(TAG, "Checking if NVS data %s has changed", save.key.c_str());
       if (is_changed(nvs_handle, save)) {
-        esp_err_t err = nvs_set_blob(nvs_handle, save.key.c_str(), save.data.data(), save.data.size());
-        ESP_LOGV(TAG, "sync: key: %s, len: %d", save.key.c_str(), save.data.size());
+        esp_err_t err = nvs_set_blob(nvs_handle, save.key.c_str(), save.data.get(), save.len);
+        ESP_LOGV(TAG, "sync: key: %s, len: %zu", save.key.c_str(), save.len);
         if (err != 0) {
-          ESP_LOGV(TAG, "nvs_set_blob('%s', len=%u) failed: %s", save.key.c_str(), save.data.size(),
-                   esp_err_to_name(err));
+          ESP_LOGV(TAG, "nvs_set_blob('%s', len=%zu) failed: %s", save.key.c_str(), save.len, esp_err_to_name(err));
           failed++;
           last_err = err;
           last_key = save.key;
@@ -135,7 +141,7 @@ class ESP32Preferences : public ESPPreferences {
         }
         written++;
       } else {
-        ESP_LOGV(TAG, "NVS data not changed skipping %s  len=%u", save.key.c_str(), save.data.size());
+        ESP_LOGV(TAG, "NVS data not changed skipping %s  len=%zu", save.key.c_str(), save.len);
         cached++;
       }
       s_pending_save.erase(s_pending_save.begin() + i);
@@ -164,7 +170,7 @@ class ESP32Preferences : public ESPPreferences {
       return true;
     }
     // Check size first before allocating memory
-    if (actual_len != to_save.data.size()) {
+    if (actual_len != to_save.len) {
       return true;
     }
     auto stored_data = std::make_unique<uint8_t[]>(actual_len);
@@ -173,7 +179,7 @@ class ESP32Preferences : public ESPPreferences {
       ESP_LOGV(TAG, "nvs_get_blob('%s') failed: %s", to_save.key.c_str(), esp_err_to_name(err));
       return true;
     }
-    return memcmp(to_save.data.data(), stored_data.get(), to_save.data.size()) != 0;
+    return memcmp(to_save.data.get(), stored_data.get(), to_save.len) != 0;
   }
 
   bool reset() override {

esphome/components/esp32_ble/__init__.py

@@ -1,5 +1,8 @@
+from collections.abc import Callable, MutableMapping
 from enum import Enum
+import logging
 import re
+from typing import Any
 
 from esphome import automation
 import esphome.codegen as cg
@@ -9,6 +12,7 @@ from esphome.const import (
     CONF_ENABLE_ON_BOOT,
     CONF_ESPHOME,
     CONF_ID,
+    CONF_MAX_CONNECTIONS,
     CONF_NAME,
     CONF_NAME_ADD_MAC_SUFFIX,
 )
@@ -19,6 +23,8 @@ DEPENDENCIES = ["esp32"]
 CODEOWNERS = ["@jesserockz", "@Rapsssito", "@bdraco"]
 DOMAIN = "esp32_ble"
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class BTLoggers(Enum):
     """Bluetooth logger categories available in ESP-IDF.
@@ -127,6 +133,28 @@ CONF_DISABLE_BT_LOGS = "disable_bt_logs"
 CONF_CONNECTION_TIMEOUT = "connection_timeout"
 CONF_MAX_NOTIFICATIONS = "max_notifications"
 
+# BLE connection limits
+# ESP-IDF CONFIG_BT_ACL_CONNECTIONS has range 1-9, default 4
+# Total instances: 10 (ADV + SCAN + connections)
+# - ADV only: up to 9 connections
+# - SCAN only: up to 9 connections
+# - ADV + SCAN: up to 8 connections
+DEFAULT_MAX_CONNECTIONS = 3
+IDF_MAX_CONNECTIONS = 9
+
+# Connection slot tracking keys
+KEY_ESP32_BLE = "esp32_ble"
+KEY_USED_CONNECTION_SLOTS = "used_connection_slots"
+
+# Export for use by other components (bluetooth_proxy, etc.)
+__all__ = [
+    "DEFAULT_MAX_CONNECTIONS",
+    "IDF_MAX_CONNECTIONS",
+    "KEY_ESP32_BLE",
+    "KEY_USED_CONNECTION_SLOTS",
+    "consume_connection_slots",
+]
+
 NO_BLUETOOTH_VARIANTS = [const.VARIANT_ESP32S2]
 
 esp32_ble_ns = cg.esphome_ns.namespace("esp32_ble")
@@ -174,19 +202,18 @@ CONFIG_SCHEMA = cv.Schema(
         cv.Optional(
             CONF_ADVERTISING_CYCLE_TIME, default="10s"
         ): cv.positive_time_period_milliseconds,
-        cv.SplitDefault(CONF_DISABLE_BT_LOGS, esp32_idf=True): cv.All(
-            cv.only_with_esp_idf, cv.boolean
-        ),
-        cv.SplitDefault(CONF_CONNECTION_TIMEOUT, esp32_idf="20s"): cv.All(
-            cv.only_with_esp_idf,
+        cv.Optional(CONF_DISABLE_BT_LOGS, default=True): cv.boolean,
+        cv.Optional(CONF_CONNECTION_TIMEOUT, default="20s"): cv.All(
             cv.positive_time_period_seconds,
             cv.Range(min=TimePeriod(seconds=10), max=TimePeriod(seconds=180)),
         ),
-        cv.SplitDefault(CONF_MAX_NOTIFICATIONS, esp32_idf=12): cv.All(
-            cv.only_with_esp_idf,
+        cv.Optional(CONF_MAX_NOTIFICATIONS, default=12): cv.All(
             cv.positive_int,
             cv.Range(min=1, max=64),
         ),
+        cv.Optional(CONF_MAX_CONNECTIONS, default=DEFAULT_MAX_CONNECTIONS): cv.All(
+            cv.positive_int, cv.Range(min=1, max=IDF_MAX_CONNECTIONS)
+        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -234,6 +261,56 @@ def validate_variant(_):
         raise cv.Invalid(f"{variant} does not support Bluetooth")
 
 
+def consume_connection_slots(
+    value: int, consumer: str
+) -> Callable[[MutableMapping], MutableMapping]:
+    """Reserve BLE connection slots for a component.
+
+    Args:
+        value: Number of connection slots to reserve
+        consumer: Name of the component consuming the slots
+
+    Returns:
+        A validator function that records the slot usage
+    """
+
+    def _consume_connection_slots(config: MutableMapping) -> MutableMapping:
+        data: dict[str, Any] = CORE.data.setdefault(KEY_ESP32_BLE, {})
+        slots: list[str] = data.setdefault(KEY_USED_CONNECTION_SLOTS, [])
+        slots.extend([consumer] * value)
+        return config
+
+    return _consume_connection_slots
+
+
+def validate_connection_slots(max_connections: int) -> None:
+    """Validate that BLE connection slots don't exceed the configured maximum."""
+    ble_data = CORE.data.get(KEY_ESP32_BLE, {})
+    used_slots = ble_data.get(KEY_USED_CONNECTION_SLOTS, [])
+    num_used = len(used_slots)
+
+    if num_used <= max_connections:
+        return
+
+    slot_users = ", ".join(used_slots)
+
+    if num_used > IDF_MAX_CONNECTIONS:
+        raise cv.Invalid(
+            f"BLE components require {num_used} connection slots but maximum is {IDF_MAX_CONNECTIONS}. "
+            f"Reduce the number of BLE clients. Components: {slot_users}"
+        )
+
+    _LOGGER.warning(
+        "BLE components require %d connection slot(s) but only %d configured. "
+        "Please set 'max_connections: %d' in the 'esp32_ble' component. "
+        "Components: %s",
+        num_used,
+        max_connections,
+        num_used,
+        slot_users,
+    )
+
+
 def final_validation(config):
     validate_variant(config)
     if (name := config.get(CONF_NAME)) is not None:
@@ -246,6 +323,43 @@ def final_validation(config):
                 f"Name '{name}' is too long, maximum length is {max_length} characters"
             )
 
+    # Set GATT Client/Server sdkconfig options based on which components are loaded
+    full_config = fv.full_config.get()
+
+    # Validate connection slots usage
+    max_connections = config.get(CONF_MAX_CONNECTIONS, DEFAULT_MAX_CONNECTIONS)
+    validate_connection_slots(max_connections)
+
+    # Check if BLE Server is needed
+    has_ble_server = "esp32_ble_server" in full_config
+    add_idf_sdkconfig_option("CONFIG_BT_GATTS_ENABLE", has_ble_server)
+
+    # Check if BLE Client is needed (via esp32_ble_tracker or esp32_ble_client)
+    has_ble_client = (
+        "esp32_ble_tracker" in full_config or "esp32_ble_client" in full_config
+    )
+    add_idf_sdkconfig_option("CONFIG_BT_GATTC_ENABLE", has_ble_client)
+
+    # Handle max_connections: check for deprecated location in esp32_ble_tracker
+    max_connections = config.get(CONF_MAX_CONNECTIONS, DEFAULT_MAX_CONNECTIONS)
+
+    # Use value from tracker if esp32_ble doesn't have it explicitly set (backward compat)
+    if "esp32_ble_tracker" in full_config:
+        tracker_config = full_config["esp32_ble_tracker"]
+        if "max_connections" in tracker_config and CONF_MAX_CONNECTIONS not in config:
+            max_connections = tracker_config["max_connections"]
+
+    # Set CONFIG_BT_ACL_CONNECTIONS to the maximum connections needed + 1 for ADV/SCAN
+    # This is the Bluedroid host stack total instance limit (range 1-9, default 4)
+    # Total instances = ADV/SCAN (1) + connection slots (max_connections)
+    # Shared between client (tracker/ble_client) and server
+    add_idf_sdkconfig_option("CONFIG_BT_ACL_CONNECTIONS", max_connections + 1)
+
+    # Set controller-specific max connections for ESP32 (classic)
+    # CONFIG_BTDM_CTRL_BLE_MAX_CONN is ESP32-specific controller limit (just connections, not ADV/SCAN)
+    # For newer chips (C3/S3/etc), different configs are used automatically
+    add_idf_sdkconfig_option("CONFIG_BTDM_CTRL_BLE_MAX_CONN", max_connections)
+
     return config
 
 
@@ -261,43 +375,44 @@ async def to_code(config):
         cg.add(var.set_name(name))
     await cg.register_component(var, config)
 
-    if CORE.using_esp_idf:
-        add_idf_sdkconfig_option("CONFIG_BT_ENABLED", True)
-        add_idf_sdkconfig_option("CONFIG_BT_BLE_42_FEATURES_SUPPORTED", True)
-
-        # Register the core BLE loggers that are always needed
-        register_bt_logger(BTLoggers.GAP, BTLoggers.BTM, BTLoggers.HCI)
-
-        # Apply logger settings if log disabling is enabled
-        if config.get(CONF_DISABLE_BT_LOGS, False):
-            # Disable all Bluetooth loggers that are not required
-            for logger in BTLoggers:
-                if logger not in _required_loggers:
-                    add_idf_sdkconfig_option(f"{logger.value}_NONE", True)
-
-        # Set BLE connection establishment timeout to match aioesphomeapi/bleak-retry-connector
-        # Default is 20 seconds instead of ESP-IDF's 30 seconds. Because there is no way to
-        # cancel a BLE connection in progress, when aioesphomeapi times out at 20 seconds,
-        # the connection slot remains occupied for the remaining time, preventing new connection
-        # attempts and wasting valuable connection slots.
-        if CONF_CONNECTION_TIMEOUT in config:
-            timeout_seconds = int(config[CONF_CONNECTION_TIMEOUT].total_seconds)
-            add_idf_sdkconfig_option(
-                "CONFIG_BT_BLE_ESTAB_LINK_CONN_TOUT", timeout_seconds
-            )
-            # Increase GATT client connection retry count for problematic devices
-            # Default in ESP-IDF is 3, we increase to 10 for better reliability with
-            # low-power/timing-sensitive devices
-            add_idf_sdkconfig_option("CONFIG_BT_GATTC_CONNECT_RETRY_COUNT", 10)
-
-        # Set the maximum number of notification registrations
-        # This controls how many BLE characteristics can have notifications enabled
-        # across all connections for a single GATT client interface
-        # https://github.com/esphome/issues/issues/6808
-        if CONF_MAX_NOTIFICATIONS in config:
-            add_idf_sdkconfig_option(
-                "CONFIG_BT_GATTC_NOTIF_REG_MAX", config[CONF_MAX_NOTIFICATIONS]
-            )
+    # Define max connections for use in C++ code (e.g., ble_server.h)
+    max_connections = config.get(CONF_MAX_CONNECTIONS, DEFAULT_MAX_CONNECTIONS)
+    cg.add_define("USE_ESP32_BLE_MAX_CONNECTIONS", max_connections)
+
+    add_idf_sdkconfig_option("CONFIG_BT_ENABLED", True)
+    add_idf_sdkconfig_option("CONFIG_BT_BLE_42_FEATURES_SUPPORTED", True)
+
+    # Register the core BLE loggers that are always needed
+    register_bt_logger(BTLoggers.GAP, BTLoggers.BTM, BTLoggers.HCI)
+
+    # Apply logger settings if log disabling is enabled
+    if config.get(CONF_DISABLE_BT_LOGS, False):
+        # Disable all Bluetooth loggers that are not required
+        for logger in BTLoggers:
+            if logger not in _required_loggers:
+                add_idf_sdkconfig_option(f"{logger.value}_NONE", True)
+
+    # Set BLE connection establishment timeout to match aioesphomeapi/bleak-retry-connector
+    # Default is 20 seconds instead of ESP-IDF's 30 seconds. Because there is no way to
+    # cancel a BLE connection in progress, when aioesphomeapi times out at 20 seconds,
+    # the connection slot remains occupied for the remaining time, preventing new connection
+    # attempts and wasting valuable connection slots.
+    if CONF_CONNECTION_TIMEOUT in config:
+        timeout_seconds = int(config[CONF_CONNECTION_TIMEOUT].total_seconds)
+        add_idf_sdkconfig_option("CONFIG_BT_BLE_ESTAB_LINK_CONN_TOUT", timeout_seconds)
+        # Increase GATT client connection retry count for problematic devices
+        # Default in ESP-IDF is 3, we increase to 10 for better reliability with
+        # low-power/timing-sensitive devices
+        add_idf_sdkconfig_option("CONFIG_BT_GATTC_CONNECT_RETRY_COUNT", 10)
+
+    # Set the maximum number of notification registrations
+    # This controls how many BLE characteristics can have notifications enabled
+    # across all connections for a single GATT client interface
+    # https://github.com/esphome/issues/issues/6808
+    if CONF_MAX_NOTIFICATIONS in config:
+        add_idf_sdkconfig_option(
+            "CONFIG_BT_GATTC_NOTIF_REG_MAX", config[CONF_MAX_NOTIFICATIONS]
+        )
 
     cg.add_define("USE_ESP32_BLE")
 

esphome/components/esp32_ble/ble.cpp

@@ -73,6 +73,28 @@ void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &dat
   this->advertising_start();
 }
 
+void ESP32BLE::advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name) {
+  // This method atomically updates both service data and device name inclusion in BLE advertising.
+  // When include_name is true, the device name is included in the advertising packet making it
+  // visible to passive BLE scanners. When false, the name is only visible in scan response
+  // (requires active scanning). This atomic operation ensures we only restart advertising once
+  // when changing both properties, avoiding the brief gap that would occur with separate calls.
+
+  this->advertising_init_();
+
+  if (include_name) {
+    // When including name, clear service data first to avoid packet overflow
+    this->advertising_->set_service_data(std::span<const uint8_t>{});
+    this->advertising_->set_include_name(true);
+  } else {
+    // When including service data, clear name first to avoid packet overflow
+    this->advertising_->set_include_name(false);
+    this->advertising_->set_service_data(data);
+  }
+
+  this->advertising_start();
+}
+
 void ESP32BLE::advertising_register_raw_advertisement_callback(std::function<void(bool)> &&callback) {
   this->advertising_init_();
   this->advertising_->register_raw_advertisement_callback(std::move(callback));
@@ -167,6 +189,7 @@ bool ESP32BLE::ble_setup_() {
     }
   }
 
+#ifdef USE_ESP32_BLE_SERVER
   if (!this->gatts_event_handlers_.empty()) {
     err = esp_ble_gatts_register_callback(ESP32BLE::gatts_event_handler);
     if (err != ESP_OK) {
@@ -174,7 +197,9 @@ bool ESP32BLE::ble_setup_() {
       return false;
     }
   }
+#endif
 
+#ifdef USE_ESP32_BLE_CLIENT
   if (!this->gattc_event_handlers_.empty()) {
     err = esp_ble_gattc_register_callback(ESP32BLE::gattc_event_handler);
     if (err != ESP_OK) {
@@ -182,20 +207,23 @@ bool ESP32BLE::ble_setup_() {
       return false;
     }
   }
+#endif
 
   std::string name;
   if (this->name_.has_value()) {
     name = this->name_.value();
     if (App.is_name_add_mac_suffix_enabled()) {
-      name += "-" + get_mac_address().substr(6);
+      name += "-";
+      name += get_mac_address().substr(6);
     }
   } else {
     name = App.get_name();
     if (name.length() > 20) {
       if (App.is_name_add_mac_suffix_enabled()) {
-        name.erase(name.begin() + 13, name.end() - 7);  // Remove characters between 13 and the mac address
+        // Keep first 13 chars and last 7 chars (MAC suffix), remove middle
+        name.erase(13, name.length() - 20);
       } else {
-        name = name.substr(0, 20);
+        name.resize(20);
       }
     }
   }
@@ -303,6 +331,7 @@ void ESP32BLE::loop() {
   BLEEvent *ble_event = this->ble_events_.pop();
   while (ble_event != nullptr) {
     switch (ble_event->type_) {
+#ifdef USE_ESP32_BLE_SERVER
       case BLEEvent::GATTS: {
         esp_gatts_cb_event_t event = ble_event->event_.gatts.gatts_event;
         esp_gatt_if_t gatts_if = ble_event->event_.gatts.gatts_if;
@@ -313,6 +342,8 @@ void ESP32BLE::loop() {
         }
         break;
       }
+#endif
+#ifdef USE_ESP32_BLE_CLIENT
       case BLEEvent::GATTC: {
         esp_gattc_cb_event_t event = ble_event->event_.gattc.gattc_event;
         esp_gatt_if_t gattc_if = ble_event->event_.gattc.gattc_if;
@@ -323,6 +354,7 @@ void ESP32BLE::loop() {
         }
         break;
       }
+#endif
       case BLEEvent::GAP: {
         esp_gap_ble_cb_event_t gap_event = ble_event->event_.gap.gap_event;
         switch (gap_event) {
@@ -416,13 +448,17 @@ void load_ble_event(BLEEvent *event, esp_gap_ble_cb_event_t e, esp_ble_gap_cb_pa
   event->load_gap_event(e, p);
 }
 
+#ifdef USE_ESP32_BLE_CLIENT
 void load_ble_event(BLEEvent *event, esp_gattc_cb_event_t e, esp_gatt_if_t i, esp_ble_gattc_cb_param_t *p) {
   event->load_gattc_event(e, i, p);
 }
+#endif
 
+#ifdef USE_ESP32_BLE_SERVER
 void load_ble_event(BLEEvent *event, esp_gatts_cb_event_t e, esp_gatt_if_t i, esp_ble_gatts_cb_param_t *p) {
   event->load_gatts_event(e, i, p);
 }
+#endif
 
 template<typename... Args> void enqueue_ble_event(Args... args) {
   // Allocate an event from the pool
@@ -443,8 +479,12 @@ template<typename... Args> void enqueue_ble_event(Args... args) {
 
 // Explicit template instantiations for the friend function
 template void enqueue_ble_event(esp_gap_ble_cb_event_t, esp_ble_gap_cb_param_t *);
+#ifdef USE_ESP32_BLE_SERVER
 template void enqueue_ble_event(esp_gatts_cb_event_t, esp_gatt_if_t, esp_ble_gatts_cb_param_t *);
+#endif
+#ifdef USE_ESP32_BLE_CLIENT
 template void enqueue_ble_event(esp_gattc_cb_event_t, esp_gatt_if_t, esp_ble_gattc_cb_param_t *);
+#endif
 
 void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
   switch (event) {
@@ -484,15 +524,19 @@ void ESP32BLE::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_pa
   ESP_LOGW(TAG, "Ignoring unexpected GAP event type: %d", event);
 }
 
+#ifdef USE_ESP32_BLE_SERVER
 void ESP32BLE::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if,
                                    esp_ble_gatts_cb_param_t *param) {
   enqueue_ble_event(event, gatts_if, param);
 }
+#endif
 
+#ifdef USE_ESP32_BLE_CLIENT
 void ESP32BLE::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
                                    esp_ble_gattc_cb_param_t *param) {
   enqueue_ble_event(event, gattc_if, param);
 }
+#endif
 
 float ESP32BLE::get_setup_priority() const { return setup_priority::BLUETOOTH; }