esphome 2025.6.3__py3-none-any.whl → 2025.7.0b2__py3-none-any.whl

esphome/components/esp32/__init__.py

@@ -4,7 +4,7 @@ import logging
 import os
 from pathlib import Path
 
-from esphome import git
+from esphome import yaml_util
 import esphome.codegen as cg
 import esphome.config_validation as cv
 from esphome.const import (
@@ -23,7 +23,6 @@ from esphome.const import (
     CONF_REFRESH,
     CONF_SOURCE,
     CONF_TYPE,
-    CONF_URL,
     CONF_VARIANT,
     CONF_VERSION,
     KEY_CORE,
@@ -32,14 +31,13 @@ from esphome.const import (
     KEY_TARGET_FRAMEWORK,
     KEY_TARGET_PLATFORM,
     PLATFORM_ESP32,
-    TYPE_GIT,
-    TYPE_LOCAL,
     __version__,
 )
 from esphome.core import CORE, HexInt, TimePeriod
 from esphome.cpp_generator import RawExpression
 import esphome.final_validate as fv
 from esphome.helpers import copy_file_if_changed, mkdir_p, write_file_if_changed
+from esphome.types import ConfigType
 
 from .boards import BOARDS
 from .const import (  # noqa
@@ -49,10 +47,8 @@ from .const import (  # noqa
     KEY_EXTRA_BUILD_FILES,
     KEY_PATH,
     KEY_REF,
-    KEY_REFRESH,
     KEY_REPO,
     KEY_SDKCONFIG_OPTIONS,
-    KEY_SUBMODULES,
     KEY_VARIANT,
     VARIANT_ESP32,
     VARIANT_ESP32C2,
@@ -132,6 +128,8 @@ def set_core_data(config):
         choices = CPU_FREQUENCIES[variant]
         if "160MHZ" in choices:
             cpu_frequency = "160MHZ"
+        elif "360MHZ" in choices:
+            cpu_frequency = "360MHZ"
         else:
             cpu_frequency = choices[-1]
         config[CONF_CPU_FREQUENCY] = cpu_frequency
@@ -191,7 +189,7 @@ def get_download_types(storage_json):
     ]
 
 
-def only_on_variant(*, supported=None, unsupported=None):
+def only_on_variant(*, supported=None, unsupported=None, msg_prefix="This feature"):
     """Config validator for features only available on some ESP32 variants."""
     if supported is not None and not isinstance(supported, list):
         supported = [supported]
@@ -202,11 +200,11 @@ def only_on_variant(*, supported=None, unsupported=None):
         variant = get_esp32_variant()
         if supported is not None and variant not in supported:
             raise cv.Invalid(
-                f"This feature is only available on {', '.join(supported)}"
+                f"{msg_prefix} is only available on {', '.join(supported)}"
             )
         if unsupported is not None and variant in unsupported:
             raise cv.Invalid(
-                f"This feature is not available on {', '.join(unsupported)}"
+                f"{msg_prefix} is not available on {', '.join(unsupported)}"
             )
         return obj
 
@@ -233,7 +231,7 @@ def add_idf_sdkconfig_option(name: str, value: SdkconfigValueType):
 def add_idf_component(
     *,
     name: str,
-    repo: str,
+    repo: str = None,
     ref: str = None,
     path: str = None,
     refresh: TimePeriod = None,
@@ -243,30 +241,27 @@ def add_idf_component(
     """Add an esp-idf component to the project."""
     if not CORE.using_esp_idf:
         raise ValueError("Not an esp-idf project")
-    if components is None:
-        components = []
-    if name not in CORE.data[KEY_ESP32][KEY_COMPONENTS]:
+    if not repo and not ref and not path:
+        raise ValueError("Requires at least one of repo, ref or path")
+    if refresh or submodules or components:
+        _LOGGER.warning(
+            "The refresh, components and submodules parameters in add_idf_component() are "
+            "deprecated and will be removed in ESPHome 2026.1. If you are seeing this, report "
+            "an issue to the external_component author and ask them to update it."
+        )
+    if components:
+        for comp in components:
+            CORE.data[KEY_ESP32][KEY_COMPONENTS][comp] = {
+                KEY_REPO: repo,
+                KEY_REF: ref,
+                KEY_PATH: f"{path}/{comp}" if path else comp,
+            }
+    else:
         CORE.data[KEY_ESP32][KEY_COMPONENTS][name] = {
             KEY_REPO: repo,
             KEY_REF: ref,
             KEY_PATH: path,
-            KEY_REFRESH: refresh,
-            KEY_COMPONENTS: components,
-            KEY_SUBMODULES: submodules,
         }
-    else:
-        component_config = CORE.data[KEY_ESP32][KEY_COMPONENTS][name]
-        if components is not None:
-            component_config[KEY_COMPONENTS] = list(
-                set(component_config[KEY_COMPONENTS] + components)
-            )
-        if submodules is not None:
-            if component_config[KEY_SUBMODULES] is None:
-                component_config[KEY_SUBMODULES] = submodules
-            else:
-                component_config[KEY_SUBMODULES] = list(
-                    set(component_config[KEY_SUBMODULES] + submodules)
-                )
 
 
 def add_extra_script(stage: str, filename: str, path: str):
@@ -289,11 +284,8 @@ def add_extra_build_file(filename: str, path: str) -> bool:
 
 def _format_framework_arduino_version(ver: cv.Version) -> str:
     # format the given arduino (https://github.com/espressif/arduino-esp32/releases) version to
-    # a PIO platformio/framework-arduinoespressif32 value
-    # List of package versions: https://api.registry.platformio.org/v3/packages/platformio/tool/framework-arduinoespressif32
-    if ver <= cv.Version(1, 0, 3):
-        return f"~2.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
-    return f"~3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
+    # a PIO pioarduino/framework-arduinoespressif32 value
+    return f"pioarduino/framework-arduinoespressif32@https://github.com/espressif/arduino-esp32/releases/download/{str(ver)}/esp32-{str(ver)}.zip"
 
 
 def _format_framework_espidf_version(
@@ -317,12 +309,10 @@ def _format_framework_espidf_version(
 
 # The default/recommended arduino framework version
 #  - https://github.com/espressif/arduino-esp32/releases
-#  - https://api.registry.platformio.org/v3/packages/platformio/tool/framework-arduinoespressif32
-RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(2, 0, 5)
-# The platformio/espressif32 version to use for arduino frameworks
-#  - https://github.com/platformio/platform-espressif32/releases
-#  - https://api.registry.platformio.org/v3/packages/platformio/platform/espressif32
-ARDUINO_PLATFORM_VERSION = cv.Version(5, 4, 0)
+RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(3, 1, 3)
+# The platform-espressif32 version to use for arduino frameworks
+#  - https://github.com/pioarduino/platform-espressif32/releases
+ARDUINO_PLATFORM_VERSION = cv.Version(53, 3, 13)
 
 # The default/recommended esp-idf framework version
 #  - https://github.com/espressif/esp-idf/releases
@@ -351,6 +341,7 @@ SUPPORTED_PLATFORMIO_ESP_IDF_5X = [
 # List based on https://github.com/pioarduino/esp-idf/releases
 SUPPORTED_PIOARDUINO_ESP_IDF_5X = [
     cv.Version(5, 5, 0),
+    cv.Version(5, 4, 2),
     cv.Version(5, 4, 1),
     cv.Version(5, 4, 0),
     cv.Version(5, 3, 3),
@@ -365,8 +356,8 @@ SUPPORTED_PIOARDUINO_ESP_IDF_5X = [
 def _arduino_check_versions(value):
     value = value.copy()
     lookups = {
-        "dev": (cv.Version(2, 1, 0), "https://github.com/espressif/arduino-esp32.git"),
-        "latest": (cv.Version(2, 0, 9), None),
+        "dev": (cv.Version(3, 1, 3), "https://github.com/espressif/arduino-esp32.git"),
+        "latest": (cv.Version(3, 1, 3), None),
         "recommended": (RECOMMENDED_ARDUINO_FRAMEWORK_VERSION, None),
     }
 
@@ -388,6 +379,10 @@ def _arduino_check_versions(value):
         CONF_PLATFORM_VERSION, _parse_platform_version(str(ARDUINO_PLATFORM_VERSION))
     )
 
+    if value[CONF_SOURCE].startswith("http"):
+        # prefix is necessary or platformio will complain with a cryptic error
+        value[CONF_SOURCE] = f"framework-arduinoespressif32@{value[CONF_SOURCE]}"
+
     if version != RECOMMENDED_ARDUINO_FRAMEWORK_VERSION:
         _LOGGER.warning(
             "The selected Arduino framework version is not the recommended one. "
@@ -416,8 +411,8 @@ def _esp_idf_check_versions(value):
         version = cv.Version.parse(cv.version_number(value[CONF_VERSION]))
         source = value.get(CONF_SOURCE, None)
 
-    if version < cv.Version(4, 0, 0):
-        raise cv.Invalid("Only ESP-IDF 4.0+ is supported.")
+    if version < cv.Version(5, 0, 0):
+        raise cv.Invalid("Only ESP-IDF 5.0+ is supported.")
 
     # flag this for later *before* we set value[CONF_PLATFORM_VERSION] below
     has_platform_ver = CONF_PLATFORM_VERSION in value
@@ -427,20 +422,15 @@ def _esp_idf_check_versions(value):
     )
 
     if (
-        (is_platformio := _platform_is_platformio(value[CONF_PLATFORM_VERSION]))
-        and version.major >= 5
-        and version not in SUPPORTED_PLATFORMIO_ESP_IDF_5X
-    ):
+        is_platformio := _platform_is_platformio(value[CONF_PLATFORM_VERSION])
+    ) and version not in SUPPORTED_PLATFORMIO_ESP_IDF_5X:
         raise cv.Invalid(
             f"ESP-IDF {str(version)} not supported by platformio/espressif32"
         )
 
     if (
-        version.major < 5
-        or (
-            version in SUPPORTED_PLATFORMIO_ESP_IDF_5X
-            and version not in SUPPORTED_PIOARDUINO_ESP_IDF_5X
-        )
+        version in SUPPORTED_PLATFORMIO_ESP_IDF_5X
+        and version not in SUPPORTED_PIOARDUINO_ESP_IDF_5X
     ) and not has_platform_ver:
         raise cv.Invalid(
             f"ESP-IDF {value[CONF_VERSION]} may be supported by platformio/espressif32; please specify '{CONF_PLATFORM_VERSION}'"
@@ -574,6 +564,17 @@ CONF_ENABLE_LWIP_DHCP_SERVER = "enable_lwip_dhcp_server"
 CONF_ENABLE_LWIP_MDNS_QUERIES = "enable_lwip_mdns_queries"
 CONF_ENABLE_LWIP_BRIDGE_INTERFACE = "enable_lwip_bridge_interface"
 
+
+def _validate_idf_component(config: ConfigType) -> ConfigType:
+    """Validate IDF component config and warn about deprecated options."""
+    if CONF_REFRESH in config:
+        _LOGGER.warning(
+            "The 'refresh' option for IDF components is deprecated and has no effect. "
+            "It will be removed in ESPHome 2026.1. Please remove it from your configuration."
+        )
+    return config
+
+
 ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -613,15 +614,19 @@ ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
                 }
             ),
             cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
-                cv.Schema(
-                    {
-                        cv.Required(CONF_NAME): cv.string_strict,
-                        cv.Required(CONF_SOURCE): cv.SOURCE_SCHEMA,
-                        cv.Optional(CONF_PATH): cv.string,
-                        cv.Optional(CONF_REFRESH, default="1d"): cv.All(
-                            cv.string, cv.source_refresh
-                        ),
-                    }
+                cv.All(
+                    cv.Schema(
+                        {
+                            cv.Required(CONF_NAME): cv.string_strict,
+                            cv.Optional(CONF_SOURCE): cv.git_ref,
+                            cv.Optional(CONF_REF): cv.string,
+                            cv.Optional(CONF_PATH): cv.string,
+                            cv.Optional(CONF_REFRESH): cv.All(
+                                cv.string, cv.source_refresh
+                            ),
+                        }
+                    ),
+                    _validate_idf_component,
                 )
             ),
         }
@@ -695,12 +700,14 @@ FINAL_VALIDATE_SCHEMA = cv.Schema(final_validate)
 async def to_code(config):
     cg.add_platformio_option("board", config[CONF_BOARD])
     cg.add_platformio_option("board_upload.flash_size", config[CONF_FLASH_SIZE])
+    cg.set_cpp_standard("gnu++20")
     cg.add_build_flag("-DUSE_ESP32")
     cg.add_define("ESPHOME_BOARD", config[CONF_BOARD])
     cg.add_build_flag(f"-DUSE_ESP32_VARIANT_{config[CONF_VARIANT]}")
     cg.add_define("ESPHOME_VARIANT", VARIANT_FRIENDLY[config[CONF_VARIANT]])
 
     cg.add_platformio_option("lib_ldf_mode", "off")
+    cg.add_platformio_option("lib_compat_mode", "strict")
 
     framework_ver: cv.Version = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
 
@@ -748,6 +755,9 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0", False)
         add_idf_sdkconfig_option("CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1", False)
 
+        # Disable dynamic log level control to save memory
+        add_idf_sdkconfig_option("CONFIG_LOG_DYNAMIC_LEVEL_CONTROL", False)
+
         # Set default CPU frequency
         add_idf_sdkconfig_option(f"CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_{freq}", True)
 
@@ -787,14 +797,9 @@ async def to_code(config):
 
         if advanced.get(CONF_IGNORE_EFUSE_MAC_CRC):
             add_idf_sdkconfig_option("CONFIG_ESP_MAC_IGNORE_MAC_CRC_ERROR", True)
-            if (framework_ver.major, framework_ver.minor) >= (4, 4):
-                add_idf_sdkconfig_option(
-                    "CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE", False
-                )
-            else:
-                add_idf_sdkconfig_option(
-                    "CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE", False
-                )
+            add_idf_sdkconfig_option(
+                "CONFIG_ESP_PHY_CALIBRATION_AND_DATA_STORAGE", False
+            )
         if advanced.get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
             _LOGGER.warning(
                 "Using experimental features in ESP-IDF may result in unexpected failures."
@@ -812,26 +817,17 @@ async def to_code(config):
             add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
 
         for component in conf[CONF_COMPONENTS]:
-            source = component[CONF_SOURCE]
-            if source[CONF_TYPE] == TYPE_GIT:
-                add_idf_component(
-                    name=component[CONF_NAME],
-                    repo=source[CONF_URL],
-                    ref=source.get(CONF_REF),
-                    path=component.get(CONF_PATH),
-                    refresh=component[CONF_REFRESH],
-                )
-            elif source[CONF_TYPE] == TYPE_LOCAL:
-                _LOGGER.warning("Local components are not implemented yet.")
-
+            add_idf_component(
+                name=component[CONF_NAME],
+                repo=component.get(CONF_SOURCE),
+                ref=component.get(CONF_REF),
+                path=component.get(CONF_PATH),
+            )
     elif conf[CONF_TYPE] == FRAMEWORK_ARDUINO:
         cg.add_platformio_option("framework", "arduino")
         cg.add_build_flag("-DUSE_ARDUINO")
         cg.add_build_flag("-DUSE_ESP32_FRAMEWORK_ARDUINO")
-        cg.add_platformio_option(
-            "platform_packages",
-            [f"platformio/framework-arduinoespressif32@{conf[CONF_SOURCE]}"],
-        )
+        cg.add_platformio_option("platform_packages", [conf[CONF_SOURCE]])
 
         if CONF_PARTITIONS in config:
             cg.add_platformio_option("board_build.partitions", config[CONF_PARTITIONS])
@@ -925,6 +921,26 @@ def _write_sdkconfig():
         write_file_if_changed(sdk_path, contents)
 
 
+def _write_idf_component_yml():
+    yml_path = Path(CORE.relative_build_path("src/idf_component.yml"))
+    if CORE.data[KEY_ESP32][KEY_COMPONENTS]:
+        components: dict = CORE.data[KEY_ESP32][KEY_COMPONENTS]
+        dependencies = {}
+        for name, component in components.items():
+            dependency = {}
+            if component[KEY_REF]:
+                dependency["version"] = component[KEY_REF]
+            if component[KEY_REPO]:
+                dependency["git"] = component[KEY_REPO]
+            if component[KEY_PATH]:
+                dependency["path"] = component[KEY_PATH]
+            dependencies[name] = dependency
+        contents = yaml_util.dump({"dependencies": dependencies})
+    else:
+        contents = ""
+    write_file_if_changed(yml_path, contents)
+
+
 # Called by writer.py
 def copy_files():
     if CORE.using_arduino:
@@ -937,6 +953,7 @@ def copy_files():
             )
     if CORE.using_esp_idf:
         _write_sdkconfig()
+        _write_idf_component_yml()
         if "partitions.csv" not in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES]:
             write_file_if_changed(
                 CORE.relative_build_path("partitions.csv"),
@@ -953,55 +970,6 @@ def copy_files():
             __version__,
         )
 
-        import shutil
-
-        shutil.rmtree(CORE.relative_build_path("components"), ignore_errors=True)
-
-        if CORE.data[KEY_ESP32][KEY_COMPONENTS]:
-            components: dict = CORE.data[KEY_ESP32][KEY_COMPONENTS]
-
-            for name, component in components.items():
-                repo_dir, _ = git.clone_or_update(
-                    url=component[KEY_REPO],
-                    ref=component[KEY_REF],
-                    refresh=component[KEY_REFRESH],
-                    domain="idf_components",
-                    submodules=component[KEY_SUBMODULES],
-                )
-                mkdir_p(CORE.relative_build_path("components"))
-                component_dir = repo_dir
-                if component[KEY_PATH] is not None:
-                    component_dir = component_dir / component[KEY_PATH]
-
-                if component[KEY_COMPONENTS] == ["*"]:
-                    shutil.copytree(
-                        component_dir,
-                        CORE.relative_build_path("components"),
-                        dirs_exist_ok=True,
-                        ignore=shutil.ignore_patterns(".git*"),
-                        symlinks=True,
-                        ignore_dangling_symlinks=True,
-                    )
-                elif len(component[KEY_COMPONENTS]) > 0:
-                    for comp in component[KEY_COMPONENTS]:
-                        shutil.copytree(
-                            component_dir / comp,
-                            CORE.relative_build_path(f"components/{comp}"),
-                            dirs_exist_ok=True,
-                            ignore=shutil.ignore_patterns(".git*"),
-                            symlinks=True,
-                            ignore_dangling_symlinks=True,
-                        )
-                else:
-                    shutil.copytree(
-                        component_dir,
-                        CORE.relative_build_path(f"components/{name}"),
-                        dirs_exist_ok=True,
-                        ignore=shutil.ignore_patterns(".git*"),
-                        symlinks=True,
-                        ignore_dangling_symlinks=True,
-                    )
-
     for _, file in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES].items():
         if file[KEY_PATH].startswith("http"):
             import requests

esphome/components/esp32/core.cpp

@@ -56,11 +56,7 @@ void arch_init() {
 void IRAM_ATTR HOT arch_feed_wdt() { esp_task_wdt_reset(); }
 
 uint8_t progmem_read_byte(const uint8_t *addr) { return *addr; }
-#if ESP_IDF_VERSION_MAJOR >= 5
 uint32_t arch_get_cpu_cycle_count() { return esp_cpu_get_cycle_count(); }
-#else
-uint32_t arch_get_cpu_cycle_count() { return cpu_hal_get_cycle_count(); }
-#endif
 uint32_t arch_get_cpu_freq_hz() {
   uint32_t freq = 0;
 #ifdef USE_ESP_IDF

esphome/components/esp32/gpio.h

@@ -29,9 +29,9 @@ class ESP32InternalGPIOPin : public InternalGPIOPin {
   void attach_interrupt(void (*func)(void *), void *arg, gpio::InterruptType type) const override;
 
   gpio_num_t pin_;
-  bool inverted_;
   gpio_drive_cap_t drive_strength_;
   gpio::Flags flags_;
+  bool inverted_;
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
   static bool isr_service_installed;
 };

esphome/components/esp32/helpers.cpp

@@ -0,0 +1,69 @@
+#include "esphome/core/helpers.h"
+
+#ifdef USE_ESP32
+
+#include "esp_efuse.h"
+#include "esp_efuse_table.h"
+#include "esp_mac.h"
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/portmacro.h>
+#include "esp_random.h"
+#include "esp_system.h"
+
+namespace esphome {
+
+uint32_t random_uint32() { return esp_random(); }
+bool random_bytes(uint8_t *data, size_t len) {
+  esp_fill_random(data, len);
+  return true;
+}
+
+Mutex::Mutex() { handle_ = xSemaphoreCreateMutex(); }
+Mutex::~Mutex() {}
+void Mutex::lock() { xSemaphoreTake(this->handle_, portMAX_DELAY); }
+bool Mutex::try_lock() { return xSemaphoreTake(this->handle_, 0) == pdTRUE; }
+void Mutex::unlock() { xSemaphoreGive(this->handle_); }
+
+// only affects the executing core
+// so should not be used as a mutex lock, only to get accurate timing
+IRAM_ATTR InterruptLock::InterruptLock() { portDISABLE_INTERRUPTS(); }
+IRAM_ATTR InterruptLock::~InterruptLock() { portENABLE_INTERRUPTS(); }
+
+void get_mac_address_raw(uint8_t *mac) {  // NOLINT(readability-non-const-parameter)
+#if defined(CONFIG_SOC_IEEE802154_SUPPORTED)
+  // When CONFIG_SOC_IEEE802154_SUPPORTED is defined, esp_efuse_mac_get_default
+  // returns the 802.15.4 EUI-64 address, so we read directly from eFuse instead.
+  if (has_custom_mac_address()) {
+    esp_efuse_read_field_blob(ESP_EFUSE_MAC_CUSTOM, mac, 48);
+  } else {
+    esp_efuse_read_field_blob(ESP_EFUSE_MAC_FACTORY, mac, 48);
+  }
+#else
+  if (has_custom_mac_address()) {
+    esp_efuse_mac_get_custom(mac);
+  } else {
+    esp_efuse_mac_get_default(mac);
+  }
+#endif
+}
+
+void set_mac_address(uint8_t *mac) { esp_base_mac_addr_set(mac); }
+
+bool has_custom_mac_address() {
+#if !defined(USE_ESP32_IGNORE_EFUSE_CUSTOM_MAC)
+  uint8_t mac[6];
+  // do not use 'esp_efuse_mac_get_custom(mac)' because it drops an error in the logs whenever it fails
+#ifndef USE_ESP32_VARIANT_ESP32
+  return (esp_efuse_read_field_blob(ESP_EFUSE_USER_DATA_MAC_CUSTOM, mac, 48) == ESP_OK) && mac_address_is_valid(mac);
+#else
+  return (esp_efuse_read_field_blob(ESP_EFUSE_MAC_CUSTOM, mac, 48) == ESP_OK) && mac_address_is_valid(mac);
+#endif
+#else
+  return false;
+#endif
+}
+
+}  // namespace esphome
+
+#endif  // USE_ESP32

esphome/components/esp32_ble/ble.cpp

@@ -1,9 +1,9 @@
 #ifdef USE_ESP32
 
 #include "ble.h"
-#include "ble_event_pool.h"
 
 #include "esphome/core/application.h"
+#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 #include <esp_bt.h>
@@ -516,13 +516,12 @@ void ESP32BLE::dump_config() {
         break;
     }
     ESP_LOGCONFIG(TAG,
-                  "ESP32 BLE:\n"
-                  "  MAC address: %02X:%02X:%02X:%02X:%02X:%02X\n"
+                  "BLE:\n"
+                  "  MAC address: %s\n"
                   "  IO Capability: %s",
-                  mac_address[0], mac_address[1], mac_address[2], mac_address[3], mac_address[4], mac_address[5],
-                  io_capability_s);
+                  format_mac_address_pretty(mac_address).c_str(), io_capability_s);
   } else {
-    ESP_LOGCONFIG(TAG, "ESP32 BLE: bluetooth stack is not enabled");
+    ESP_LOGCONFIG(TAG, "Bluetooth stack is not enabled");
   }
 }
 

esphome/components/esp32_ble/ble.h

@@ -12,8 +12,8 @@
 #include "esphome/core/helpers.h"
 
 #include "ble_event.h"
-#include "ble_event_pool.h"
-#include "queue.h"
+#include "esphome/core/lock_free_queue.h"
+#include "esphome/core/event_pool.h"
 
 #ifdef USE_ESP32
 
@@ -25,10 +25,15 @@ namespace esphome {
 namespace esp32_ble {
 
 // Maximum number of BLE scan results to buffer
+// Sized to handle bursts of advertisements while allowing for processing delays
+// With 16 advertisements per batch and some safety margin:
+// - Without PSRAM: 24 entries (1.5× batch size)
+// - With PSRAM: 36 entries (2.25× batch size)
+// The reduced structure size (~80 bytes vs ~400 bytes) allows for larger buffers
 #ifdef USE_PSRAM
-static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 32;
+static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 36;
 #else
-static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 20;
+static constexpr uint8_t SCAN_RESULT_BUFFER_SIZE = 24;
 #endif
 
 // Maximum size of the BLE event queue - must be power of 2 for lock-free queue
@@ -51,7 +56,7 @@ enum IoCapability {
   IO_CAP_KBDISP = ESP_IO_CAP_KBDISP,
 };
 
-enum BLEComponentState {
+enum BLEComponentState : uint8_t {
   /** Nothing has been initialized yet. */
   BLE_COMPONENT_STATE_OFF = 0,
   /** BLE should be disabled on next loop. */
@@ -141,21 +146,31 @@ class ESP32BLE : public Component {
  private:
   template<typename... Args> friend void enqueue_ble_event(Args... args);
 
+  // Vectors (12 bytes each on 32-bit, naturally aligned to 4 bytes)
   std::vector<GAPEventHandler *> gap_event_handlers_;
   std::vector<GAPScanEventHandler *> gap_scan_event_handlers_;
   std::vector<GATTcEventHandler *> gattc_event_handlers_;
   std::vector<GATTsEventHandler *> gatts_event_handlers_;
   std::vector<BLEStatusEventHandler *> ble_status_event_handlers_;
-  BLEComponentState state_{BLE_COMPONENT_STATE_OFF};
-
-  LockFreeQueue<BLEEvent, MAX_BLE_QUEUE_SIZE> ble_events_;
-  BLEEventPool<MAX_BLE_QUEUE_SIZE> ble_event_pool_;
-  BLEAdvertising *advertising_{};
-  esp_ble_io_cap_t io_cap_{ESP_IO_CAP_NONE};
-  uint32_t advertising_cycle_time_{};
-  bool enable_on_boot_{};
+
+  // Large objects (size depends on template parameters, but typically aligned to 4 bytes)
+  esphome::LockFreeQueue<BLEEvent, MAX_BLE_QUEUE_SIZE> ble_events_;
+  esphome::EventPool<BLEEvent, MAX_BLE_QUEUE_SIZE> ble_event_pool_;
+
+  // optional<string> (typically 16+ bytes on 32-bit, aligned to 4 bytes)
   optional<std::string> name_;
-  uint16_t appearance_{0};
+
+  // 4-byte aligned members
+  BLEAdvertising *advertising_{};             // 4 bytes (pointer)
+  esp_ble_io_cap_t io_cap_{ESP_IO_CAP_NONE};  // 4 bytes (enum)
+  uint32_t advertising_cycle_time_{};         // 4 bytes
+
+  // 2-byte aligned members
+  uint16_t appearance_{0};  // 2 bytes
+
+  // 1-byte aligned members (grouped together to minimize padding)
+  BLEComponentState state_{BLE_COMPONENT_STATE_OFF};  // 1 byte (uint8_t enum)
+  bool enable_on_boot_{};                             // 1 byte
 };
 
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)

esphome/components/esp32_ble/ble_event.h

@@ -134,13 +134,13 @@ class BLEEvent {
   }
 
   // Destructor to clean up heap allocations
-  ~BLEEvent() { this->cleanup_heap_data(); }
+  ~BLEEvent() { this->release(); }
 
   // Default constructor for pre-allocation in pool
   BLEEvent() : type_(GAP) {}
 
-  // Clean up any heap-allocated data
-  void cleanup_heap_data() {
+  // Invoked on return to EventPool - clean up any heap-allocated data
+  void release() {
     if (this->type_ == GAP) {
       return;
     }
@@ -161,19 +161,19 @@ class BLEEvent {
 
   // Load new event data for reuse (replaces previous event data)
   void load_gap_event(esp_gap_ble_cb_event_t e, esp_ble_gap_cb_param_t *p) {
-    this->cleanup_heap_data();
+    this->release();
     this->type_ = GAP;
     this->init_gap_data_(e, p);
   }
 
   void load_gattc_event(esp_gattc_cb_event_t e, esp_gatt_if_t i, esp_ble_gattc_cb_param_t *p) {
-    this->cleanup_heap_data();
+    this->release();
     this->type_ = GATTC;
     this->init_gattc_data_(e, i, p);
   }
 
   void load_gatts_event(esp_gatts_cb_event_t e, esp_gatt_if_t i, esp_ble_gatts_cb_param_t *p) {
-    this->cleanup_heap_data();
+    this->release();
     this->type_ = GATTS;
     this->init_gatts_data_(e, i, p);
   }