esphome 2025.7.5__py3-none-any.whl → 2025.8.0__py3-none-any.whl

esphome/components/es8156/es8156.cpp

@@ -17,8 +17,6 @@ static const char *const TAG = "es8156";
   }
 
 void ES8156::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG02_SCLK_MODE, 0x04));
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG20_ANALOG_SYS1, 0x2A));
   ES8156_ERROR_FAILED(this->write_byte(ES8156_REG21_ANALOG_SYS2, 0x3C));

esphome/components/es8311/es8311.cpp

@@ -22,8 +22,6 @@ static const char *const TAG = "es8311";
   }
 
 void ES8311::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   // Reset
   ES8311_ERROR_FAILED(this->write_byte(ES8311_REG00_RESET, 0x1F));
   ES8311_ERROR_FAILED(this->write_byte(ES8311_REG00_RESET, 0x00));

esphome/components/es8388/es8388.cpp

@@ -23,8 +23,6 @@ static const char *const TAG = "es8388";
   }
 
 void ES8388::setup() {
-  ESP_LOGCONFIG(TAG, "Running setup");
-
   // mute DAC
   this->set_mute_state_(true);
 

esphome/components/esp32/__init__.py

@@ -15,6 +15,7 @@ from esphome.const import (
     CONF_FRAMEWORK,
     CONF_IGNORE_EFUSE_CUSTOM_MAC,
     CONF_IGNORE_EFUSE_MAC_CRC,
+    CONF_LOG_LEVEL,
     CONF_NAME,
     CONF_PATH,
     CONF_PLATFORM_VERSION,
@@ -31,6 +32,7 @@ from esphome.const import (
     KEY_TARGET_FRAMEWORK,
     KEY_TARGET_PLATFORM,
     PLATFORM_ESP32,
+    ThreadModel,
     __version__,
 )
 from esphome.core import CORE, HexInt, TimePeriod
@@ -39,7 +41,7 @@ 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 .boards import BOARDS, STANDARD_BOARDS
 from .const import (  # noqa
     KEY_BOARD,
     KEY_COMPONENTS,
@@ -75,8 +77,18 @@ CONF_ASSERTION_LEVEL = "assertion_level"
 CONF_COMPILER_OPTIMIZATION = "compiler_optimization"
 CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES = "enable_idf_experimental_features"
 CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
+CONF_EXECUTE_FROM_PSRAM = "execute_from_psram"
 CONF_RELEASE = "release"
 
+LOG_LEVELS_IDF = [
+    "NONE",
+    "ERROR",
+    "WARN",
+    "INFO",
+    "DEBUG",
+    "VERBOSE",
+]
+
 ASSERTION_LEVELS = {
     "DISABLE": "CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE",
     "ENABLE": "CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE",
@@ -309,19 +321,19 @@ def _format_framework_espidf_version(
 
 # The default/recommended arduino framework version
 #  - https://github.com/espressif/arduino-esp32/releases
-RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(3, 1, 3)
+RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(3, 2, 1)
 # The platform-espressif32 version to use for arduino frameworks
 #  - https://github.com/pioarduino/platform-espressif32/releases
-ARDUINO_PLATFORM_VERSION = cv.Version(53, 3, 13)
+ARDUINO_PLATFORM_VERSION = cv.Version(54, 3, 21, "2")
 
 # The default/recommended esp-idf framework version
 #  - https://github.com/espressif/esp-idf/releases
 #  - https://api.registry.platformio.org/v3/packages/platformio/tool/framework-espidf
-RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION = cv.Version(5, 3, 2)
+RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION = cv.Version(5, 4, 2)
 # The platformio/espressif32 version to use for esp-idf frameworks
 #  - https://github.com/platformio/platform-espressif32/releases
 #  - https://api.registry.platformio.org/v3/packages/platformio/platform/espressif32
-ESP_IDF_PLATFORM_VERSION = cv.Version(53, 3, 13)
+ESP_IDF_PLATFORM_VERSION = cv.Version(54, 3, 21, "2")
 
 # List based on https://registry.platformio.org/tools/platformio/framework-espidf/versions
 SUPPORTED_PLATFORMIO_ESP_IDF_5X = [
@@ -356,8 +368,8 @@ SUPPORTED_PIOARDUINO_ESP_IDF_5X = [
 def _arduino_check_versions(value):
     value = value.copy()
     lookups = {
-        "dev": (cv.Version(3, 1, 3), "https://github.com/espressif/arduino-esp32.git"),
-        "latest": (cv.Version(3, 1, 3), None),
+        "dev": (cv.Version(3, 2, 1), "https://github.com/espressif/arduino-esp32.git"),
+        "latest": (cv.Version(3, 2, 1), None),
         "recommended": (RECOMMENDED_ARDUINO_FRAMEWORK_VERSION, None),
     }
 
@@ -395,8 +407,8 @@ def _arduino_check_versions(value):
 def _esp_idf_check_versions(value):
     value = value.copy()
     lookups = {
-        "dev": (cv.Version(5, 3, 2), "https://github.com/espressif/esp-idf.git"),
-        "latest": (cv.Version(5, 3, 2), None),
+        "dev": (cv.Version(5, 4, 2), "https://github.com/espressif/esp-idf.git"),
+        "latest": (cv.Version(5, 2, 2), None),
         "recommended": (RECOMMENDED_ESP_IDF_FRAMEWORK_VERSION, None),
     }
 
@@ -467,10 +479,10 @@ def _parse_platform_version(value):
     try:
         ver = cv.Version.parse(cv.version_number(value))
         if ver.major >= 50:  # a pioarduino version
-            if "-" in value:
-                # maybe a release candidate?...definitely not our default, just use it as-is...
-                return f"https://github.com/pioarduino/platform-espressif32/releases/download/{value}/platform-espressif32.zip"
-            return f"https://github.com/pioarduino/platform-espressif32/releases/download/{ver.major}.{ver.minor:02d}.{ver.patch:02d}/platform-espressif32.zip"
+            release = f"{ver.major}.{ver.minor:02d}.{ver.patch:02d}"
+            if ver.extra:
+                release += f"-{ver.extra}"
+            return f"https://github.com/pioarduino/platform-espressif32/releases/download/{release}/platform-espressif32.zip"
         # if platform version is a valid version constraint, prefix the default package
         cv.platformio_version_constraint(value)
         return f"platformio/espressif32@{value}"
@@ -487,56 +499,90 @@ def _platform_is_platformio(value):
 
 
 def _detect_variant(value):
-    board = value[CONF_BOARD]
-    if board in BOARDS:
-        variant = BOARDS[board][KEY_VARIANT]
-        if CONF_VARIANT in value and variant != value[CONF_VARIANT]:
+    board = value.get(CONF_BOARD)
+    variant = value.get(CONF_VARIANT)
+    if variant and board is None:
+        # If variant is set, we can derive the board from it
+        # variant has already been validated against the known set
+        value = value.copy()
+        value[CONF_BOARD] = STANDARD_BOARDS[variant]
+    elif board in BOARDS:
+        variant = variant or BOARDS[board][KEY_VARIANT]
+        if variant != BOARDS[board][KEY_VARIANT]:
             raise cv.Invalid(
                 f"Option '{CONF_VARIANT}' does not match selected board.",
                 path=[CONF_VARIANT],
             )
         value = value.copy()
         value[CONF_VARIANT] = variant
+    elif not variant:
+        raise cv.Invalid(
+            "This board is unknown, if you are sure you want to compile with this board selection, "
+            f"override with option '{CONF_VARIANT}'",
+            path=[CONF_BOARD],
+        )
     else:
-        if CONF_VARIANT not in value:
-            raise cv.Invalid(
-                "This board is unknown, if you are sure you want to compile with this board selection, "
-                f"override with option '{CONF_VARIANT}'",
-                path=[CONF_BOARD],
-            )
         _LOGGER.warning(
-            "This board is unknown. Make sure the chosen chip component is correct.",
+            "This board is unknown; the specified variant '%s' will be used but this may not work as expected.",
+            variant,
         )
     return value
 
 
 def final_validate(config):
-    if not (
-        pio_options := fv.full_config.get()[CONF_ESPHOME].get(CONF_PLATFORMIO_OPTIONS)
-    ):
-        # Not specified or empty
-        return config
-
-    pio_flash_size_key = "board_upload.flash_size"
-    pio_partitions_key = "board_build.partitions"
-    if CONF_PARTITIONS in config and pio_partitions_key in pio_options:
-        raise cv.Invalid(
-            f"Do not specify '{pio_partitions_key}' in '{CONF_PLATFORMIO_OPTIONS}' with '{CONF_PARTITIONS}' in esp32"
-        )
-
-    if pio_flash_size_key in pio_options:
-        raise cv.Invalid(
-            f"Please specify {CONF_FLASH_SIZE} within esp32 configuration only"
-        )
-
+    # Imported locally to avoid circular import issues
+    from esphome.components.psram import DOMAIN as PSRAM_DOMAIN
+
+    errs = []
+    full_config = fv.full_config.get()
+    if pio_options := full_config[CONF_ESPHOME].get(CONF_PLATFORMIO_OPTIONS):
+        pio_flash_size_key = "board_upload.flash_size"
+        pio_partitions_key = "board_build.partitions"
+        if CONF_PARTITIONS in config and pio_partitions_key in pio_options:
+            errs.append(
+                cv.Invalid(
+                    f"Do not specify '{pio_partitions_key}' in '{CONF_PLATFORMIO_OPTIONS}' with '{CONF_PARTITIONS}' in esp32"
+                )
+            )
+        if pio_flash_size_key in pio_options:
+            errs.append(
+                cv.Invalid(
+                    f"Please specify {CONF_FLASH_SIZE} within esp32 configuration only"
+                )
+            )
     if (
         config[CONF_VARIANT] != VARIANT_ESP32
         and CONF_ADVANCED in (conf_fw := config[CONF_FRAMEWORK])
         and CONF_IGNORE_EFUSE_MAC_CRC in conf_fw[CONF_ADVANCED]
     ):
-        raise cv.Invalid(
-            f"{CONF_IGNORE_EFUSE_MAC_CRC} is not supported on {config[CONF_VARIANT]}"
+        errs.append(
+            cv.Invalid(
+                f"'{CONF_IGNORE_EFUSE_MAC_CRC}' is not supported on {config[CONF_VARIANT]}",
+                path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_IGNORE_EFUSE_MAC_CRC],
+            )
         )
+    if (
+        config.get(CONF_FRAMEWORK, {})
+        .get(CONF_ADVANCED, {})
+        .get(CONF_EXECUTE_FROM_PSRAM)
+    ):
+        if config[CONF_VARIANT] != VARIANT_ESP32S3:
+            errs.append(
+                cv.Invalid(
+                    f"'{CONF_EXECUTE_FROM_PSRAM}' is only supported on {VARIANT_ESP32S3} variant",
+                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_EXECUTE_FROM_PSRAM],
+                )
+            )
+        if PSRAM_DOMAIN not in full_config:
+            errs.append(
+                cv.Invalid(
+                    f"'{CONF_EXECUTE_FROM_PSRAM}' requires PSRAM to be configured",
+                    path=[CONF_FRAMEWORK, CONF_ADVANCED, CONF_EXECUTE_FROM_PSRAM],
+                )
+            )
+
+    if errs:
+        raise cv.MultipleInvalid(errs)
 
     return config
 
@@ -563,6 +609,8 @@ CONF_SDKCONFIG_OPTIONS = "sdkconfig_options"
 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"
+CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING = "enable_lwip_tcpip_core_locking"
+CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY = "enable_lwip_check_thread_safety"
 
 
 def _validate_idf_component(config: ConfigType) -> ConfigType:
@@ -585,6 +633,9 @@ ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
             cv.Optional(CONF_SDKCONFIG_OPTIONS, default={}): {
                 cv.string_strict: cv.string_strict
             },
+            cv.Optional(CONF_LOG_LEVEL, default="ERROR"): cv.one_of(
+                *LOG_LEVELS_IDF, upper=True
+            ),
             cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
                 {
                     cv.Optional(CONF_ASSERTION_LEVEL): cv.one_of(
@@ -611,6 +662,13 @@ ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
                     cv.Optional(
                         CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
                     ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, default=True
+                    ): cv.boolean,
+                    cv.Optional(
+                        CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, default=True
+                    ): cv.boolean,
+                    cv.Optional(CONF_EXECUTE_FROM_PSRAM): cv.boolean,
                 }
             ),
             cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
@@ -635,6 +693,64 @@ ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
 )
 
 
+class _FrameworkMigrationWarning:
+    shown = False
+
+
+def _show_framework_migration_message(name: str, variant: str) -> None:
+    """Show a friendly message about framework migration when defaulting to Arduino."""
+    if _FrameworkMigrationWarning.shown:
+        return
+    _FrameworkMigrationWarning.shown = True
+
+    from esphome.log import AnsiFore, color
+
+    message = (
+        color(
+            AnsiFore.BOLD_CYAN,
+            f"💡 IMPORTANT: {name} doesn't have a framework specified!",
+        )
+        + "\n\n"
+        + f"Currently, {variant} defaults to the Arduino framework.\n"
+        + color(AnsiFore.YELLOW, "This will change to ESP-IDF in ESPHome 2026.1.0.\n")
+        + "\n"
+        + "Note: Newer ESP32 variants (C6, H2, P4, etc.) already use ESP-IDF by default.\n"
+        + "\n"
+        + "Why change? ESP-IDF offers:\n"
+        + color(AnsiFore.GREEN, "  ✨ Up to 40% smaller binaries\n")
+        + color(AnsiFore.GREEN, "  🚀 Better performance and optimization\n")
+        + color(AnsiFore.GREEN, "  📦 Custom-built firmware for your exact needs\n")
+        + color(
+            AnsiFore.GREEN,
+            "  🔧 Active development and testing by ESPHome developers\n",
+        )
+        + "\n"
+        + "Trade-offs:\n"
+        + color(AnsiFore.YELLOW, "  ⏱️  Compile times are ~25% longer\n")
+        + color(AnsiFore.YELLOW, "  🔄 Some components need migration\n")
+        + "\n"
+        + "What should I do?\n"
+        + color(AnsiFore.CYAN, "  Option 1")
+        + ": Migrate to ESP-IDF (recommended)\n"
+        + "    Add this to your YAML under 'esp32:':\n"
+        + color(AnsiFore.WHITE, "      framework:\n")
+        + color(AnsiFore.WHITE, "        type: esp-idf\n")
+        + "\n"
+        + color(AnsiFore.CYAN, "  Option 2")
+        + ": Keep using Arduino (still supported)\n"
+        + "    Add this to your YAML under 'esp32:':\n"
+        + color(AnsiFore.WHITE, "      framework:\n")
+        + color(AnsiFore.WHITE, "        type: arduino\n")
+        + "\n"
+        + "Need help? Check out the migration guide:\n"
+        + color(
+            AnsiFore.BLUE,
+            "https://esphome.io/guides/esp32_arduino_to_idf.html",
+        )
+    )
+    _LOGGER.warning(message)
+
+
 def _set_default_framework(config):
     if CONF_FRAMEWORK not in config:
         config = config.copy()
@@ -643,6 +759,10 @@ def _set_default_framework(config):
         if variant in ARDUINO_ALLOWED_VARIANTS:
             config[CONF_FRAMEWORK] = ARDUINO_FRAMEWORK_SCHEMA({})
             config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ARDUINO
+            # Show the migration message
+            _show_framework_migration_message(
+                config.get(CONF_NAME, "This device"), variant
+            )
         else:
             config[CONF_FRAMEWORK] = ESP_IDF_FRAMEWORK_SCHEMA({})
             config[CONF_FRAMEWORK][CONF_TYPE] = FRAMEWORK_ESP_IDF
@@ -676,7 +796,7 @@ CONF_PARTITIONS = "partitions"
 CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
-            cv.Required(CONF_BOARD): cv.string_strict,
+            cv.Optional(CONF_BOARD): cv.string_strict,
             cv.Optional(CONF_CPU_FREQUENCY): cv.one_of(
                 *FULL_CPU_FREQUENCIES, upper=True
             ),
@@ -691,6 +811,7 @@ CONFIG_SCHEMA = cv.All(
     _detect_variant,
     _set_default_framework,
     set_core_data,
+    cv.has_at_least_one_key(CONF_BOARD, CONF_VARIANT),
 )
 
 
@@ -703,8 +824,10 @@ async def to_code(config):
     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]])
+    variant = config[CONF_VARIANT]
+    cg.add_build_flag(f"-DUSE_ESP32_VARIANT_{variant}")
+    cg.add_define("ESPHOME_VARIANT", VARIANT_FRIENDLY[variant])
+    cg.add_define(ThreadModel.MULTI_ATOMICS)
 
     cg.add_platformio_option("lib_ldf_mode", "off")
     cg.add_platformio_option("lib_compat_mode", "strict")
@@ -737,6 +860,7 @@ async def to_code(config):
         cg.add_platformio_option(
             "platform_packages", ["espressif/toolchain-esp32ulp@2.35.0-20220830"]
         )
+        add_idf_sdkconfig_option(f"CONFIG_IDF_TARGET_{variant}", True)
         add_idf_sdkconfig_option(
             f"CONFIG_ESPTOOLPY_FLASHSIZE_{config[CONF_FLASH_SIZE]}", True
         )
@@ -774,6 +898,21 @@ async def to_code(config):
             add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
         if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
             add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
+        if advanced.get(CONF_EXECUTE_FROM_PSRAM, False):
+            add_idf_sdkconfig_option("CONFIG_SPIRAM_FETCH_INSTRUCTIONS", True)
+            add_idf_sdkconfig_option("CONFIG_SPIRAM_RODATA", True)
+
+        # Apply LWIP core locking for better socket performance
+        # This is already enabled by default in Arduino framework, where it provides
+        # significant performance benefits. Our benchmarks show socket operations are
+        # 24-200% faster with core locking enabled:
+        # - select() on 4 sockets: ~190μs (Arduino/core locking) vs ~235μs (ESP-IDF default)
+        # - Up to 200% slower under load when all operations queue through tcpip_thread
+        # Enabling this makes ESP-IDF socket performance match Arduino framework.
+        if advanced.get(CONF_ENABLE_LWIP_TCPIP_CORE_LOCKING, True):
+            add_idf_sdkconfig_option("CONFIG_LWIP_TCPIP_CORE_LOCKING", True)
+        if advanced.get(CONF_ENABLE_LWIP_CHECK_THREAD_SAFETY, True):
+            add_idf_sdkconfig_option("CONFIG_LWIP_CHECK_THREAD_SAFETY", True)
 
         cg.add_platformio_option("board_build.partitions", "partitions.csv")
         if CONF_PARTITIONS in config:
@@ -813,6 +952,10 @@ async def to_code(config):
             ),
         )
 
+        add_idf_sdkconfig_option(
+            f"CONFIG_LOG_DEFAULT_LEVEL_{conf[CONF_LOG_LEVEL]}", True
+        )
+
         for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
             add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
 
@@ -862,7 +1005,7 @@ def get_arduino_partition_csv(flash_size):
     eeprom_partition_start = app1_partition_start + app_partition_size
     spiffs_partition_start = eeprom_partition_start + eeprom_partition_size
 
-    partition_csv = f"""\
+    return f"""\
 nvs,      data, nvs,     0x9000, 0x5000,
 otadata,  data, ota,     0xE000, 0x2000,
 app0,     app,  ota_0,   0x{app0_partition_start:X}, 0x{app_partition_size:X},
@@ -870,20 +1013,18 @@ app1,     app,  ota_1,   0x{app1_partition_start:X}, 0x{app_partition_size:X},
 eeprom,   data, 0x99,    0x{eeprom_partition_start:X}, 0x{eeprom_partition_size:X},
 spiffs,   data, spiffs,  0x{spiffs_partition_start:X}, 0x{spiffs_partition_size:X}
 """
-    return partition_csv
 
 
 def get_idf_partition_csv(flash_size):
     app_partition_size = APP_PARTITION_SIZES[flash_size]
 
-    partition_csv = f"""\
+    return f"""\
 otadata,  data, ota,     ,        0x2000,
 phy_init, data, phy,     ,        0x1000,
 app0,     app,  ota_0,   ,        0x{app_partition_size:X},
 app1,     app,  ota_1,   ,        0x{app_partition_size:X},
 nvs,      data, nvs,     ,        0x6D000,
 """
-    return partition_csv
 
 
 def _format_sdkconfig_val(value: SdkconfigValueType) -> str:
@@ -943,14 +1084,16 @@ def _write_idf_component_yml():
 
 # Called by writer.py
 def copy_files():
-    if CORE.using_arduino:
-        if "partitions.csv" not in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES]:
-            write_file_if_changed(
-                CORE.relative_build_path("partitions.csv"),
-                get_arduino_partition_csv(
-                    CORE.platformio_options.get("board_upload.flash_size")
-                ),
-            )
+    if (
+        CORE.using_arduino
+        and "partitions.csv" not in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES]
+    ):
+        write_file_if_changed(
+            CORE.relative_build_path("partitions.csv"),
+            get_arduino_partition_csv(
+                CORE.platformio_options.get("board_upload.flash_size")
+            ),
+        )
     if CORE.using_esp_idf:
         _write_sdkconfig()
         _write_idf_component_yml()
@@ -970,7 +1113,7 @@ def copy_files():
             __version__,
         )
 
-    for _, file in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES].items():
+    for file in CORE.data[KEY_ESP32][KEY_EXTRA_BUILD_FILES].values():
         if file[KEY_PATH].startswith("http"):
             import requests
 

esphome/components/esp32/boards.py

@@ -2,13 +2,30 @@ from .const import (
     VARIANT_ESP32,
     VARIANT_ESP32C2,
     VARIANT_ESP32C3,
+    VARIANT_ESP32C5,
     VARIANT_ESP32C6,
     VARIANT_ESP32H2,
     VARIANT_ESP32P4,
     VARIANT_ESP32S2,
     VARIANT_ESP32S3,
+    VARIANTS,
 )
 
+STANDARD_BOARDS = {
+    VARIANT_ESP32: "esp32dev",
+    VARIANT_ESP32C2: "esp32-c2-devkitm-1",
+    VARIANT_ESP32C3: "esp32-c3-devkitm-1",
+    VARIANT_ESP32C5: "esp32-c5-devkitc-1",
+    VARIANT_ESP32C6: "esp32-c6-devkitm-1",
+    VARIANT_ESP32H2: "esp32-h2-devkitm-1",
+    VARIANT_ESP32P4: "esp32-p4-evboard",
+    VARIANT_ESP32S2: "esp32-s2-kaluga-1",
+    VARIANT_ESP32S3: "esp32-s3-devkitc-1",
+}
+
+# Make sure not missed here if a new variant added.
+assert all(v in STANDARD_BOARDS for v in VARIANTS)
+
 ESP32_BASE_PINS = {
     "TX": 1,
     "RX": 3,

esphome/components/esp32/gpio.cpp

@@ -114,7 +114,6 @@ void ESP32InternalGPIOPin::setup() {
   if (flags_ & gpio::FLAG_OUTPUT) {
     gpio_set_drive_capability(pin_, drive_strength_);
   }
-  ESP_LOGD(TAG, "rtc: %d", SOC_GPIO_SUPPORT_RTC_INDEPENDENT);
 }
 
 void ESP32InternalGPIOPin::pin_mode(gpio::Flags flags) {

esphome/components/esp32/gpio.py

@@ -187,8 +187,7 @@ def validate_supports(value):
             "Open-drain only works with output mode", [CONF_MODE, CONF_OPEN_DRAIN]
         )
 
-    value = _esp32_validations[variant].usage_validation(value)
-    return value
+    return _esp32_validations[variant].usage_validation(value)
 
 
 # https://docs.espressif.com/projects/esp-idf/en/v3.3.5/api-reference/peripherals/gpio.html#_CPPv416gpio_drive_cap_t

esphome/components/esp32/gpio_esp32_h2.py

@@ -2,6 +2,7 @@ import logging
 
 import esphome.config_validation as cv
 from esphome.const import CONF_INPUT, CONF_MODE, CONF_NUMBER
+from esphome.pins import check_strapping_pin
 
 _ESP32H2_SPI_FLASH_PINS = {6, 7, 15, 16, 17, 18, 19, 20, 21}
 
@@ -15,13 +16,6 @@ _LOGGER = logging.getLogger(__name__)
 def esp32_h2_validate_gpio_pin(value):
     if value < 0 or value > 27:
         raise cv.Invalid(f"Invalid pin number: {value} (must be 0-27)")
-    if value in _ESP32H2_STRAPPING_PINS:
-        _LOGGER.warning(
-            "GPIO%d is a Strapping PIN and should be avoided.\n"
-            "Attaching external pullup/down resistors to strapping pins can cause unexpected failures.\n"
-            "See https://esphome.io/guides/faq.html#why-am-i-getting-a-warning-about-strapping-pins",
-            value,
-        )
     if value in _ESP32H2_SPI_FLASH_PINS:
         _LOGGER.warning(
             "GPIO%d is reserved for SPI Flash communication on some ESP32-H2 chip variants.\n"
@@ -49,4 +43,5 @@ def esp32_h2_validate_supports(value):
     if is_input:
         # All ESP32 pins support input mode
         pass
+    check_strapping_pin(value, _ESP32H2_STRAPPING_PINS, _LOGGER)
     return value

esphome/components/esp32/gpio_esp32_p4.py

@@ -2,6 +2,7 @@ import logging
 
 import esphome.config_validation as cv
 from esphome.const import CONF_INPUT, CONF_MODE, CONF_NUMBER
+from esphome.pins import check_strapping_pin
 
 _ESP32P4_USB_JTAG_PINS = {24, 25}
 
@@ -13,13 +14,6 @@ _LOGGER = logging.getLogger(__name__)
 def esp32_p4_validate_gpio_pin(value):
     if value < 0 or value > 54:
         raise cv.Invalid(f"Invalid pin number: {value} (must be 0-54)")
-    if value in _ESP32P4_STRAPPING_PINS:
-        _LOGGER.warning(
-            "GPIO%d is a Strapping PIN and should be avoided.\n"
-            "Attaching external pullup/down resistors to strapping pins can cause unexpected failures.\n"
-            "See https://esphome.io/guides/faq.html#why-am-i-getting-a-warning-about-strapping-pins",
-            value,
-        )
     if value in _ESP32P4_USB_JTAG_PINS:
         _LOGGER.warning(
             "GPIO%d is reserved for the USB-Serial-JTAG interface.\n"
@@ -40,4 +34,5 @@ def esp32_p4_validate_supports(value):
     if is_input:
         # All ESP32 pins support input mode
         pass
+    check_strapping_pin(value, _ESP32P4_STRAPPING_PINS, _LOGGER)
     return value