Merge branch 'dev' into platformio-prefetch-git-clones

# Conflicts:
#	esphome/platformio/prefetch.py

.github/workflows/ci.yml

@@ -374,9 +374,8 @@ jobs:
       - name: Install apt packages (cached)
         # ccache speeds up the host compiles. A cache hit never touches apt
         # (mirror outages cannot hang the job); the timeout bounds the cold
-        # path. Packages and version must match seed-apt-cache exactly.
-        # libsdl2-dev is needed by the headless display tests, which capture
-        # screenshots.
+        # path. Packages and version must match seed-apt-cache exactly;
+        # libsdl2-dev is unused here and carried only for cache-key parity.
         timeout-minutes: 10
         uses: awalsh128/cache-apt-pkgs-action@553a35bb8ebd9fcabcb1c9451aa4c98e1b4ca8a9 # v1.6.3
         with:
@@ -439,16 +438,6 @@ jobs:
           echo "Bucket ${{ matrix.bucket.name }}: running ${#test_files[@]} integration tests"
           pytest -vv --no-cov --tb=native --durations=30 -n auto --dist worksteal \
             --junitxml=junit-integration.xml "${test_files[@]}"
-      - name: Upload test artifacts
-        # Tests that compare rendered output write the image they actually got here, so a
-        # failure can be looked at without reproducing the whole build locally.
-        if: failure()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-        with:
-          name: integration-test-artifacts-${{ matrix.bucket.name }}
-          path: test_artifacts/
-          if-no-files-found: ignore
-          retention-days: 7
       - name: Upload junit timings
         # Consumed by sync-integration-durations.yml through
         # script/update_integration_test_durations.py; only full matrix dev

.gitignore

@@ -137,8 +137,6 @@ config/
 !tests/component_tests/**/config/
 tests/build/
 tests/.esphome/
-# Output kept by failing tests for inspection; uploaded by CI
-test_artifacts/
 /.temp-clang-tidy.cpp
 /.temp/
 .pio/

AGENTS.md

@@ -44,16 +44,6 @@ This document provides essential context for AI models interacting with this pro
 
 ## 4. Coding Conventions & Style Guide
 
-**Read the developer documentation before writing a component.** https://developers.esphome.io covers the
-component lifecycle, the main loop, and the reasoning behind the rules below in far more depth than this
-file does, and it is the authority when they disagree. The most useful starting points:
-
-*   https://developers.esphome.io/architecture/components/ - component lifecycle, `setup()`, `loop()`,
-    setup priorities, and how a component is registered.
-*   https://developers.esphome.io/architecture/components/advanced/ - choosing between `loop()`,
-    `set_interval`, `set_timeout` and `defer`; waking the loop from another thread; the RAM cost of each.
-*   https://developers.esphome.io/contributing/code/ - contribution rules, public API and breaking changes.
-
 *   **Formatting:**
     *   **Python:** Uses `ruff` and `flake8` for linting and formatting. Configuration is in `pyproject.toml`.
     *   **C++:** Uses `clang-format` for formatting. Configuration is in `.clang-format`.
@@ -152,47 +142,6 @@ file does, and it is the authority when they disagree. The most useful starting
     *   **Indentation:** Use spaces (two per indentation level), not tabs
     *   **Type aliases:** Prefer `using type_t = int;` over `typedef int type_t;`
     *   **Line length:** Wrap lines at no more than 120 characters
-    *   **Timing in `loop()`:** Never call `millis()` in a `loop()` body. The current tick's timestamp is
-        already cached - use `App.get_loop_component_start_time()` (from `esphome/core/application.h`).
-        Only reach for `millis()` when you genuinely need sub-tick resolution inside a long operation.
-    *   **The main loop runs every 16 ms.** A rate-limit gate shorter than that does nothing: the check
-        passes on essentially every pass of the loop, so it costs a comparison and buys nothing. Pick an
-        interval comfortably coarser than 16 ms, or drop the gate entirely and accept running every loop.
-        ```cpp
-        // Bad - a 10ms gate against a 16ms loop never holds anything back
-        static constexpr uint32_t POLL_INTERVAL_MS = 10;
-        const uint32_t now = millis();
-        if (now - this->last_poll_ < POLL_INTERVAL_MS)
-          return;
-        this->last_poll_ = now;
-        ```
-        ```cpp
-        // Good - an interval that actually rate limits, off the cached timestamp
-        static constexpr uint32_t POLL_INTERVAL_MS = 100;
-        const uint32_t now = App.get_loop_component_start_time();
-        if (now - this->last_poll_ < POLL_INTERVAL_MS)
-          return;
-        this->last_poll_ = now;
-        ```
-        Pick the primitive by cadence: under 250 ms use a gated `loop()`; 500 ms and above use
-        `set_interval`. Full reasoning, including why `set_interval` costs more below 500 ms:
-        https://developers.esphome.io/architecture/components/advanced/#quick-rule-of-thumb
-    *   **Don't override a default with the same value:** if a base class method already returns what you
-        want, do not override it. `Component::get_setup_priority()` returns `setup_priority::DATA`, so a
-        component that wants `DATA` should simply leave it alone.
-        ```cpp
-        // Bad - this is exactly what the base class already does
-        float get_setup_priority() const override { return setup_priority::DATA; }
-        ```
-    *   **Logging string literals:** wrap literals passed as `%s` arguments in `LOG_STR_LITERAL()` so they
-        can be stored in flash rather than RAM.
-        ```cpp
-        // Bad
-        ESP_LOGV(TAG, "Key %u %s", key, pressed ? "pressed" : "released");
-
-        // Good
-        ESP_LOGV(TAG, "Key %u %s", key, pressed ? LOG_STR_LITERAL("pressed") : LOG_STR_LITERAL("released"));
-        ```
     *   **Constructor parameters vs setters:** Component properties that are both **required** and **invariant**
         (never change after construction) should be constructor parameters rather than set via setter methods.
         This makes the dependency explicit and prevents use of the object in an incompletely-initialized state.
@@ -613,33 +562,6 @@ file does, and it is the authority when they disagree. The most useful starting
            Use `cg.add_define("MAX_SERVICES", count)` to set the size from Python configuration.
            Like `std::array` but with vector-like API (`push_back()`, `size()`) and no STL reallocation code.
 
-           **Listener and child-entity registration lists are the most common case, and the most commonly
-           missed.** A `register_*()` method called once per child at code generation time has a count that
-           is known at compile time, so it should never be a `std::vector`. Use `cg.slot_counter()`: it
-           returns a function that each consumer calls once per slot it will occupy, and after every
-           `to_code` has run it emits the define with the final count. When nothing registers, no define is
-           emitted and the storage plus its registration method compile out entirely.
-           ```python
-           # hub component's __init__.py
-           _request_listener_slot = cg.slot_counter("MY_COMPONENT_LISTENER_COUNT")
-
-
-           async def register_listener(hub: MockObj, var: MockObj) -> None:
-               _request_listener_slot()
-               cg.add(hub.register_listener(var))
-           ```
-           ```cpp
-           #ifdef MY_COMPONENT_LISTENER_COUNT
-             void register_listener(MyComponentListener *listener);
-           #endif
-            protected:
-           #ifdef MY_COMPONENT_LISTENER_COUNT
-             StaticVector<MyComponentListener *, MY_COMPONENT_LISTENER_COUNT> listeners_;
-           #endif
-           ```
-           Request slots from `to_code`, not from a job that runs after `CoroPriority.FINAL` - a late
-           request raises rather than silently undercounting.
-
         3. **Runtime-known sizes:** Use `FixedVector` from `esphome/core/helpers.h` when the size is only known at runtime initialization.
            ```cpp
            // Bad - generates STL realloc code (_M_realloc_insert)
@@ -677,25 +599,9 @@ file does, and it is the authority when they disagree. The most useful starting
            ```
            Linear search on small datasets (1-16 elements) is often faster than hashing/tree overhead, but this depends on lookup frequency and access patterns. For frequent lookups in hot code paths, the O(1) vs O(n) complexity difference may still matter even for small datasets. `std::vector` with simple structs is usually fine—it's the heavy containers (`map`, `set`, `unordered_map`) that should be avoided for small datasets unless profiling shows otherwise.
 
-        5. **Strings set once from configuration:** Use `StringRef` (`esphome/core/string_ref.h`) rather than
-           `std::string`. Code generation passes a string literal that lives in flash for the life of the
-           program, so storing a `std::string` copies it onto the heap for nothing. `StringRef` is a
-           non-owning pointer plus length; it does not copy, and it must only ever refer to storage that
-           outlives it (a string literal, or a buffer owned elsewhere).
-           ```cpp
-           // Bad - heap copy of a literal that is already in flash
-           void set_keys(std::string keys) { this->keys_ = std::move(keys); }
-           std::string keys_;
-           ```
-           ```cpp
-           // Good - no allocation
-           void set_keys(const char *keys) { this->keys_ = StringRef(keys); }
-           StringRef keys_;
-           ```
+        5. **Avoid `std::deque`:** It allocates in 512-byte blocks regardless of element size, guaranteeing at least 512 bytes of RAM usage immediately. This is a major source of crashes on memory-constrained devices.
 
-        6. **Avoid `std::deque`:** It allocates in 512-byte blocks regardless of element size, guaranteeing at least 512 bytes of RAM usage immediately. This is a major source of crashes on memory-constrained devices.
-
-        7. **Detection:** Look for these patterns in compiler output:
+        6. **Detection:** Look for these patterns in compiler output:
            - Large code sections with STL symbols (vector, map, set)
            - `alloc`, `realloc`, `dealloc` in symbol names
            - `_M_realloc_insert`, `_M_default_append` (vector reallocation)

CODEOWNERS

@@ -496,7 +496,6 @@ esphome/components/sm2335/* @Cossid
 esphome/components/sml/* @alengwenus
 esphome/components/smt100/* @piechade
 esphome/components/sn74hc165/* @jesserockz
-esphome/components/snapshot/* @clydebarrow
 esphome/components/socket/* @esphome/core
 esphome/components/sonoff_d1/* @anatoly-savchenkov
 esphome/components/sound_level/* @kahrendt

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2026.10.0-dev
+PROJECT_NUMBER         = 2026.9.0-dev
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

docker/Dockerfile

@@ -22,7 +22,7 @@ RUN \
     -r /requirements.txt
 
 # Install the ESPHome Device Builder dashboard.
-RUN uv pip install --no-cache-dir esphome-device-builder==1.14.0
+RUN uv pip install --no-cache-dir esphome-device-builder==1.13.1
 
 RUN \
     platformio settings set enable_telemetry No \

esphome/arduino8266/framework.py

@@ -44,7 +44,8 @@ def get_arduino8266_tools_path() -> Path:
     return tools_cache_path(*ARDUINO8266_TOOLS_CACHE)
 
 
-# 3.1.1 rather than 3.1.0: the registry has no packages for 3.0.0, 3.0.1 or 3.1.0
+# 3.1.1 rather than 3.1.0: the registry has no package for 3.1.0, and the
+# encoder below cannot name 3.0.0/3.0.1 either (see its docstring)
 MIN_FRAMEWORK_VERSION = Version(3, 1, 1)
 
 
@@ -52,16 +53,20 @@ def framework_package_version(ver: Version) -> str:
     """Map an Arduino core version to its registry package version (3.1.2 ->
     3.30102.0; the leading 3 is the package major).
 
-    Exact registry names for 3.x cores; callers floor at MIN_FRAMEWORK_VERSION.
+    Exact registry names only for cores > 2.6.2 and >= 3.0.2; callers floor
+    at MIN_FRAMEWORK_VERSION.
     """
     if ver.major > 3:
         raise EsphomeError(
             f"Arduino core {ver} is not supported yet; "
             "the newest known core series is 3.x"
         )
-    if ver.major < 3:
+    if ver <= Version(2, 6, 2):
+        # Cores <= 2.6.2 use the older 1.x/2.x package-major encodings (same
+        # boundary as _format_framework_arduino_version's era guard)
         raise EsphomeError(
-            f"Arduino core {ver} is not supported; ESPHome requires core 3.x"
+            f"Arduino core {ver} uses an older package encoding than this "
+            "helper implements (newer than 2.6.2)"
         )
     return f"3.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
 

esphome/build_gen/arduino8266.py

@@ -1,773 +0,0 @@
-"""Build specification for the native ESP8266 Arduino toolchain.
-
-Transliterates the PlatformIO build spec for the Arduino ESP8266 framework
-(``framework-arduinoespressif8266/tools/platformio-build.py`` plus
-``platform-espressif8266/builder/main.py``): the flag sets, defines, and
-linker-script generation deliberately match what PlatformIO produces so the
-binaries stay near-identical between the two toolchains. The ninja emission
-(``write_project``) builds on these pieces.
-
-The ``PIO_FRAMEWORK_ARDUINO_*`` knob defines (lwIP variant, NONOS SDK
-version, MMU layout, exceptions, waveform phase) keep working: they are read
-from the build flags with the same precedence as the PlatformIO builder.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import hashlib
-import logging
-import os
-from pathlib import Path
-import re
-import shlex
-import subprocess
-from typing import TYPE_CHECKING, NamedTuple
-
-from esphome.arduino8266.framework import toolchain_tool
-from esphome.build_helpers.ninja import shell_token as _shell_token
-from esphome.components.esp8266 import build_surgery
-from esphome.core import CORE, EsphomeError
-from esphome.helpers import mkdir_p, write_file_if_changed
-from esphome.platformio.library import lex_build_flags
-
-if TYPE_CHECKING:
-    from esphome.arduino8266.framework import InstalledPaths
-
-_LOGGER = logging.getLogger(__name__)
-
-# Values that land unquoted on generated command lines are shape-checked
-# against these before use. re.ASCII: a Unicode digit or word character
-# (Arabic-Indic numerals) would pass \d/\w and defeat the named error
-_MMU_VALUE_RE = re.compile(r"(?:0[xX][0-9a-fA-F]+|\d+)[uUlL]*", re.ASCII)
-_MMU_HEX_VALUE_RE = re.compile(r"0[xX][0-9a-fA-F]+[uUlL]*", re.ASCII)
-# Only these land in the preprocessed script's ``len =`` fields, which
-# build_surgery's segment parser reads back as hex; the other MMU_* macros
-# (MMU_EXTERNAL_HEAP=128) are consumed by mmu_iram.h and may be decimal
-_MMU_SEGMENT_SIZE_NAMES = ("MMU_IRAM_SIZE", "MMU_ICACHE_SIZE")
-_BOARD_NAME_RE = re.compile(r"[\w.-]+", re.ASCII)
-_F_CPU_RE = re.compile(r"\d+L?", re.ASCII)
-_FLASH_LD_NAME_RE = re.compile(r"[\w.-]+\.ld", re.ASCII)
-
-# Every supported board ships this clock; board_build.f_cpu overrides
-_DEFAULT_F_CPU = "80000000L"
-
-# The SDK linker-script template and the preprocessed copy the build links
-# against; the cache stamp and stderr sidecars derive from the output name
-_COMMON_LD_HEADER = "eagle.app.v6.common.ld.h"
-_COMMON_LD_NAME = "local.eagle.app.v6.common.ld"
-# Testing mode shadows the SDK flash ld with a patched copy under this name
-_TESTING_LD_PREFIX = "testing_"
-
-# The recovery hint for a half-extracted or damaged framework cache
-_CLEAN_HINT = "run 'esphome clean-all' and retry"
-
-
-def _sdk_ld_dir(framework: Path) -> Path:
-    return framework / "tools" / "sdk" / "ld"
-
-
-def _apply_surgery(fn, *args: object) -> str:
-    """Run one build_surgery edit, naming a failed anchor instead of a
-    traceback (the surgery module raises bare RuntimeError so its
-    ``.py.script`` twins stay importable without esphome)."""
-    try:
-        return fn(*args)
-    except RuntimeError as err:
-        raise EsphomeError(str(err)) from err
-
-
-# From platformio-build.py. Knob suffix -> SDK define; the first entry is
-# the default (dicts preserve insertion order). With multiple SDK knobs set
-# (a pathological config) ties break by table order, since upstream's
-# tie-break depends on define order and is not reproducible here.
-_NONOSDK_VERSIONS = {
-    "SDK22x_190703": "NONOSDK22x_190703",
-    "SDK221": "NONOSDK221",
-    "SDK22x_190313": "NONOSDK22x_190313",
-    "SDK22x_191024": "NONOSDK22x_191024",
-    "SDK22x_191105": "NONOSDK22x_191105",
-    "SDK22x_191122": "NONOSDK22x_191122",
-    "SDK305": "NONOSDK305",
-}
-
-
-class _LwipVariant(NamedTuple):
-    """One lwIP build variant: the defines and the prebuilt library that
-    was compiled with them."""
-
-    tcp_mss: int
-    features: int
-    ipv6: int
-    lib: str
-
-
-# Knob define -> variant; first match wins, in insertion order (as in
-# platformio-build.py)
-_LWIP_VARIANTS = {
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_IPV6_LOW_MEMORY": _LwipVariant(
-        536, 1, 1, "lwip6-536-feat"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_IPV6_HIGHER_BANDWIDTH": _LwipVariant(
-        1460, 1, 1, "lwip6-1460-feat"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH": _LwipVariant(
-        1460, 1, 0, "lwip2-1460-feat"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_LOW_MEMORY_LOW_FLASH": _LwipVariant(
-        536, 0, 0, "lwip2-536"
-    ),
-    "PIO_FRAMEWORK_ARDUINO_LWIP2_HIGHER_BANDWIDTH_LOW_FLASH": _LwipVariant(
-        1460, 0, 0, "lwip2-1460"
-    ),
-}
-# The default is PIO_FRAMEWORK_ARDUINO_LWIP2_LOW_MEMORY's variant: upstream
-# has no branch for that spelling (it is the else), so any listed knob wins
-# over it -- sntp emits LOW_MEMORY while esp8266 always emits
-# HIGHER_BANDWIDTH_LOW_FLASH, and the latter must win as under PlatformIO
-_LWIP_DEFAULT = _LwipVariant(536, 1, 0, "lwip2-536-feat")
-
-# Knob define -> MMU_* defines; first match wins, in insertion order (as
-# in platformio-build.py)
-_MMU_VARIANTS = {
-    "PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48": (
-        "MMU_IRAM_SIZE=0xC000",
-        "MMU_ICACHE_SIZE=0x4000",
-    ),
-    "PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM48_SECHEAP_SHARED": (
-        "MMU_IRAM_SIZE=0xC000",
-        "MMU_ICACHE_SIZE=0x4000",
-        "MMU_IRAM_HEAP",
-    ),
-    "PIO_FRAMEWORK_ARDUINO_MMU_CACHE16_IRAM32_SECHEAP_NOTSHARED": (
-        "MMU_IRAM_SIZE=0x8000",
-        "MMU_ICACHE_SIZE=0x4000",
-        "MMU_SEC_HEAP_SIZE=0x4000",
-        "MMU_SEC_HEAP=0x40108000",
-    ),
-    "PIO_FRAMEWORK_ARDUINO_MMU_EXTERNAL_128K": (
-        "MMU_IRAM_SIZE=0x8000",
-        "MMU_ICACHE_SIZE=0x8000",
-        "MMU_EXTERNAL_HEAP=128",
-    ),
-    # Upstream really does cap the 1024K option's heap knob at 256
-    # (platformio-build.py's MMU_EXTERNAL_1024K branch); transliterated
-    # verbatim
-    "PIO_FRAMEWORK_ARDUINO_MMU_EXTERNAL_1024K": (
-        "MMU_IRAM_SIZE=0x8000",
-        "MMU_ICACHE_SIZE=0x8000",
-        "MMU_EXTERNAL_HEAP=256",
-    ),
-}
-# From platformio-build.py: the invariant framework defines every TU gets
-# (ARDUINO=10805 encodes the IDE compatibility level); the board, flash-mode,
-# knob, and MMU defines are composed around them in _defines_flags, in
-# upstream's order.
-_FRAMEWORK_DEFINES = ("__ets__", "ICACHE_FLASH", "_GNU_SOURCE", "ARDUINO=10805")
-_ARCH_DEFINES = ("ESP8266", "ARDUINO_ARCH_ESP8266")
-
-# Upstream reads these from the board manifest (build.mmu_iram_size etc.);
-# no supported board sets them, so the platformio-build.py defaults are
-# hardcoded here rather than drift
-_MMU_DEFAULT = ("MMU_IRAM_SIZE=0x8000", "MMU_ICACHE_SIZE=0x8000")
-
-# Upstream's CXXFLAGS (-fno-rtti, the -std level, -f(no-)exceptions) and the
-# trailing stdc++/m/c/gcc system libs are composed at emission
-# (write_project) from CORE.cpp_standard and _BuildConfig.exceptions.
-_ASFLAGS = ["-mlongcalls", "-mtext-section-literals"]
-_CFLAGS = [
-    "-std=gnu17",
-    "-Wpointer-arith",
-    "-Wno-implicit-function-declaration",
-    "-Wl,-EL",
-    "-fno-inline-functions",
-    "-nostdlib",
-]
-_CCFLAGS = [
-    "-Os",
-    "-mlongcalls",
-    "-mtext-section-literals",
-    "-falign-functions=4",
-    "-U__STRICT_ANSI__",
-    "-ffunction-sections",
-    "-fdata-sections",
-    "-Wall",
-    "-Werror=return-type",
-    "-free",
-    "-fipa-pta",
-]
-# Upstream's -u _scanf_float is deliberately absent: it is re-added from
-# KEY_SCANF_FLOAT at emission (the remove_float_scanf extra script's job).
-_LINKFLAGS = [
-    "-Os",
-    "-nostdlib",
-    "-Wl,--no-check-sections",
-    "-Wl,-static",
-    "-Wl,--gc-sections",
-    "-Wl,-wrap,system_restart_local",
-    "-Wl,-wrap,spi_flash_read",
-    "-u",
-    "app_entry",
-    "-u",
-    "_printf_float",
-    "-u",
-    "_DebugExceptionVector",
-    "-u",
-    "_DoubleExceptionVector",
-    "-u",
-    "_KernelExceptionVector",
-    "-u",
-    "_NMIExceptionVector",
-    "-u",
-    "_UserExceptionVector",
-]
-_SYSTEM_LIBS_PRE_LWIP = ["hal", "phy", "pp", "net80211"]
-_SYSTEM_LIBS_POST_LWIP = [
-    "wpa",
-    "crypto",
-    "main",
-    "wps",
-    "bearssl",
-    "espnow",
-    "smartconfig",
-    "airkiss",
-    "wpa2",
-]
-
-
-@dataclass
-class _BuildConfig:
-    """Knob-derived build configuration (PIO_FRAMEWORK_ARDUINO_* defines)."""
-
-    nonosdk: str
-    lwip_lib: str
-    exceptions: bool
-    vtables: str
-    fp_in_irom: bool
-    knob_defines: list[str]
-    mmu_defines: list[str]
-
-
-def _lexed_build_flags() -> list[str]:
-    """Shell-lex ``CORE.build_flags`` as PlatformIO's ``ParseFlags`` does,
-    sorted so duplicate defines resolve deterministically.
-
-    Lex once per build; consumers share the tokens.
-    """
-    # The funnel warns and drops empty glued arguments (-D "") itself
-    return lex_build_flags(sorted(CORE.build_flags), "esphome")
-
-
-def _flag_defines(unflags: set[str], tokens: list[str]) -> dict[str, str]:
-    """Map define name -> full ``NAME[=VALUE]`` for every -D build flag.
-
-    ``tokens`` comes from one ``_lexed_build_flags()`` call shared with
-    ``_project_flags``, which already warned about and dropped any bare "-D".
-    """
-    defines: dict[str, str] = {}
-    for tok in tokens:
-        # An unflagged knob must not drive lwIP/SDK/MMU selection while
-        # being absent from the compile line
-        if tok in unflags:
-            continue
-        if tok.startswith("-D"):
-            body = tok[2:]
-            defines[body.split("=", 1)[0]] = body
-    return defines
-
-
-def _resolve_build_config(defines: dict[str, str]) -> _BuildConfig:
-    nonosdk = next(
-        (
-            define
-            for name, define in _NONOSDK_VERSIONS.items()
-            if f"PIO_FRAMEWORK_ARDUINO_ESPRESSIF_{name}" in defines
-        ),
-        next(iter(_NONOSDK_VERSIONS.values())),
-    )
-    # Same compile-line/linked-artifact split as the lwIP knobs below: a
-    # raw NONOSDK* would define a second SDK macro while the link still
-    # resolves against the knob's libraries
-    if raw_sdk := sorted(n for n in defines if n.startswith("NONOSDK")):
-        raise EsphomeError(
-            f"{', '.join(raw_sdk)} are set by the "
-            "PIO_FRAMEWORK_ARDUINO_ESPRESSIF_SDK* knobs; drop the raw "
-            "build flags"
-        )
-
-    lwip = next(
-        (variant for knob, variant in _LWIP_VARIANTS.items() if knob in defines),
-        _LWIP_DEFAULT,
-    )
-
-    # The lwIP triple selects a prebuilt library; a raw override would win
-    # the compile line (user tokens come last here) while the link still
-    # pulls the library built for the knob's values
-    if owned := sorted(
-        n for n in ("TCP_MSS", "LWIP_FEATURES", "LWIP_IPV6") if n in defines
-    ):
-        raise EsphomeError(
-            f"{', '.join(owned)} are set by the PIO_FRAMEWORK_ARDUINO_LWIP2_* "
-            "knobs; drop the raw build flags"
-        )
-    knob_defines = [
-        f"{nonosdk}=1",
-        f"TCP_MSS={lwip.tcp_mss}",
-        f"LWIP_FEATURES={lwip.features}",
-        f"LWIP_IPV6={lwip.ipv6}",
-    ]
-    if "PIO_FRAMEWORK_ARDUINO_WAVEFORM_LOCKED_PHASE" in defines:
-        knob_defines.append("WAVEFORM_LOCKED_PHASE=1")
-
-    # Sorted so the pick is deterministic: the dict is built from a set of
-    # build flags, whose iteration order varies between processes.
-    vtables_knobs = sorted(name for name in defines if name.startswith("VTABLES_IN_"))
-    known_vtables = {"VTABLES_IN_FLASH", "VTABLES_IN_DRAM", "VTABLES_IN_IRAM"}
-    # A typo'd or conflicting knob would otherwise fail obscurely in the
-    # SDK header's #error
-    if unknown := [k for k in vtables_knobs if k not in known_vtables]:
-        raise EsphomeError(f"Unknown VTABLES_IN_* define(s): {', '.join(unknown)}")
-    # A body (e.g. VTABLES_IN_FLASH=0) would split the compile line from the
-    # linker script, which always defines the bare name
-    if valued := [defines[k] for k in vtables_knobs if defines[k] not in (k, f"{k}=1")]:
-        raise EsphomeError(f"VTABLES_IN_* defines take no value: {', '.join(valued)}")
-    if len(vtables_knobs) > 1:
-        raise EsphomeError(
-            f"Conflicting VTABLES_IN_* defines: {', '.join(vtables_knobs)}"
-        )
-    vtables = vtables_knobs[0] if vtables_knobs else "VTABLES_IN_FLASH"
-
-    mmu_knob = next((knob for knob in _MMU_VARIANTS if knob in defines), None)
-    if mmu_knob is not None:
-        if raw := sorted(n for n in defines if n.startswith("MMU_")):
-            # Same compile-line/linker-script split as the no-knob case below
-            fix = (
-                f"drop {mmu_knob} to use the custom sizes"
-                if "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM" in defines
-                else "drop the raw MMU_* build flags or use "
-                "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM"
-            )
-            raise EsphomeError(f"{', '.join(raw)} conflict with {mmu_knob}; {fix}")
-        mmu = list(_MMU_VARIANTS[mmu_knob])
-    elif "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM" in defines:
-        if "MMU_IRAM_SIZE" not in defines or "MMU_ICACHE_SIZE" not in defines:
-            raise EsphomeError(
-                "PIO_FRAMEWORK_ARDUINO_MMU_CUSTOM requires MMU_IRAM_SIZE and "
-                "MMU_ICACHE_SIZE build flags"
-            )
-        for name in _MMU_SEGMENT_SIZE_NAMES:
-            # A bare -Dname would preprocess to len = 1 and fail far away
-            if "=" not in defines[name]:
-                raise EsphomeError(
-                    f"{name} must be a hex literal (e.g. 0x8000), got (no value)"
-                )
-        for name, body in defines.items():
-            if not name.startswith("MMU_") or "=" not in body:
-                # Valueless flags (MMU_IRAM_HEAP) are legitimate switches
-                continue
-            # Every valued MMU_* reaches the linker-script preprocessor; a
-            # bare or non-numeric value would corrupt it and fail far away
-            # in ld. The two segment sizes must additionally be hex:
-            # build_surgery's segment parser cannot read decimal back.
-            value = body.partition("=")[2]
-            rule = (
-                _MMU_HEX_VALUE_RE if name in _MMU_SEGMENT_SIZE_NAMES else _MMU_VALUE_RE
-            )
-            if not rule.fullmatch(value):
-                shape = (
-                    "a hex literal (e.g. 0x8000)"
-                    if name in _MMU_SEGMENT_SIZE_NAMES
-                    else "a numeric literal"
-                )
-                raise EsphomeError(
-                    f"{name} must be {shape}, got {value or '(no value)'}"
-                )
-        # Sorted so build.ninja and the linker-script stamp stay
-        # byte-stable across runs (the flag set has no deterministic
-        # iteration order).
-        mmu = sorted(body for name, body in defines.items() if name.startswith("MMU_"))
-    else:
-        if raw := sorted(n for n in defines if n.startswith("MMU_")):
-            # Unlike PlatformIO (whose defaults win the compile line), user
-            # MMU_* here would win the compile but not the linker script;
-            # refuse them all, like the knob branch above.
-            raise EsphomeError(
-                f"Raw {', '.join(raw)} build flags require "
-                "-DPIO_FRAMEWORK_ARDUINO_MMU_CUSTOM"
-            )
-        mmu = list(_MMU_DEFAULT)
-
-    return _BuildConfig(
-        nonosdk=nonosdk,
-        lwip_lib=lwip.lib,
-        exceptions="PIO_FRAMEWORK_ARDUINO_ENABLE_EXCEPTIONS" in defines,
-        vtables=vtables,
-        fp_in_irom="FP_IN_IROM" in defines,
-        knob_defines=knob_defines,
-        mmu_defines=mmu,
-    )
-
-
-def _pio_option(key: str, default: str) -> str:
-    """A platformio_options value the native build honors (str-normalized).
-
-    core/config.py routes these into ``CORE.platformio_options`` under the
-    arduino toolchain and already collapses a repeated option to its last
-    value (like a later platformio.ini line), so a scalar always arrives.
-    """
-    value = CORE.platformio_options.get(key)
-    if value is None:
-        return default
-    value = str(value).strip()
-    if not value:
-        raise EsphomeError(f"platformio_options {key} is empty")
-    return value
-
-
-def _defines_flags(
-    config: _BuildConfig, flash_mode: str, board: str, board_defines: tuple[str, ...]
-) -> list[str]:
-    r"""The framework/board -D tokens for the compile line.
-
-    The returned tokens already carry shell-level escaping (the board
-    defines embed ``\"``), so they must be emitted unquoted; wrapping
-    them in ``_shell_token`` would deliver literal backslashes to gcc.
-    ``flash_mode`` also lands unquoted: callers pass it pre-validated
-    against ``BUILD_FLASH_MODES`` (cv.one_of at config time, the
-    ``_FLASH_MODES`` check at the emission half's read site).
-    """
-    if not _BOARD_NAME_RE.fullmatch(board):
-        # The name lands unquoted in two -D bodies; reject it by name
-        # instead of corrupting the compile line
-        raise EsphomeError(f"Invalid board name {board!r}")
-    # Every supported board ships 80 MHz; board_build.f_cpu overrides
-    f_cpu = _pio_option("board_build.f_cpu", _DEFAULT_F_CPU)
-    if not _F_CPU_RE.fullmatch(f_cpu):
-        # The value lands unquoted on the compile line; reject by name
-        # instead of corrupting it
-        raise EsphomeError(f"Invalid board_build.f_cpu value {f_cpu!r}")
-    return [
-        f"-D{d}"
-        for d in (
-            f"F_CPU={f_cpu}",
-            *_FRAMEWORK_DEFINES,
-            f'ARDUINO_BOARD=\\"PLATFORMIO_{board.upper()}\\"',
-            f'ARDUINO_BOARD_ID=\\"{board}\\"',
-            f"FLASHMODE_{flash_mode.upper()}",
-            "LWIP_OPEN_SRC",
-            *config.knob_defines,
-            config.vtables,
-            # User-supplied bodies re-quote like every other user token
-            # (a no-op for real MMU values)
-            *(_shell_token(d) for d in config.mmu_defines),
-            *_ARCH_DEFINES,
-            *board_defines,
-        )
-    ]
-
-
-def _unflag_tokens() -> set[str]:
-    """``build_unflags`` entries shell-lexed to tokens, as PlatformIO matches."""
-    # Lexed like _lexed_build_flags reads build_flags, so "-D FOO" removes
-    # -DFOO in both spellings (PlatformIO's ProcessUnFlags parses the same
-    # way) and no bare half can collaterally drop an unrelated token
-    return set(lex_build_flags(list(CORE.build_unflags), "esphome build_unflags"))
-
-
-def _project_flags(
-    unflags: set[str], tokens: list[str]
-) -> tuple[list[str], list[str], list[Path], list[str]]:
-    """Split the ESPHome build flags into compile, linker, -L, and -l lists.
-
-    Plain-form linker flags (``_PLAIN_LINKER_FLAGS``/``_PLAIN_LINKER_PREFIXES``)
-    raise: they would be inert on the ``-c`` compile line.
-    ``compile_flags``/``link_flags`` come back shell-quoted;
-    ``lib_dirs``/``libs`` are raw, quote at emission.
-    """
-    compile_flags: list[str] = []
-    link_flags: list[str] = []
-    lib_dirs: list[Path] = []
-    libs: list[str] = []
-    for tok in tokens:
-        if tok in unflags:
-            continue
-        # _lexed_build_flags warned about and dropped any bare -I/-D/-L/-l
-        if tok.startswith("-Wl,"):
-            link_flags.append(_shell_token(tok))
-        elif tok.startswith("-L"):
-            lib_dirs.append(Path(tok[2:]))
-        elif tok.startswith("-l"):
-            libs.append(tok[2:])
-        else:
-            if tok.startswith(_PLAIN_DRIVER_LINK_PREFIXES):
-                # Driver options with no -Wl, spelling; ld would reject them
-                raise EsphomeError(
-                    f"Link flag {tok} in build_flags is not supported by the "
-                    "native toolchain"
-                )
-            if tok in _PLAIN_LINKER_FLAGS or tok.startswith(_PLAIN_LINKER_PREFIXES):
-                raise EsphomeError(
-                    f"Linker flag {tok} in build_flags is not routed to the "
-                    "link line; use the -Wl, form"
-                )
-            if tok.startswith("-") and not tok.startswith(_COMPILE_FLAG_PREFIXES):
-                # The linker deny lists are not exhaustive; an unlisted
-                # link-only spelling would be inert on the -c compile line,
-                # so at least surface the odd shape
-                _LOGGER.warning(
-                    "Build flag %s is not a recognized compile-flag shape; "
-                    "it is passed to the compile line only",
-                    tok,
-                )
-            compile_flags.append(_shell_token(tok))
-    return compile_flags, link_flags, lib_dirs, libs
-
-
-# Recognized compile-flag shapes: the allow-list feeding the fall-through
-# warning in _project_flags (an unlisted link-only spelling still reaches
-# the compile line, but not silently)
-_COMPILE_FLAG_PREFIXES = (
-    "-D",
-    "-I",
-    "-U",
-    "-W",
-    "-f",
-    "-m",
-    "-O",
-    "-g",
-    "-std=",
-    "-include",
-)
-# Plain-form linker flags rejected by _project_flags: inert on a -c compile
-# line, so the firmware would silently lack the requested link behavior.
-# Best-effort, not exhaustive; see _COMPILE_FLAG_PREFIXES above.
-_PLAIN_LINKER_FLAGS = (
-    "-u",
-    "-e",
-    "-s",
-    "-static",
-    "-nostartfiles",
-    "-nodefaultlibs",
-    "-nostdlib",
-    "-rdynamic",
-)
-_PLAIN_LINKER_PREFIXES = ("-T", "-Xlinker")
-# Driver options, not ld options: -Wl, has no equivalent for these
-_PLAIN_DRIVER_LINK_PREFIXES = ("-fuse-ld=", "--specs=", "-specs=")
-
-
-def _stat_sig(path: Path) -> str:
-    """Size and mtime cache-stamp signature for one input file.
-
-    Absent stays deterministic ("missing": the spawn names it); unreadable
-    forces a cache miss every run rather than pinning the stamp to a
-    constant that can never notice a later edit.
-    """
-    try:
-        st = path.stat()
-        return f"{st.st_size}:{st.st_mtime_ns}"
-    except FileNotFoundError:
-        return "missing"
-    except OSError as err:
-        _LOGGER.warning(
-            "Could not stat %s (%s); regenerating the linker script every "
-            "build. Run 'esphome clean-all' to reinstall the framework.",
-            path,
-            err,
-        )
-        return f"unreadable:{os.urandom(8).hex()}"
-
-
-def _write_note(path: Path, text: str, *, warn: bool = False) -> bool:
-    """Best-effort bookkeeping write; a failure never fails the build.
-
-    ``warn`` marks notes whose loss drops a diagnostic on later cached
-    builds; a lost stamp only costs a cache miss and stays at debug.
-    Returns whether the write persisted, so a lost warn note can veto
-    the cache stamp and keep the diagnostic re-derivable.
-    """
-    try:
-        path.write_text(text, encoding="utf-8")
-    except OSError as err:
-        log = _LOGGER.warning if warn else _LOGGER.debug
-        log("Could not write %s: %s", path, err)
-        return False
-    return True
-
-
-def generate_ld_scripts(
-    paths: InstalledPaths, config: _BuildConfig, flash_ld_name: str
-) -> None:
-    """Generate the common linker script (and testing-mode flash ld copy).
-
-    Runs the same preprocessor invocation as the PlatformIO builder over
-    ``eagle.app.v6.common.ld.h``, then applies ESPHome's surgeries: the wifi
-    rate-table DRAM relocation, and enlarged memory segments in testing mode.
-    """
-    if not _FLASH_LD_NAME_RE.fullmatch(flash_ld_name):
-        # Joined under the SDK and build ld dirs; never a path or traversal
-        raise EsphomeError(f"Invalid flash linker script name {flash_ld_name!r}")
-    framework = paths.framework
-    gcc = toolchain_tool(paths.toolchain, "gcc")
-    ld_dir = CORE.relative_pioenvs_path(CORE.name, "ld")
-    mkdir_p(ld_dir)
-
-    cmd = [str(gcc), "-CC", "-E", "-P", f"-D{config.vtables}"]
-    cmd += [f"-D{d}" for d in config.mmu_defines]
-    if config.fp_in_irom:
-        cmd.append("-DFP_IN_IROM")
-    header = _sdk_ld_dir(framework) / _COMMON_LD_HEADER
-    cmd += [str(header), "-o", "-"]
-
-    # The inputs are the command line (defines + framework version, which is
-    # baked into the paths) plus testing mode; skip the preprocessor spawn on
-    # incremental builds when nothing changed.
-    output = ld_dir / _COMMON_LD_NAME
-    stamp = ld_dir / f".{_COMMON_LD_NAME}.stamp"
-    # Stamp includes the header/gcc stat (catches in-place re-extraction)
-    # and the surgery fingerprint (a build_surgery edit invalidates old
-    # build dirs)
-    stamp_content = (
-        # shlex.join: a spaced path stays one quoted element, so two
-        # different cmd lists can never collide to the same stamp string
-        shlex.join(cmd)
-        + f" testing={CORE.testing_mode}"
-        + f" header={_stat_sig(header)}"
-        + f" gcc={_stat_sig(gcc)}"
-        + f" {build_surgery.surgery_fingerprint()}"
-    )
-
-    stderr_note = ld_dir / f".{_COMMON_LD_NAME}.stderr"
-
-    def _note_digest() -> str:
-        # The note is an output like the script itself; folding its state
-        # into the stamp makes an externally removed or edited note a cache
-        # miss that re-runs -E and re-derives the diagnostic
-        if not stderr_note.is_file():
-            return "none"
-        return hashlib.sha256(stderr_note.read_bytes()).hexdigest()
-
-    def _cached_ld_is_valid() -> bool:
-        # Any damaged cache regenerates; never abort the build over it. The
-        # stamp records the sha256 of the content written, so an externally
-        # edited script regenerates too.
-        try:
-            if not (output.is_file() and stamp.is_file()):
-                return False
-            rest, sep, digest = stamp.read_text(encoding="utf-8").rpartition(
-                " content="
-            )
-            inputs, note_sep, note_digest = rest.rpartition(" note=")
-            return (
-                bool(sep)
-                and bool(note_sep)
-                and inputs == stamp_content
-                and note_digest == _note_digest()
-                and hashlib.sha256(output.read_bytes()).hexdigest() == digest
-            )
-        except (OSError, UnicodeDecodeError):
-            return False
-
-    if not _cached_ld_is_valid():
-        try:
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                check=False,
-                close_fds=False,
-            )
-        except OSError as err:
-            # A half-extracted or half-deleted toolchain cache reaches here
-            raise EsphomeError(f"Could not run {gcc}: {err}; {_CLEAN_HINT}") from err
-        # Localized gcc diagnostics on a non-UTF-8 console must degrade,
-        # not UnicodeDecodeError the build; the script itself (below) is
-        # decoded strictly instead, so a mangled byte can never be cached
-        stderr_text = result.stderr.decode("utf-8", errors="replace")
-        if result.returncode != 0:
-            raise EsphomeError(f"Generating the linker script failed:\n{stderr_text}")
-        note_persisted = True
-        if stderr_text.strip():
-            # Preprocessor warnings on the success path must reach the user
-            # on this and every later cached build (see the re-emit below)
-            _LOGGER.warning("Linker-script preprocessor: %s", stderr_text.strip())
-            note_persisted = _write_note(stderr_note, stderr_text.strip(), warn=True)
-        else:
-            try:
-                stderr_note.unlink(missing_ok=True)
-            except OSError as err:
-                # A kept stale note would re-emit an obsolete diagnostic on
-                # every cache hit; skip the stamp so -E re-derives the truth
-                _LOGGER.warning(
-                    "Could not remove %s (%s); the linker script will "
-                    "regenerate every build until it is removable; %s",
-                    stderr_note,
-                    err,
-                    _CLEAN_HINT,
-                )
-                note_persisted = False
-        try:
-            stdout_text = result.stdout.decode("utf-8")
-        except UnicodeDecodeError as err:
-            # -CC keeps header comments verbatim; a non-UTF-8 byte replaced
-            # with U+FFFD would be cached as valid for the build dir's life
-            raise EsphomeError(
-                f"Preprocessed linker script from {header} is not UTF-8: "
-                f"{err}; {_CLEAN_HINT}"
-            ) from err
-        if "SECTIONS" not in stdout_text:
-            # A degenerate zero-exit run must not be stamped as a good cache
-            raise EsphomeError(
-                f"Generated linker script is missing its SECTIONS block; {_CLEAN_HINT}"
-            )
-        content = _apply_surgery(build_surgery.relocate_ratetable, stdout_text)
-        if CORE.testing_mode:
-            content = _apply_surgery(
-                build_surgery.apply_testing_memory_patches, content, ("iram1_0_seg",)
-            )
-        write_file_if_changed(output, content)
-        if note_persisted:
-            # An unstamped cache re-runs -E next build, re-deriving the
-            # diagnostic the lost note would have re-emitted
-            _write_note(
-                stamp,
-                f"{stamp_content} note={_note_digest()} "
-                f"content={hashlib.sha256(content.encode('utf-8')).hexdigest()}",
-            )
-    elif stderr_note.is_file():
-        # Re-emit cached preprocessor warnings on cache hits
-        try:
-            _LOGGER.warning(
-                "Linker-script preprocessor: %s",
-                stderr_note.read_text(encoding="utf-8"),
-            )
-        except (OSError, UnicodeDecodeError) as err:
-            _LOGGER.warning(
-                "A cached linker-script preprocessor diagnostic exists at %s "
-                "but could not be read: %s",
-                stderr_note,
-                err,
-            )
-
-    if CORE.testing_mode:
-        _generate_testing_flash_ld(framework, ld_dir, flash_ld_name)
-
-
-def _generate_testing_flash_ld(
-    framework: Path, ld_dir: Path, flash_ld_name: str
-) -> None:
-    """A patched copy of the flash ld in the build dir; resolved through the
-    same -L path as the SDK original it shadows."""
-    flash_ld = _sdk_ld_dir(framework) / flash_ld_name
-    try:
-        flash_ld_text = flash_ld.read_text(encoding="utf-8")
-    except OSError as err:
-        # Same half-extracted-cache hazard as the preprocessor spawn
-        raise EsphomeError(f"Could not read {flash_ld}: {err}; {_CLEAN_HINT}") from err
-    patched_flash_ld = _apply_surgery(
-        build_surgery.apply_testing_memory_patches,
-        flash_ld_text,
-        ("dram0_0_seg", "irom0_0_seg"),
-    )
-    write_file_if_changed(
-        ld_dir / f"{_TESTING_LD_PREFIX}{flash_ld_name}", patched_flash_ld
-    )

esphome/components/climate/climate.cpp

@@ -368,8 +368,8 @@ optional<ClimateDeviceRestoreState> Climate::restore_state_() {
 }
 
 void Climate::save_state_(const ClimateTraits &traits) {
-#if (defined(USE_ESP32) || defined(USE_ESP8266)) && !defined(CLANG_TIDY)
-#pragma GCC diagnostic push
+#if (defined(USE_ESP32) || (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0))) && \
+    !defined(CLANG_TIDY)
 #pragma GCC diagnostic ignored "-Wclass-memaccess"
 #define TEMP_IGNORE_MEMACCESS
 #endif

esphome/components/cm1106/cm1106.cpp

@@ -100,6 +100,7 @@ bool CM1106Component::cm1106_write_command_(const uint8_t *command, size_t comma
 void CM1106Component::dump_config() {
   ESP_LOGCONFIG(TAG, "CM1106:");
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
+  this->check_uart_settings(9600);
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }

esphome/components/cm1106/sensor.py

@@ -46,14 +46,6 @@ CONFIG_SCHEMA = (
     .extend(uart.UART_DEVICE_SCHEMA)
 )
 
-FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "cm1106",
-    baud_rate=9600,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
-)
-
 
 async def to_code(config: ConfigType) -> None:
     """Code generation entry point."""

esphome/components/cse7761/cse7761.cpp

@@ -58,6 +58,7 @@ void CSE7761Component::dump_config() {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
+  this->check_uart_settings(38400, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
 }
 
 void CSE7761Component::update() {

esphome/components/cse7761/sensor.py

@@ -68,13 +68,7 @@ CONFIG_SCHEMA = (
 )
 
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "cse7761",
-    baud_rate=38400,
-    require_rx=True,
-    require_tx=True,
-    data_bits=8,
-    parity="EVEN",
-    stop_bits=1,
+    "cse7761", baud_rate=38400, require_rx=True, require_tx=True
 )
 
 

esphome/components/cse7766/cse7766.cpp

@@ -255,6 +255,7 @@ void CSE7766Component::dump_config() {
   LOG_SENSOR("  ", "Apparent Power", this->apparent_power_sensor_);
   LOG_SENSOR("  ", "Reactive Power", this->reactive_power_sensor_);
   LOG_SENSOR("  ", "Power Factor", this->power_factor_sensor_);
+  this->check_uart_settings(4800, 1, uart::UART_CONFIG_PARITY_EVEN);
 }
 
 }  // namespace esphome::cse7766

esphome/components/cse7766/sensor.py

@@ -84,12 +84,7 @@ CONFIG_SCHEMA = (
     .extend(cv.COMPONENT_SCHEMA)
 )
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "cse7766",
-    baud_rate=4800,
-    require_rx=True,
-    data_bits=8,
-    parity="EVEN",
-    stop_bits=1,
+    "cse7766", baud_rate=4800, parity="EVEN", require_rx=True
 )
 
 

esphome/components/daly_bms/__init__.py

@@ -26,14 +26,6 @@ CONFIG_SCHEMA = (
     .extend(cv.polling_component_schema("30s"))
 )
 
-FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "daly_bms",
-    baud_rate=9600,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
-)
-
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])

esphome/components/daly_bms/daly_bms.cpp

@@ -22,7 +22,10 @@ static const uint8_t DALY_REQUEST_TEMPERATURE = 0x96;
 
 void DalyBmsComponent::setup() { this->next_request_ = 1; }
 
-void DalyBmsComponent::dump_config() { ESP_LOGCONFIG(TAG, "Daly BMS:"); }
+void DalyBmsComponent::dump_config() {
+  ESP_LOGCONFIG(TAG, "Daly BMS:");
+  this->check_uart_settings(9600);
+}
 
 void DalyBmsComponent::update() {
   this->trigger_next_ = true;

esphome/components/debug/debug_component.cpp

@@ -22,9 +22,9 @@ void DebugComponent::dump_config() {
   LOG_SENSOR("  ", "Free space on heap", this->free_sensor_);
   LOG_SENSOR("  ", "Largest free heap block", this->block_sensor_);
   LOG_SENSOR("  ", "CPU frequency", this->cpu_frequency_sensor_);
-#ifdef USE_ESP8266
+#if defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
   LOG_SENSOR("  ", "Heap fragmentation", this->fragmentation_sensor_);
-#endif  // USE_ESP8266
+#endif  // defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
 #endif  // USE_SENSOR
 
   char device_info_buffer[DEVICE_INFO_BUFFER_SIZE];

esphome/components/debug/debug_component.h

@@ -35,7 +35,7 @@ class DebugComponent final : public PollingComponent {
 #ifdef USE_SENSOR
   void set_free_sensor(sensor::Sensor *free_sensor) { free_sensor_ = free_sensor; }
   void set_block_sensor(sensor::Sensor *block_sensor) { block_sensor_ = block_sensor; }
-#if defined(USE_ESP8266) || defined(USE_ESP32)
+#if (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)) || defined(USE_ESP32)
   void set_fragmentation_sensor(sensor::Sensor *fragmentation_sensor) { fragmentation_sensor_ = fragmentation_sensor; }
 #endif
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)
@@ -61,7 +61,7 @@ class DebugComponent final : public PollingComponent {
 
   sensor::Sensor *free_sensor_{nullptr};
   sensor::Sensor *block_sensor_{nullptr};
-#if defined(USE_ESP8266) || defined(USE_ESP32)
+#if (defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)) || defined(USE_ESP32)
   sensor::Sensor *fragmentation_sensor_{nullptr};
 #endif
 #if defined(USE_ESP32) || defined(USE_LIBRETINY)

esphome/components/debug/debug_esp8266.cpp

@@ -159,10 +159,12 @@ void DebugComponent::update_platform_() {
     // NOLINTNEXTLINE(readability-static-accessed-through-instance)
     this->block_sensor_->publish_state(ESP.getMaxFreeBlockSize());
   }
+#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 2)
   if (this->fragmentation_sensor_ != nullptr) {
     // NOLINTNEXTLINE(readability-static-accessed-through-instance)
     this->fragmentation_sensor_->publish_state(ESP.getHeapFragmentation());
   }
+#endif
 
 #endif
 }

esphome/components/debug/sensor.py

@@ -52,9 +52,12 @@ CONFIG_SCHEMA = {
     ),
     cv.Optional(CONF_FRAGMENTATION): cv.All(
         cv.Any(
-            cv.only_on_esp8266,
+            cv.All(
+                cv.only_on_esp8266,
+                cv.require_framework_version(esp8266_arduino=cv.Version(2, 5, 2)),
+            ),
             cv.only_on_esp32,
-            msg="This feature is only available on ESP8266 and ESP32",
+            msg="This feature is only available on ESP8266 (Arduino 2.5.2+) and ESP32",
         ),
         sensor.sensor_schema(
             unit_of_measurement=UNIT_PERCENT,

esphome/components/dfplayer/__init__.py

@@ -60,12 +60,7 @@ CONFIG_SCHEMA = cv.All(
     ).extend(uart.UART_DEVICE_SCHEMA)
 )
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "dfplayer",
-    baud_rate=9600,
-    require_tx=True,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
+    "dfplayer", baud_rate=9600, require_tx=True
 )
 
 

esphome/components/dfplayer/dfplayer.cpp

@@ -277,6 +277,9 @@ void DFPlayer::loop() {
     }
   }
 }
-void DFPlayer::dump_config() { ESP_LOGCONFIG(TAG, "DFPlayer:"); }
+void DFPlayer::dump_config() {
+  ESP_LOGCONFIG(TAG, "DFPlayer:");
+  this->check_uart_settings(9600);
+}
 
 }  // namespace esphome::dfplayer

esphome/components/esp8266/__init__.py

@@ -35,7 +35,7 @@ from esphome.platformio.toolchain import copy_ccache_script
 from esphome.storage_json import StorageJSON
 from esphome.types import ConfigType
 
-from .boards import BOARDS, board_ld_script
+from .boards import BOARDS, ESP8266_LD_SCRIPTS, board_ld_script
 from .const import (
     CONF_EARLY_PIN_INIT,
     CONF_ENABLE_SERIAL,
@@ -43,6 +43,8 @@ from .const import (
     CONF_RESTORE_FROM_FLASH,
     KEY_BOARD,
     KEY_ESP8266,
+    KEY_FLASH_SIZE,
+    KEY_LDSCRIPT,
     KEY_PIN_INITIAL_STATES,
     KEY_SERIAL1_REQUIRED,
     KEY_SERIAL_REQUIRED,
@@ -131,6 +133,10 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
     # format the given arduino (https://github.com/esp8266/Arduino/releases) version to
     # a PIO platformio/framework-arduinoespressif8266 value
     # List of package versions: https://api.registry.platformio.org/v3/packages/platformio/tool/framework-arduinoespressif8266
+    if ver <= cv.Version(2, 4, 1):
+        return f"~1.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
+    if ver <= cv.Version(2, 6, 2):
+        return f"~2.{ver.major}{ver.minor:02d}{ver.patch:02d}.0"
     # Same encoding the native toolchain uses for its package download, so a
     # version bump cannot drift between the two paths.
     from esphome.arduino8266.framework import framework_package_version
@@ -153,9 +159,11 @@ def _format_framework_arduino_version(ver: cv.Version) -> str:
 #  - https://github.com/esp8266/Arduino/releases
 #  - https://api.registry.platformio.org/v3/packages/platformio/tool/framework-arduinoespressif8266
 RECOMMENDED_ARDUINO_FRAMEWORK_VERSION = cv.Version(3, 1, 2)
-# The platformio/espressif8266 version to use for arduino 3 framework versions
+# The platformio/espressif8266 version to use for arduino 2 framework versions
 #  - https://github.com/platformio/platform-espressif8266/releases
 #  - https://api.registry.platformio.org/v3/packages/platformio/platform/espressif8266
+ARDUINO_2_PLATFORM_VERSION = cv.Version(2, 6, 3)
+# for arduino 3 framework versions
 ARDUINO_3_PLATFORM_VERSION = cv.Version(3, 2, 0)
 # for arduino 4 framework versions
 ARDUINO_4_PLATFORM_VERSION = cv.Version(4, 2, 1)
@@ -180,14 +188,6 @@ def _arduino_check_versions(value: ConfigType) -> ConfigType:
         version = cv.Version.parse(cv.version_number(value[CONF_VERSION]))
         source = value.get(CONF_SOURCE, None)
 
-    if version < cv.Version(3, 0, 0):
-        raise cv.Invalid(
-            f"Arduino framework {version} is no longer supported; ESPHome requires "
-            f"C++20, which needs Arduino core 3.x. Use the recommended version "
-            f"({RECOMMENDED_ARDUINO_FRAMEWORK_VERSION}).",
-            path=[CONF_VERSION],
-        )
-
     value[CONF_VERSION] = str(version)
     value[CONF_SOURCE] = source or _format_framework_arduino_version(version)
 
@@ -195,8 +195,12 @@ def _arduino_check_versions(value: ConfigType) -> ConfigType:
     if platform_version is None:
         if version >= cv.Version(3, 1, 0):
             platform_version = _parse_platform_version(str(ARDUINO_4_PLATFORM_VERSION))
-        else:
+        elif version >= cv.Version(3, 0, 0):
             platform_version = _parse_platform_version(str(ARDUINO_3_PLATFORM_VERSION))
+        elif version >= cv.Version(2, 5, 0):
+            platform_version = _parse_platform_version(str(ARDUINO_2_PLATFORM_VERSION))
+        else:
+            platform_version = _parse_platform_version(str(cv.Version(1, 8, 0)))
     value[CONF_PLATFORM_VERSION] = platform_version
 
     if version != RECOMMENDED_ARDUINO_FRAMEWORK_VERSION:
@@ -285,11 +289,29 @@ def check_rosetta() -> None:
         )
 
 
-def _choose_ld_script(board: str) -> str:
-    """The flash ld to pin for this board."""
+def _choose_ld_script(board: str, ver: cv.Version) -> str | None:
+    """The flash ld to pin for this board and core, or None for cores
+    without ld-script support."""
+    board_data = BOARDS[board]
+    ld_scripts = ESP8266_LD_SCRIPTS[board_data[KEY_FLASH_SIZE]]
+    if ver <= cv.Version(2, 3, 0):
+        # No ld script support
+        return None
+    if ver <= cv.Version(2, 4, 2):
+        # Old ld script path; the modern per-board override names do not
+        # exist in this core's SDK, so the override cannot be honored.
+        # Substituting the size default would move _FS_end and the
+        # preferences sector, wiping flash-backed state on flash.
+        if KEY_LDSCRIPT in board_data:
+            raise EsphomeError(
+                f"Board {board} requires its {board_data[KEY_LDSCRIPT]} "
+                f"flash layout, which Arduino core {ver} cannot honor; "
+                "use a core newer than 2.4.2"
+            )
+        return ld_scripts[0]
     # A per-board override preserves a layout the board shipped with
     # (see d1_wroom_02 in boards.py)
-    return board_ld_script(BOARDS[board])
+    return board_ld_script(board_data)
 
 
 @coroutine_with_priority(CoroPriority.PLATFORM)
@@ -413,9 +435,10 @@ async def to_code(config: ConfigType) -> None:
     )
 
     if config[CONF_BOARD] in BOARDS:
-        cg.add_platformio_option(
-            "board_build.ldscript", _choose_ld_script(config[CONF_BOARD])
-        )
+        ld_script = _choose_ld_script(config[CONF_BOARD], ver)
+
+        if ld_script is not None:
+            cg.add_platformio_option("board_build.ldscript", ld_script)
 
     CORE.add_job(add_pin_initial_states_array)
     CORE.add_job(finalize_waveform_config)

esphome/components/hc8/hc8.cpp

@@ -96,6 +96,7 @@ void HC8Component::dump_config() {
                 "  Warmup time: %" PRIu32 " s",
                 this->warmup_seconds_);
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
+  this->check_uart_settings(9600);
 }
 
 }  // namespace esphome::hc8

esphome/components/hc8/sensor.py

@@ -47,9 +47,6 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
     baud_rate=9600,
     require_rx=True,
     require_tx=True,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
 )
 
 

esphome/components/he60r/he60r.cpp

@@ -38,6 +38,7 @@ CoverTraits HE60rCover::get_traits() {
 
 void HE60rCover::dump_config() {
   LOG_COVER("", "HE60R Cover", this);
+  this->check_uart_settings(1200, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
   ESP_LOGCONFIG(TAG,
                 "  Open Duration: %.1fs\n"
                 "  Close Duration: %.1fs",

esphome/components/hrxl_maxsonar_wr/hrxl_maxsonar_wr.cpp

@@ -68,6 +68,8 @@ void HrxlMaxsonarWrComponent::check_buffer_() {
 void HrxlMaxsonarWrComponent::dump_config() {
   ESP_LOGCONFIG(TAG, "HRXL MaxSonar WR Sensor:");
   LOG_SENSOR("  ", "Distance", this);
+  // As specified in the sensor's data sheet
+  this->check_uart_settings(9600, 1, esphome::uart::UART_CONFIG_PARITY_NONE, 8);
 }
 
 }  // namespace esphome::hrxl_maxsonar_wr

esphome/components/hrxl_maxsonar_wr/sensor.py

@@ -23,14 +23,6 @@ CONFIG_SCHEMA = sensor.sensor_schema(
     state_class=STATE_CLASS_MEASUREMENT,
 ).extend(uart.UART_DEVICE_SCHEMA)
 
-FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "hrxl_maxsonar_wr",
-    baud_rate=9600,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
-)
-
 
 async def to_code(config: ConfigType) -> None:
     var = await sensor.new_sensor(config)

esphome/components/hydreon_rgxx/hydreon_rgxx.cpp

@@ -11,6 +11,7 @@ static const char *const PROTOCOL_NAMES[] = {HYDREON_RGXX_PROTOCOL_LIST(, HYDREO
 static const char *const IGNORE_STRINGS[] = {HYDREON_RGXX_IGNORE_LIST(, HYDREON_RGXX_COMMA)};
 
 void HydreonRGxxComponent::dump_config() {
+  this->check_uart_settings(9600, 1, esphome::uart::UART_CONFIG_PARITY_NONE, 8);
   ESP_LOGCONFIG(TAG, "hydreon_rgxx:");
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Connection with hydreon_rgxx failed!");

esphome/components/hydreon_rgxx/sensor.py

@@ -130,14 +130,6 @@ CONFIG_SCHEMA = cv.All(
     _validate,
 )
 
-FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "hydreon_rgxx",
-    baud_rate=9600,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
-)
-
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])

esphome/components/kamstrup_kmp/kamstrup_kmp.cpp

@@ -26,6 +26,8 @@ void KamstrupKMPComponent::dump_config() {
     LOG_SENSOR("  ", "Custom Sensor", this->custom_sensors_[i]);
     ESP_LOGCONFIG(TAG, "    Command: 0x%04X", this->custom_commands_[i]);
   }
+
+  this->check_uart_settings(1200, 2, uart::UART_CONFIG_PARITY_NONE, 8);
 }
 
 void KamstrupKMPComponent::update() {

esphome/components/kamstrup_kmp/sensor.py

@@ -102,13 +102,7 @@ CONFIG_SCHEMA = (
 )
 
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "kamstrup_kmp",
-    baud_rate=1200,
-    require_rx=True,
-    require_tx=True,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=2,
+    "kamstrup_kmp", baud_rate=1200, require_rx=True, require_tx=True
 )
 
 

esphome/components/mhz19/mhz19.cpp

@@ -143,6 +143,8 @@ void MHZ19Component::dump_config() {
   ESP_LOGCONFIG(TAG, "MH-Z19:");
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
+  this->check_uart_settings(9600);
+
   if (this->abc_boot_logic_ == MHZ19_ABC_ENABLED) {
     ESP_LOGCONFIG(TAG, "  Automatic baseline calibration enabled on boot");
   } else if (this->abc_boot_logic_ == MHZ19_ABC_DISABLED) {

esphome/components/mhz19/sensor.py

@@ -80,14 +80,6 @@ CONFIG_SCHEMA = (
     .extend(uart.UART_DEVICE_SCHEMA)
 )
 
-FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "mhz19",
-    baud_rate=9600,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
-)
-
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])

esphome/components/mk2pvrouter/mk2pvrouter.cpp

@@ -163,7 +163,10 @@ void Mk2PVRouter::publish_value_(const char *tag, const char *val) {
 #endif
 }
 
-void Mk2PVRouter::dump_config() { ESP_LOGCONFIG(TAG, "Mk2PVRouter:"); }
+void Mk2PVRouter::dump_config() {
+  ESP_LOGCONFIG(TAG, "Mk2PVRouter:");
+  this->check_uart_settings(BAUD_RATE, 1, uart::UART_CONFIG_PARITY_EVEN, 7);
+}
 
 #ifdef MK2PVROUTER_LISTENER_COUNT
 void Mk2PVRouter::register_mk2pvrouter_listener(Mk2PVRouterListener *listener) {

esphome/components/mk2pvrouter/mk2pvrouter.h

@@ -43,6 +43,7 @@ class Mk2PVRouter final : public Component, public uart::UARTDevice {
 
  protected:
   static constexpr size_t CRC_SUFFIX_LEN = 1;
+  static constexpr uint32_t BAUD_RATE = 9600;
 
   enum class State : uint8_t {
     WAITING_FOR_START,

esphome/components/nextion/nextion_upload_arduino.cpp

@@ -209,8 +209,14 @@ bool Nextion::upload_tft(uint32_t baud_rate, bool exit_reparse) {
   http_client.setTimeout(this->tft_upload_http_timeout_);
 
   bool begin_status = false;
+#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 7, 0)
   http_client.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
+#elif USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
+  http_client.setFollowRedirects(true);
+#endif
+#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 6, 0)
   http_client.setRedirectLimit(3);
+#endif
   begin_status = http_client.begin(*this->get_wifi_client_(), this->tft_url_.c_str());
   if (!begin_status) {
     this->connection_state_.is_updating_ = false;

esphome/components/pm1006/pm1006.cpp

@@ -16,6 +16,7 @@ void PM1006Component::dump_config() {
   ESP_LOGCONFIG(TAG, "PM1006:");
   LOG_SENSOR("  ", "PM2.5", this->pm_2_5_sensor_);
   LOG_UPDATE_INTERVAL(this);
+  this->check_uart_settings(9600);
 }
 
 void PM1006Component::update() {

esphome/components/pm1006/sensor.py

@@ -48,9 +48,6 @@ def validate_interval_uart(config: ConfigType) -> None:
         baud_rate=9600,
         require_rx=True,
         require_tx=interval.total_milliseconds != SCHEDULER_DONT_RUN,
-        data_bits=8,
-        parity="NONE",
-        stop_bits=1,
     )(config)
 
 

esphome/components/pmsx003/pmsx003.cpp

@@ -46,6 +46,8 @@ void PMSX003Component::dump_config() {
   } else {
     ESP_LOGCONFIG(TAG, "  Mode: passive with sleep/wake cycles");
   }
+
+  this->check_uart_settings(9600);
 }
 
 void PMSX003Component::loop() {

esphome/components/pmsx003/sensor.py

@@ -302,13 +302,7 @@ CONFIG_SCHEMA = cv.All(
 def final_validate(config: ConfigType) -> None:
     require_tx = config[CONF_UPDATE_INTERVAL] > cv.time_period("0s")
     schema = uart.final_validate_device_schema(
-        "pmsx003",
-        baud_rate=9600,
-        require_rx=True,
-        require_tx=require_tx,
-        data_bits=8,
-        parity="NONE",
-        stop_bits=1,
+        "pmsx003", baud_rate=9600, require_rx=True, require_tx=require_tx
     )
     schema(config)
 

esphome/components/pylontech/__init__.py

@@ -41,14 +41,6 @@ CONFIG_SCHEMA = cv.All(
     .extend(uart.UART_DEVICE_SCHEMA)
 )
 
-FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "pylontech",
-    baud_rate=115200,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
-)
-
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])

esphome/components/pylontech/pylontech.cpp

@@ -33,6 +33,7 @@ static const uint8_t ASCII_LF = 0x0A;
 PylontechComponent::PylontechComponent() {}
 
 void PylontechComponent::dump_config() {
+  this->check_uart_settings(115200, 1, esphome::uart::UART_CONFIG_PARITY_NONE, 8);
   ESP_LOGCONFIG(TAG, "pylontech:");
   if (this->is_failed()) {
     ESP_LOGE(TAG, "Connection with pylontech failed!");

esphome/components/remote_transmitter/__init__.py

@@ -4,7 +4,11 @@ from esphome import automation, pins
 import esphome.codegen as cg
 from esphome.components import esp32, esp32_rmt, remote_base
 from esphome.components.libretiny import get_libretiny_family
-from esphome.components.libretiny.const import FAMILY_BK7238, FAMILY_RTL8720C
+from esphome.components.libretiny.const import (
+    FAMILY_BK7231N,
+    FAMILY_BK7238,
+    FAMILY_RTL8720C,
+)
 from esphome.config_helpers import filter_source_files_from_platform
 import esphome.config_validation as cv
 from esphome.const import (
@@ -45,9 +49,7 @@ DigitalWriteAction = remote_transmitter_ns.class_(
 )
 
 
-# Keep in sync with the USE_LIBRETINY_VARIANT_RTL8720C / REMOTE_TRANSMITTER_BK_PWM gates in
-# remote_transmitter.h, which decide where set_non_blocking() is declared
-_NON_BLOCKING_LIBRETINY_FAMILIES = (FAMILY_RTL8720C, FAMILY_BK7238)
+_NON_BLOCKING_LIBRETINY_FAMILIES = (FAMILY_RTL8720C, FAMILY_BK7231N, FAMILY_BK7238)
 
 
 def _validate_non_blocking_platform(value: bool) -> bool:
@@ -57,7 +59,9 @@ def _validate_non_blocking_platform(value: bool) -> bool:
         return cv.boolean(value)
     if CORE.is_libretiny and get_libretiny_family() in _NON_BLOCKING_LIBRETINY_FAMILIES:
         return cv.boolean(value)
-    raise cv.Invalid("non_blocking is only supported on ESP32, RTL8720C and BK7238")
+    raise cv.Invalid(
+        "non_blocking is only supported on ESP32, RTL8720C, BK7231N and BK7238"
+    )
 
 
 MULTI_CONF = True

esphome/components/remote_transmitter/remote_transmitter.h

@@ -12,11 +12,10 @@
 #endif  // SOC_RMT_SUPPORTED
 #endif  // USE_ESP32
 
-// Enables the ISR-driven transmitter on Beken. Gated on BK7238 alone: the shadow-load PWM
-// block is shared with BK7231N, but LibreTiny builds that family against an older BDK whose
-// PWM driver has no pwm_init_param()/pwm_start(). See remote_transmitter_bk72xx.cpp.
-// Keep in sync with _NON_BLOCKING_LIBRETINY_FAMILIES in __init__.py.
-#ifdef USE_LIBRETINY_VARIANT_BK7238
+// The BK7231N-style PWM block (hardware shadow-load duty updates) enables the ISR-driven
+// transmitter on these families; family-level proxy for the SDK's CFG_SOC_NAME gate.
+// See remote_transmitter_bk72xx.cpp.
+#if defined(USE_LIBRETINY_VARIANT_BK7231N) || defined(USE_LIBRETINY_VARIANT_BK7238)
 #define REMOTE_TRANSMITTER_BK_PWM
 #endif
 

esphome/components/remote_transmitter/remote_transmitter_bk72xx.cpp

@@ -9,13 +9,10 @@
 // with the core's fixes for type-name collisions between the two
 #include <ArduinoPrivate.h>
 
-// Needs the BK7231N-style PWM block (shadow registers with a hardware CFG_UPDATA load bit)
-// for glitch-free per-edge duty updates, and an SDK exposing pwm_init_param()/pwm_start().
-// BK7231N has the block but LibreTiny builds it against an older BDK offering only the
-// sddev_control API (CMD_PWM_INIT_PARAM), so it stays on the generic bit-bang path until
-// someone can add and validate that path on real hardware. Every other Beken SoC lacks the
-// block. REMOTE_TRANSMITTER_BK_PWM is set per-family in remote_transmitter.h; when it is
-// unset this file compiles to nothing and remote_transmitter.cpp is used instead.
+// Only the BK7231N-style PWM block (shadow registers with a hardware CFG_UPDATA load bit)
+// supports glitch-free per-edge duty updates; older SoCs compile the generic bit-bang
+// implementation (remote_transmitter.cpp) instead, and this file compiles to nothing.
+// REMOTE_TRANSMITTER_BK_PWM is set per-family in remote_transmitter.h.
 
 namespace esphome::remote_transmitter {
 

esphome/components/remote_transmitter/remote_transmitter_libretiny_isr.cpp

@@ -3,11 +3,11 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 
-// Envelope chain shared by the LibreTiny families that pace transmission from a hardware timer
-// interrupt: RTL8720C (gtimer) and BK7238 (BKTIMER1). Everything platform-specific sits behind
-// five hooks implemented in the per-family files -- carrier setup, duty writes, one-shot arming
-// and timer stop. Families without a usable timer keep the generic bit-bang implementation and
-// compile none of this.
+// Envelope chain shared by the LibreTiny families that pace transmission from a hardware
+// timer interrupt: RTL8720C (gtimer) and the BK7231N-style PWM block (BKTIMER1). Everything
+// platform-specific sits behind five hooks implemented in the per-family files -- carrier
+// setup, duty writes, one-shot arming and timer stop. Families without a usable timer keep
+// the generic bit-bang implementation and compile none of this.
 #if defined(USE_LIBRETINY_VARIANT_RTL8720C) || defined(REMOTE_TRANSMITTER_BK_PWM)
 
 namespace esphome::remote_transmitter {

esphome/components/sdl/__init__.py

@@ -1,254 +1 @@
-import esphome.codegen as cg
-
 CODEOWNERS = ["@clydebarrow"]
-
-SDL_KeyCode = cg.global_ns.enum("SDL_KeyCode")
-
-SDL_KEYS = (
-    "SDLK_UNKNOWN",
-    "SDLK_RETURN",
-    "SDLK_ESCAPE",
-    "SDLK_BACKSPACE",
-    "SDLK_TAB",
-    "SDLK_SPACE",
-    "SDLK_EXCLAIM",
-    "SDLK_QUOTEDBL",
-    "SDLK_HASH",
-    "SDLK_PERCENT",
-    "SDLK_DOLLAR",
-    "SDLK_AMPERSAND",
-    "SDLK_QUOTE",
-    "SDLK_LEFTPAREN",
-    "SDLK_RIGHTPAREN",
-    "SDLK_ASTERISK",
-    "SDLK_PLUS",
-    "SDLK_COMMA",
-    "SDLK_MINUS",
-    "SDLK_PERIOD",
-    "SDLK_SLASH",
-    "SDLK_0",
-    "SDLK_1",
-    "SDLK_2",
-    "SDLK_3",
-    "SDLK_4",
-    "SDLK_5",
-    "SDLK_6",
-    "SDLK_7",
-    "SDLK_8",
-    "SDLK_9",
-    "SDLK_COLON",
-    "SDLK_SEMICOLON",
-    "SDLK_LESS",
-    "SDLK_EQUALS",
-    "SDLK_GREATER",
-    "SDLK_QUESTION",
-    "SDLK_AT",
-    "SDLK_LEFTBRACKET",
-    "SDLK_BACKSLASH",
-    "SDLK_RIGHTBRACKET",
-    "SDLK_CARET",
-    "SDLK_UNDERSCORE",
-    "SDLK_BACKQUOTE",
-    "SDLK_a",
-    "SDLK_b",
-    "SDLK_c",
-    "SDLK_d",
-    "SDLK_e",
-    "SDLK_f",
-    "SDLK_g",
-    "SDLK_h",
-    "SDLK_i",
-    "SDLK_j",
-    "SDLK_k",
-    "SDLK_l",
-    "SDLK_m",
-    "SDLK_n",
-    "SDLK_o",
-    "SDLK_p",
-    "SDLK_q",
-    "SDLK_r",
-    "SDLK_s",
-    "SDLK_t",
-    "SDLK_u",
-    "SDLK_v",
-    "SDLK_w",
-    "SDLK_x",
-    "SDLK_y",
-    "SDLK_z",
-    "SDLK_CAPSLOCK",
-    "SDLK_F1",
-    "SDLK_F2",
-    "SDLK_F3",
-    "SDLK_F4",
-    "SDLK_F5",
-    "SDLK_F6",
-    "SDLK_F7",
-    "SDLK_F8",
-    "SDLK_F9",
-    "SDLK_F10",
-    "SDLK_F11",
-    "SDLK_F12",
-    "SDLK_PRINTSCREEN",
-    "SDLK_SCROLLLOCK",
-    "SDLK_PAUSE",
-    "SDLK_INSERT",
-    "SDLK_HOME",
-    "SDLK_PAGEUP",
-    "SDLK_DELETE",
-    "SDLK_END",
-    "SDLK_PAGEDOWN",
-    "SDLK_RIGHT",
-    "SDLK_LEFT",
-    "SDLK_DOWN",
-    "SDLK_UP",
-    "SDLK_NUMLOCKCLEAR",
-    "SDLK_KP_DIVIDE",
-    "SDLK_KP_MULTIPLY",
-    "SDLK_KP_MINUS",
-    "SDLK_KP_PLUS",
-    "SDLK_KP_ENTER",
-    "SDLK_KP_1",
-    "SDLK_KP_2",
-    "SDLK_KP_3",
-    "SDLK_KP_4",
-    "SDLK_KP_5",
-    "SDLK_KP_6",
-    "SDLK_KP_7",
-    "SDLK_KP_8",
-    "SDLK_KP_9",
-    "SDLK_KP_0",
-    "SDLK_KP_PERIOD",
-    "SDLK_APPLICATION",
-    "SDLK_POWER",
-    "SDLK_KP_EQUALS",
-    "SDLK_F13",
-    "SDLK_F14",
-    "SDLK_F15",
-    "SDLK_F16",
-    "SDLK_F17",
-    "SDLK_F18",
-    "SDLK_F19",
-    "SDLK_F20",
-    "SDLK_F21",
-    "SDLK_F22",
-    "SDLK_F23",
-    "SDLK_F24",
-    "SDLK_EXECUTE",
-    "SDLK_HELP",
-    "SDLK_MENU",
-    "SDLK_SELECT",
-    "SDLK_STOP",
-    "SDLK_AGAIN",
-    "SDLK_UNDO",
-    "SDLK_CUT",
-    "SDLK_COPY",
-    "SDLK_PASTE",
-    "SDLK_FIND",
-    "SDLK_MUTE",
-    "SDLK_VOLUMEUP",
-    "SDLK_VOLUMEDOWN",
-    "SDLK_KP_COMMA",
-    "SDLK_KP_EQUALSAS400",
-    "SDLK_ALTERASE",
-    "SDLK_SYSREQ",
-    "SDLK_CANCEL",
-    "SDLK_CLEAR",
-    "SDLK_PRIOR",
-    "SDLK_RETURN2",
-    "SDLK_SEPARATOR",
-    "SDLK_OUT",
-    "SDLK_OPER",
-    "SDLK_CLEARAGAIN",
-    "SDLK_CRSEL",
-    "SDLK_EXSEL",
-    "SDLK_KP_00",
-    "SDLK_KP_000",
-    "SDLK_THOUSANDSSEPARATOR",
-    "SDLK_DECIMALSEPARATOR",
-    "SDLK_CURRENCYUNIT",
-    "SDLK_CURRENCYSUBUNIT",
-    "SDLK_KP_LEFTPAREN",
-    "SDLK_KP_RIGHTPAREN",
-    "SDLK_KP_LEFTBRACE",
-    "SDLK_KP_RIGHTBRACE",
-    "SDLK_KP_TAB",
-    "SDLK_KP_BACKSPACE",
-    "SDLK_KP_A",
-    "SDLK_KP_B",
-    "SDLK_KP_C",
-    "SDLK_KP_D",
-    "SDLK_KP_E",
-    "SDLK_KP_F",
-    "SDLK_KP_XOR",
-    "SDLK_KP_POWER",
-    "SDLK_KP_PERCENT",
-    "SDLK_KP_LESS",
-    "SDLK_KP_GREATER",
-    "SDLK_KP_AMPERSAND",
-    "SDLK_KP_DBLAMPERSAND",
-    "SDLK_KP_VERTICALBAR",
-    "SDLK_KP_DBLVERTICALBAR",
-    "SDLK_KP_COLON",
-    "SDLK_KP_HASH",
-    "SDLK_KP_SPACE",
-    "SDLK_KP_AT",
-    "SDLK_KP_EXCLAM",
-    "SDLK_KP_MEMSTORE",
-    "SDLK_KP_MEMRECALL",
-    "SDLK_KP_MEMCLEAR",
-    "SDLK_KP_MEMADD",
-    "SDLK_KP_MEMSUBTRACT",
-    "SDLK_KP_MEMMULTIPLY",
-    "SDLK_KP_MEMDIVIDE",
-    "SDLK_KP_PLUSMINUS",
-    "SDLK_KP_CLEAR",
-    "SDLK_KP_CLEARENTRY",
-    "SDLK_KP_BINARY",
-    "SDLK_KP_OCTAL",
-    "SDLK_KP_DECIMAL",
-    "SDLK_KP_HEXADECIMAL",
-    "SDLK_LCTRL",
-    "SDLK_LSHIFT",
-    "SDLK_LALT",
-    "SDLK_LGUI",
-    "SDLK_RCTRL",
-    "SDLK_RSHIFT",
-    "SDLK_RALT",
-    "SDLK_RGUI",
-    "SDLK_MODE",
-    "SDLK_AUDIONEXT",
-    "SDLK_AUDIOPREV",
-    "SDLK_AUDIOSTOP",
-    "SDLK_AUDIOPLAY",
-    "SDLK_AUDIOMUTE",
-    "SDLK_MEDIASELECT",
-    "SDLK_WWW",
-    "SDLK_MAIL",
-    "SDLK_CALCULATOR",
-    "SDLK_COMPUTER",
-    "SDLK_AC_SEARCH",
-    "SDLK_AC_HOME",
-    "SDLK_AC_BACK",
-    "SDLK_AC_FORWARD",
-    "SDLK_AC_STOP",
-    "SDLK_AC_REFRESH",
-    "SDLK_AC_BOOKMARKS",
-    "SDLK_BRIGHTNESSDOWN",
-    "SDLK_BRIGHTNESSUP",
-    "SDLK_DISPLAYSWITCH",
-    "SDLK_KBDILLUMTOGGLE",
-    "SDLK_KBDILLUMDOWN",
-    "SDLK_KBDILLUMUP",
-    "SDLK_EJECT",
-    "SDLK_SLEEP",
-    "SDLK_APP1",
-    "SDLK_APP2",
-    "SDLK_AUDIOREWIND",
-    "SDLK_AUDIOFASTFORWARD",
-    "SDLK_SOFTLEFT",
-    "SDLK_SOFTRIGHT",
-    "SDLK_CALL",
-    "SDLK_ENDCALL",
-)
-
-SDL_KEYMAP = {key: getattr(SDL_KeyCode, key) for key in SDL_KEYS}

esphome/components/sdl/binary_sensor.py

@@ -7,15 +7,262 @@ from esphome.core import Lambda
 from esphome.cpp_generator import ExpressionStatement, RawExpression
 from esphome.types import ConfigType
 
-from . import SDL_KEYMAP
-from .display import CONF_SDL_ID, Sdl, headless_final_validate
+from .display import CONF_SDL_ID, Sdl
 
 CODEOWNERS = ["@bdm310"]
 
 STATE_ARG = "state"
 
-FINAL_VALIDATE_SCHEMA = headless_final_validate("binary_sensor")
+SDL_KeyCode = cg.global_ns.enum("SDL_KeyCode")
 
+SDL_KEYS = (
+    "SDLK_UNKNOWN",
+    "SDLK_RETURN",
+    "SDLK_ESCAPE",
+    "SDLK_BACKSPACE",
+    "SDLK_TAB",
+    "SDLK_SPACE",
+    "SDLK_EXCLAIM",
+    "SDLK_QUOTEDBL",
+    "SDLK_HASH",
+    "SDLK_PERCENT",
+    "SDLK_DOLLAR",
+    "SDLK_AMPERSAND",
+    "SDLK_QUOTE",
+    "SDLK_LEFTPAREN",
+    "SDLK_RIGHTPAREN",
+    "SDLK_ASTERISK",
+    "SDLK_PLUS",
+    "SDLK_COMMA",
+    "SDLK_MINUS",
+    "SDLK_PERIOD",
+    "SDLK_SLASH",
+    "SDLK_0",
+    "SDLK_1",
+    "SDLK_2",
+    "SDLK_3",
+    "SDLK_4",
+    "SDLK_5",
+    "SDLK_6",
+    "SDLK_7",
+    "SDLK_8",
+    "SDLK_9",
+    "SDLK_COLON",
+    "SDLK_SEMICOLON",
+    "SDLK_LESS",
+    "SDLK_EQUALS",
+    "SDLK_GREATER",
+    "SDLK_QUESTION",
+    "SDLK_AT",
+    "SDLK_LEFTBRACKET",
+    "SDLK_BACKSLASH",
+    "SDLK_RIGHTBRACKET",
+    "SDLK_CARET",
+    "SDLK_UNDERSCORE",
+    "SDLK_BACKQUOTE",
+    "SDLK_a",
+    "SDLK_b",
+    "SDLK_c",
+    "SDLK_d",
+    "SDLK_e",
+    "SDLK_f",
+    "SDLK_g",
+    "SDLK_h",
+    "SDLK_i",
+    "SDLK_j",
+    "SDLK_k",
+    "SDLK_l",
+    "SDLK_m",
+    "SDLK_n",
+    "SDLK_o",
+    "SDLK_p",
+    "SDLK_q",
+    "SDLK_r",
+    "SDLK_s",
+    "SDLK_t",
+    "SDLK_u",
+    "SDLK_v",
+    "SDLK_w",
+    "SDLK_x",
+    "SDLK_y",
+    "SDLK_z",
+    "SDLK_CAPSLOCK",
+    "SDLK_F1",
+    "SDLK_F2",
+    "SDLK_F3",
+    "SDLK_F4",
+    "SDLK_F5",
+    "SDLK_F6",
+    "SDLK_F7",
+    "SDLK_F8",
+    "SDLK_F9",
+    "SDLK_F10",
+    "SDLK_F11",
+    "SDLK_F12",
+    "SDLK_PRINTSCREEN",
+    "SDLK_SCROLLLOCK",
+    "SDLK_PAUSE",
+    "SDLK_INSERT",
+    "SDLK_HOME",
+    "SDLK_PAGEUP",
+    "SDLK_DELETE",
+    "SDLK_END",
+    "SDLK_PAGEDOWN",
+    "SDLK_RIGHT",
+    "SDLK_LEFT",
+    "SDLK_DOWN",
+    "SDLK_UP",
+    "SDLK_NUMLOCKCLEAR",
+    "SDLK_KP_DIVIDE",
+    "SDLK_KP_MULTIPLY",
+    "SDLK_KP_MINUS",
+    "SDLK_KP_PLUS",
+    "SDLK_KP_ENTER",
+    "SDLK_KP_1",
+    "SDLK_KP_2",
+    "SDLK_KP_3",
+    "SDLK_KP_4",
+    "SDLK_KP_5",
+    "SDLK_KP_6",
+    "SDLK_KP_7",
+    "SDLK_KP_8",
+    "SDLK_KP_9",
+    "SDLK_KP_0",
+    "SDLK_KP_PERIOD",
+    "SDLK_APPLICATION",
+    "SDLK_POWER",
+    "SDLK_KP_EQUALS",
+    "SDLK_F13",
+    "SDLK_F14",
+    "SDLK_F15",
+    "SDLK_F16",
+    "SDLK_F17",
+    "SDLK_F18",
+    "SDLK_F19",
+    "SDLK_F20",
+    "SDLK_F21",
+    "SDLK_F22",
+    "SDLK_F23",
+    "SDLK_F24",
+    "SDLK_EXECUTE",
+    "SDLK_HELP",
+    "SDLK_MENU",
+    "SDLK_SELECT",
+    "SDLK_STOP",
+    "SDLK_AGAIN",
+    "SDLK_UNDO",
+    "SDLK_CUT",
+    "SDLK_COPY",
+    "SDLK_PASTE",
+    "SDLK_FIND",
+    "SDLK_MUTE",
+    "SDLK_VOLUMEUP",
+    "SDLK_VOLUMEDOWN",
+    "SDLK_KP_COMMA",
+    "SDLK_KP_EQUALSAS400",
+    "SDLK_ALTERASE",
+    "SDLK_SYSREQ",
+    "SDLK_CANCEL",
+    "SDLK_CLEAR",
+    "SDLK_PRIOR",
+    "SDLK_RETURN2",
+    "SDLK_SEPARATOR",
+    "SDLK_OUT",
+    "SDLK_OPER",
+    "SDLK_CLEARAGAIN",
+    "SDLK_CRSEL",
+    "SDLK_EXSEL",
+    "SDLK_KP_00",
+    "SDLK_KP_000",
+    "SDLK_THOUSANDSSEPARATOR",
+    "SDLK_DECIMALSEPARATOR",
+    "SDLK_CURRENCYUNIT",
+    "SDLK_CURRENCYSUBUNIT",
+    "SDLK_KP_LEFTPAREN",
+    "SDLK_KP_RIGHTPAREN",
+    "SDLK_KP_LEFTBRACE",
+    "SDLK_KP_RIGHTBRACE",
+    "SDLK_KP_TAB",
+    "SDLK_KP_BACKSPACE",
+    "SDLK_KP_A",
+    "SDLK_KP_B",
+    "SDLK_KP_C",
+    "SDLK_KP_D",
+    "SDLK_KP_E",
+    "SDLK_KP_F",
+    "SDLK_KP_XOR",
+    "SDLK_KP_POWER",
+    "SDLK_KP_PERCENT",
+    "SDLK_KP_LESS",
+    "SDLK_KP_GREATER",
+    "SDLK_KP_AMPERSAND",
+    "SDLK_KP_DBLAMPERSAND",
+    "SDLK_KP_VERTICALBAR",
+    "SDLK_KP_DBLVERTICALBAR",
+    "SDLK_KP_COLON",
+    "SDLK_KP_HASH",
+    "SDLK_KP_SPACE",
+    "SDLK_KP_AT",
+    "SDLK_KP_EXCLAM",
+    "SDLK_KP_MEMSTORE",
+    "SDLK_KP_MEMRECALL",
+    "SDLK_KP_MEMCLEAR",
+    "SDLK_KP_MEMADD",
+    "SDLK_KP_MEMSUBTRACT",
+    "SDLK_KP_MEMMULTIPLY",
+    "SDLK_KP_MEMDIVIDE",
+    "SDLK_KP_PLUSMINUS",
+    "SDLK_KP_CLEAR",
+    "SDLK_KP_CLEARENTRY",
+    "SDLK_KP_BINARY",
+    "SDLK_KP_OCTAL",
+    "SDLK_KP_DECIMAL",
+    "SDLK_KP_HEXADECIMAL",
+    "SDLK_LCTRL",
+    "SDLK_LSHIFT",
+    "SDLK_LALT",
+    "SDLK_LGUI",
+    "SDLK_RCTRL",
+    "SDLK_RSHIFT",
+    "SDLK_RALT",
+    "SDLK_RGUI",
+    "SDLK_MODE",
+    "SDLK_AUDIONEXT",
+    "SDLK_AUDIOPREV",
+    "SDLK_AUDIOSTOP",
+    "SDLK_AUDIOPLAY",
+    "SDLK_AUDIOMUTE",
+    "SDLK_MEDIASELECT",
+    "SDLK_WWW",
+    "SDLK_MAIL",
+    "SDLK_CALCULATOR",
+    "SDLK_COMPUTER",
+    "SDLK_AC_SEARCH",
+    "SDLK_AC_HOME",
+    "SDLK_AC_BACK",
+    "SDLK_AC_FORWARD",
+    "SDLK_AC_STOP",
+    "SDLK_AC_REFRESH",
+    "SDLK_AC_BOOKMARKS",
+    "SDLK_BRIGHTNESSDOWN",
+    "SDLK_BRIGHTNESSUP",
+    "SDLK_DISPLAYSWITCH",
+    "SDLK_KBDILLUMTOGGLE",
+    "SDLK_KBDILLUMDOWN",
+    "SDLK_KBDILLUMUP",
+    "SDLK_EJECT",
+    "SDLK_SLEEP",
+    "SDLK_APP1",
+    "SDLK_APP2",
+    "SDLK_AUDIOREWIND",
+    "SDLK_AUDIOFASTFORWARD",
+    "SDLK_SOFTLEFT",
+    "SDLK_SOFTRIGHT",
+    "SDLK_CALL",
+    "SDLK_ENDCALL",
+)
+
+SDL_KEYMAP = {key: getattr(SDL_KeyCode, key) for key in SDL_KEYS}
 
 CONFIG_SCHEMA = (
     binary_sensor.binary_sensor_schema(BinarySensor)

esphome/components/sdl/display.py

@@ -4,7 +4,6 @@ from typing import Any
 
 import esphome.codegen as cg
 from esphome.components import display
-from esphome.components.snapshot import Snapshot, register_snapshot
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_DIMENSIONS,
@@ -17,21 +16,14 @@ from esphome.const import (
     CONF_Y,
     PLATFORM_HOST,
 )
-import esphome.final_validate as fv
 from esphome.types import ConfigType
 
-from . import SDL_KEYMAP
-
-AUTO_LOAD = ["snapshot"]
-
 sdl_ns = cg.esphome_ns.namespace("sdl")
-Sdl = sdl_ns.class_("Sdl", display.Display, cg.Component, Snapshot)
+Sdl = sdl_ns.class_("Sdl", display.Display, cg.Component)
 sdl_window_flags = cg.global_ns.enum("SDL_WindowFlags")
 
 
 CONF_CENTERED_ON_DISPLAY = "centered_on_display"
-CONF_HEADLESS = "headless"
-CONF_SNAPSHOT_KEY = "snapshot_key"
 CONF_SDL_OPTIONS = "sdl_options"
 CONF_SDL_ID = "sdl_id"
 CONF_WINDOW_OPTIONS = "window_options"
@@ -75,29 +67,12 @@ def _validate_position(config: dict) -> dict:
     raise cv.Invalid("Must specify either 'x' and 'y' or 'centered_on_display'")
 
 
-def _validate_headless(config: ConfigType) -> ConfigType:
-    if not config[CONF_HEADLESS]:
-        return config
-    if CONF_WINDOW_OPTIONS in config:
-        raise cv.Invalid(
-            f"'{CONF_WINDOW_OPTIONS}' has no effect when '{CONF_HEADLESS}' is set - there is no window"
-        )
-    if CONF_SNAPSHOT_KEY in config:
-        raise cv.Invalid(
-            f"'{CONF_SNAPSHOT_KEY}' cannot be used when '{CONF_HEADLESS}' is set - "
-            f"there is no keyboard. Use the 'snapshot.take' action instead"
-        )
-    return config
-
-
 CONFIG_SCHEMA = cv.All(
     display.FULL_DISPLAY_SCHEMA.extend(
         cv.Schema(
             {
                 cv.GenerateID(): cv.declare_id(Sdl),
                 cv.Optional(CONF_SDL_OPTIONS, default=""): get_sdl_options,
-                cv.Optional(CONF_HEADLESS, default=False): cv.boolean,
-                cv.Optional(CONF_SNAPSHOT_KEY): cv.enum(SDL_KEYMAP),
                 cv.Required(CONF_DIMENSIONS): cv.Any(
                     cv.dimensions,
                     cv.Schema(
@@ -124,42 +99,16 @@ CONFIG_SCHEMA = cv.All(
             }
         )
     ),
-    _validate_headless,
     cv.only_on(PLATFORM_HOST),
 )
 
 
-def headless_final_validate(platform: str) -> cv.Schema:
-    """Build a FINAL_VALIDATE_SCHEMA rejecting a platform whose sdl display is headless.
-
-    Mouse and keyboard platforms are driven by window events, so under a headless display they
-    would never report anything.
-    """
-
-    def validate_display(display_config: ConfigType) -> ConfigType:
-        if display_config.get(CONF_HEADLESS):
-            raise cv.Invalid(
-                f"The sdl {platform} platform needs a window, but its display has "
-                f"'{CONF_HEADLESS}' set"
-            )
-        return display_config
-
-    return cv.Schema(
-        {cv.Required(CONF_SDL_ID): fv.id_declaration_match_schema(validate_display)},
-        extra=cv.ALLOW_EXTRA,
-    )
-
-
 async def to_code(config: ConfigType) -> None:
     for option in config[CONF_SDL_OPTIONS].split():
         cg.add_build_flag(option)
     cg.add_build_flag("-DSDL_BYTEORDER=4321")
     var = cg.new_Pvariable(config[CONF_ID])
     await display.register_display(var, config)
-    await register_snapshot(var, config)
-    cg.add(var.set_headless(config[CONF_HEADLESS]))
-    if (key := config.get(CONF_SNAPSHOT_KEY)) is not None:
-        cg.add(var.set_snapshot_key(key))
 
     dimensions = config[CONF_DIMENSIONS]
     if isinstance(dimensions, dict):

esphome/components/sdl/sdl_esphome.cpp

@@ -2,17 +2,8 @@
 #include "sdl_esphome.h"
 #include "esphome/components/display/display_color_utils.h"
 
-#include <cstdlib>
-
 namespace esphome::sdl {
 
-namespace {
-
-// Key under which each window keeps a pointer back to its Sdl instance.
-constexpr const char *const WINDOW_DATA_KEY = "esphome_sdl";
-
-}  // namespace
-
 int Sdl::get_width() {
   switch (this->rotation_) {
     case display::DISPLAY_ROTATION_90_DEGREES:
@@ -37,96 +28,17 @@ int Sdl::get_height() {
   }
 }
 
-void Sdl::destroy_renderer_() {
-  // Reverse order of creation: the renderer refers to the window or surface it was made from.
-  if (this->shot_target_ != nullptr) {
-    SDL_DestroyTexture(this->shot_target_);
-    this->shot_target_ = nullptr;
-  }
-  if (this->texture_ != nullptr) {
-    SDL_DestroyTexture(this->texture_);
-    this->texture_ = nullptr;
-  }
-  if (this->renderer_ != nullptr) {
-    SDL_DestroyRenderer(this->renderer_);
-    this->renderer_ = nullptr;
-  }
-  if (this->window_ != nullptr) {
-    SDL_DestroyWindow(this->window_);
-    this->window_ = nullptr;
-  }
-  if (this->surface_ != nullptr) {
-    SDL_FreeSurface(this->surface_);
-    this->surface_ = nullptr;
-  }
-}
-
-bool Sdl::setup_failed_(const char *what) {
-  ESP_LOGE(TAG, "%s: %s", what, SDL_GetError());
-  // Give back whatever was created before the failure. Without this a half set up display leaves an
-  // empty window on screen for the life of the process, still registered as an event target.
-  this->destroy_renderer_();
-  return false;
-}
-
-bool Sdl::setup_renderer_() {
-  SDL_SetMainReady();
-  if (this->headless_) {
-    // SDL_INIT_VIDEO is deliberately not requested: a software renderer bound to a surface needs no
-    // video device, so this works on a machine with no display server at all.
-    if (SDL_Init(0) != 0)
-      return this->setup_failed_("SDL_Init failed");
-    this->surface_ = SDL_CreateRGBSurfaceWithFormat(0, this->width_, this->height_, 16, SDL_PIXELFORMAT_RGB565);
-    if (this->surface_ == nullptr)
-      return this->setup_failed_("Could not create offscreen surface");
-    this->renderer_ = SDL_CreateSoftwareRenderer(this->surface_);
-  } else {
-    if (SDL_Init(SDL_INIT_VIDEO) != 0)
-      return this->setup_failed_("SDL_Init failed");
-    this->window_ = SDL_CreateWindow(App.get_name().c_str(), this->pos_x_, this->pos_y_, this->width_, this->height_,
-                                     this->window_options_);
-    if (this->window_ == nullptr)
-      return this->setup_failed_("Could not create window");
-    // Lets loop() find the display an event belongs to, so one display does not act on another's
-    // input when several windows are open.
-    SDL_SetWindowData(this->window_, WINDOW_DATA_KEY, this);
-    this->renderer_ = SDL_CreateRenderer(this->window_, -1, SDL_RENDERER_SOFTWARE);
-  }
-  if (this->renderer_ == nullptr)
-    return this->setup_failed_("Could not create renderer");
-  if (SDL_RenderSetLogicalSize(this->renderer_, this->width_, this->height_) != 0)
-    return this->setup_failed_("Could not set renderer logical size");
+void Sdl::setup() {
+  SDL_Init(SDL_INIT_VIDEO);
+  this->window_ = SDL_CreateWindow(App.get_name().c_str(), this->pos_x_, this->pos_y_, this->width_, this->height_,
+                                   this->window_options_);
+  this->renderer_ = SDL_CreateRenderer(this->window_, -1, SDL_RENDERER_SOFTWARE);
+  SDL_RenderSetLogicalSize(this->renderer_, this->width_, this->height_);
   this->texture_ =
       SDL_CreateTexture(this->renderer_, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_STATIC, this->width_, this->height_);
-  if (this->texture_ == nullptr)
-    return this->setup_failed_("Could not create texture");
-  // The texture has no alpha channel, so blending is pointless. Headless it would also force a
-  // different software blit path onto the 16 bit target surface.
-  if (SDL_SetTextureBlendMode(this->texture_, this->headless_ ? SDL_BLENDMODE_NONE : SDL_BLENDMODE_BLEND) != 0)
-    return this->setup_failed_("Could not set texture blend mode");
-  return true;
+  SDL_SetTextureBlendMode(this->texture_, SDL_BLENDMODE_BLEND);
 }
-
-void Sdl::setup() {
-  if (!this->setup_renderer_()) {
-    this->mark_failed();
-    return;
-  }
-  if (this->headless_) {
-    // Nothing generates events, so there is nothing for loop() to do.
-    this->disable_loop();
-  } else if (this->snapshot_key_ != 0) {
-    this->add_key_listener(this->snapshot_key_, [this](bool down) {
-      if (down && !this->take_snapshot(nullptr)) {
-        ESP_LOGW(TAG, "snapshot key did not write a file");
-      }
-    });
-  }
-}
-
 void Sdl::update() {
-  if (this->texture_ == nullptr)
-    return;
   this->do_update_();
   if ((this->x_high_ < this->x_low_) || (this->y_high_ < this->y_low_))
     return;
@@ -139,19 +51,12 @@ void Sdl::update() {
 }
 
 void Sdl::redraw_(SDL_Rect &rect) {
-  // Nothing to present when headless - a snapshot blits the whole texture when it needs it, so
-  // doing it here as well would just burn CPU. draw_pixels_at() calls this on every partial
-  // update, so it is worth skipping.
-  if (this->headless_)
-    return;
   SDL_RenderCopy(this->renderer_, this->texture_, &rect, &rect);
   SDL_RenderPresent(this->renderer_);
 }
 
 void Sdl::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
                          display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
-  if (this->texture_ == nullptr)
-    return;
   SDL_Rect rect{x_start, y_start, w, h};
   if (this->rotation_ != display::DISPLAY_ROTATION_0_DEGREES || bitness != display::COLOR_BITNESS_565 || big_endian) {
     Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
@@ -164,7 +69,7 @@ void Sdl::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *
 }
 
 void Sdl::draw_pixel_at(int x, int y, Color color) {
-  if (this->texture_ == nullptr || !this->get_clipping().inside(x, y))
+  if (!this->get_clipping().inside(x, y))
     return;
 
   if (this->rotation_ == display::DISPLAY_ROTATION_180_DEGREES) {
@@ -199,148 +104,61 @@ void Sdl::process_key(uint32_t keycode, bool down) {
     callback->second(down);
 }
 
-Sdl *Sdl::instance_for_window_(uint32_t window_id) {
-  SDL_Window *window = SDL_GetWindowFromID(window_id);
-  if (window == nullptr)
-    return nullptr;
-  return static_cast<Sdl *>(SDL_GetWindowData(window, WINDOW_DATA_KEY));
-}
-
-void Sdl::handle_event_(const SDL_Event &event) {
-  switch (event.type) {
-    case SDL_MOUSEBUTTONDOWN:
-    case SDL_MOUSEBUTTONUP:
-      if (event.button.button == 1) {
-        this->mouse_x = event.button.x;
-        this->mouse_y = event.button.y;
-        this->mouse_down = event.button.state != 0;
-      }
-      break;
-
-    case SDL_MOUSEMOTION:
-      if (event.motion.state & 1) {
-        this->mouse_x = event.motion.x;
-        this->mouse_y = event.motion.y;
-        this->mouse_down = true;
-      } else {
-        this->mouse_down = false;
-      }
-      break;
-
-    case SDL_KEYDOWN:
-      // Ignore auto-repeat, otherwise holding a key floods the listeners.
-      if (event.key.repeat != 0)
-        break;
-      ESP_LOGD(TAG, "keydown %d", event.key.keysym.sym);
-      this->process_key(event.key.keysym.sym, true);
-      break;
-
-    case SDL_KEYUP:
-      ESP_LOGD(TAG, "keyup %d", event.key.keysym.sym);
-      this->process_key(event.key.keysym.sym, false);
-      break;
-
-    case SDL_WINDOWEVENT:
-      switch (event.window.event) {
-        case SDL_WINDOWEVENT_SIZE_CHANGED:
-        case SDL_WINDOWEVENT_EXPOSED:
-        case SDL_WINDOWEVENT_RESIZED: {
-          SDL_Rect rect{0, 0, this->width_, this->height_};
-          this->redraw_(rect);
-          break;
-        }
-        default:
-          break;
-      }
-      break;
-
-    default:
-      break;
-  }
-}
-
 void Sdl::loop() {
   SDL_Event e;
-  // Take everything that is waiting, not one event per loop. A touch drag produces a burst of
-  // motion events, and consuming them one at a time lets the queue grow without bound, so the
-  // pointer ends up acting on input from further and further in the past. Draining collapses a
-  // burst to the position it ended at, which is the one the user is asking for anyway.
-  while (SDL_PollEvent(&e)) {
-    if (e.type == SDL_QUIT)
-      exit(0);
-
-    // Events carry the window they happened in, so send each one to the display that owns it.
-    uint32_t window_id;
+  if (SDL_PollEvent(&e)) {
     switch (e.type) {
+      case SDL_QUIT:
+        exit(0);
+
       case SDL_MOUSEBUTTONDOWN:
       case SDL_MOUSEBUTTONUP:
-        window_id = e.button.windowID;
+        if (e.button.button == 1) {
+          this->mouse_x = e.button.x;
+          this->mouse_y = e.button.y;
+          this->mouse_down = e.button.state != 0;
+        }
         break;
+
       case SDL_MOUSEMOTION:
-        window_id = e.motion.windowID;
+        if (e.motion.state & 1) {
+          this->mouse_x = e.button.x;
+          this->mouse_y = e.button.y;
+          this->mouse_down = true;
+        } else {
+          this->mouse_down = false;
+        }
         break;
+
       case SDL_KEYDOWN:
+        ESP_LOGD(TAG, "keydown %d", e.key.keysym.sym);
+        this->process_key(e.key.keysym.sym, true);
+        break;
+
       case SDL_KEYUP:
-        window_id = e.key.windowID;
+        ESP_LOGD(TAG, "keyup %d", e.key.keysym.sym);
+        this->process_key(e.key.keysym.sym, false);
         break;
+
       case SDL_WINDOWEVENT:
-        window_id = e.window.windowID;
+        switch (e.window.event) {
+          case SDL_WINDOWEVENT_SIZE_CHANGED:
+          case SDL_WINDOWEVENT_EXPOSED:
+          case SDL_WINDOWEVENT_RESIZED: {
+            SDL_Rect rect{0, 0, this->width_, this->height_};
+            this->redraw_(rect);
+            break;
+          }
+          default:
+            break;
+        }
         break;
+
       default:
-        // Anything else, including the touch events SDL reports alongside the mouse events it
-        // synthesises from them, is not used here.
         ESP_LOGV(TAG, "Event %d", e.type);
-        continue;
-    }
-
-    Sdl *target = instance_for_window_(window_id);
-    if (target == nullptr) {
-      // Nothing to route this to: the window has gone, or it is not one of ours. Say so, otherwise
-      // input that stops working leaves no trace at all.
-      ESP_LOGV(TAG, "Event %d for unknown window %u", e.type, window_id);
-      continue;
-    }
-    target->handle_event_(e);
-  }
-}
-
-bool Sdl::capture_bgr(uint8_t *dest, size_t row_stride) {
-  if (this->texture_ == nullptr || this->renderer_ == nullptr) {
-    ESP_LOGE(TAG, "Snapshot requested but SDL is not set up");
-    return false;
-  }
-  if (this->shot_target_ == nullptr) {
-    this->shot_target_ = SDL_CreateTexture(this->renderer_, SDL_PIXELFORMAT_RGB565, SDL_TEXTUREACCESS_TARGET,
-                                           this->width_, this->height_);
-    if (this->shot_target_ == nullptr) {
-      ESP_LOGE(TAG, "Could not create capture texture: %s", SDL_GetError());
-      return false;
-    }
-    SDL_SetTextureBlendMode(this->shot_target_, SDL_BLENDMODE_NONE);
-  }
-
-  // Render into an offscreen target first. SDL_RenderReadPixels works in physical output pixels and
-  // ignores the logical size, so reading straight off a resizable window would read more pixels than
-  // there is room for.
-  // Every step is checked: a failed clear or copy would otherwise be read back as a blank or stale
-  // picture, written out, and reported as a snapshot that worked.
-  bool ok = false;
-  if (SDL_SetRenderTarget(this->renderer_, this->shot_target_) == 0) {
-    ok = SDL_SetRenderDrawColor(this->renderer_, 0, 0, 0, SDL_ALPHA_OPAQUE) == 0 &&
-         SDL_RenderClear(this->renderer_) == 0 &&
-         SDL_RenderCopy(this->renderer_, this->texture_, nullptr, nullptr) == 0 &&
-         SDL_RenderReadPixels(this->renderer_, nullptr, SDL_PIXELFORMAT_BGR24, dest, static_cast<int>(row_stride)) == 0;
-    if (SDL_SetRenderTarget(this->renderer_, nullptr) != 0) {
-      // Stuck rendering into shot_target_ from here on, so there's no point continuing.
-      ESP_LOGE(TAG, "Could not restore the render target: %s", SDL_GetError());
-      this->mark_failed();
-      return false;
+        break;
     }
   }
-  if (!ok) {
-    ESP_LOGE(TAG, "Could not capture the screen: %s", SDL_GetError());
-  }
-  return ok;
 }
 
 }  // namespace esphome::sdl

esphome/components/sdl/sdl_esphome.h

@@ -1,12 +1,10 @@
 #pragma once
 
 #ifdef USE_HOST
-#include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/log.h"
 #include "esphome/core/application.h"
 #include "esphome/components/display/display.h"
-#include "esphome/components/snapshot/snapshot.h"
 #define SDL_MAIN_HANDLED
 #include "SDL.h"
 #include <map>
@@ -15,7 +13,7 @@ namespace esphome::sdl {
 
 constexpr static const char *const TAG = "sdl";
 
-class Sdl final : public display::Display, public snapshot::Snapshot {
+class Sdl final : public display::Display {
  public:
   display::DisplayType get_display_type() override { return display::DISPLAY_TYPE_COLOR; }
   void update() override;
@@ -34,9 +32,6 @@ class Sdl final : public display::Display, public snapshot::Snapshot {
     this->pos_x_ = pos_x;
     this->pos_y_ = pos_y;
   }
-  void set_headless(bool headless) { this->headless_ = headless; }
-  void set_snapshot_key(int32_t keycode) { this->snapshot_key_ = keycode; }
-
   int get_width() override;
   int get_height() override;
   float get_setup_priority() const override { return setup_priority::HARDWARE; }
@@ -56,40 +51,20 @@ class Sdl final : public display::Display, public snapshot::Snapshot {
   int get_width_internal() override { return this->width_; }
   int get_height_internal() override { return this->height_; }
   void redraw_(SDL_Rect &rect);
-  bool setup_renderer_();
-  /// Release the window, surface, renderer and textures, and forget them.
-  void destroy_renderer_();
-  /// Log an SDL failure during setup, release anything already created, and return false.
-  bool setup_failed_(const char *what);
-  int snapshot_width() override { return this->width_; }
-  int snapshot_height() override { return this->height_; }
-  bool capture_bgr(uint8_t *dest, size_t row_stride) override;
-  void handle_event_(const SDL_Event &event);
-  /// The display owning the given window, or nullptr if it is not one of ours.
-  static Sdl *instance_for_window_(uint32_t window_id);
-  SDL_Renderer *renderer_{};
-  SDL_Window *window_{};
-  SDL_Texture *texture_{};
-  // Offscreen render target used when headless. SDL_CreateSoftwareRenderer only borrows the
-  // surface, and the renderer goes back to using it as its output whenever the capture target is
-  // released, so it has to stay alive as long as the renderer does.
-  SDL_Surface *surface_{};
-  // Capture target, created on first snapshot.
-  SDL_Texture *shot_target_{};
-  std::map<int32_t, CallbackManager<void(bool)>> key_callbacks_{};
   int width_{};
   int height_{};
   uint32_t window_options_{0};
   int32_t pos_x_{SDL_WINDOWPOS_UNDEFINED};
   int32_t pos_y_{SDL_WINDOWPOS_UNDEFINED};
-  int32_t snapshot_key_{0};
+  SDL_Renderer *renderer_{};
+  SDL_Window *window_{};
+  SDL_Texture *texture_{};
   uint16_t x_low_{0};
   uint16_t y_low_{0};
   uint16_t x_high_{0};
   uint16_t y_high_{0};
-  bool headless_{false};
+  std::map<int32_t, CallbackManager<void(bool)>> key_callbacks_{};
 };
-
 }  // namespace esphome::sdl
 
 #endif

esphome/components/sdl/touchscreen/__init__.py

@@ -4,12 +4,10 @@ import esphome.config_validation as cv
 from esphome.const import CONF_ID
 from esphome.types import ConfigType
 
-from ..display import CONF_SDL_ID, Sdl, headless_final_validate, sdl_ns
+from ..display import CONF_SDL_ID, Sdl, sdl_ns
 
 SdlTouchscreen = sdl_ns.class_("SdlTouchscreen", touchscreen.Touchscreen)
 
-FINAL_VALIDATE_SCHEMA = headless_final_validate("touchscreen")
-
 
 CONFIG_SCHEMA = touchscreen.TOUCHSCREEN_SCHEMA.extend(
     {

esphome/components/seeed_mr60fda2/__init__.py

@@ -31,7 +31,6 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
     require_tx=True,
     require_rx=True,
     baud_rate=115200,
-    data_bits=8,
     parity="NONE",
     stop_bits=1,
 )

esphome/components/seeed_mr60fda2/seeed_mr60fda2.cpp

@@ -33,6 +33,8 @@ void MR60FDA2Component::dump_config() {
 
 // Initialisation functions
 void MR60FDA2Component::setup() {
+  this->check_uart_settings(115200);
+
   this->current_frame_locate_ = LOCATE_FRAME_HEADER;
   this->current_frame_id_ = 0;
   this->current_frame_len_ = 0;

esphome/components/serial_proxy/serial_proxy.cpp

@@ -130,26 +130,17 @@ SerialProxyResult SerialProxy::configure(api::APIConnection *api_connection, uin
     return SerialProxyResult::SERIAL_PROXY_RESULT_NOT_SUPPORTED;
   }
 
-  // Skip a no-op reconfigure. Clients routinely re-send identical settings on every
-  // port open, and on a USB UART each apply is a CDC SET_LINE_CODING control transfer.
-  // Some bridges watch line-coding changes as a signalling channel (a magic baud
-  // sequence to enter a bootloader, say), so redundant applies are not harmless.
-  static const uart::UARTParityOptions PARITY_MAP[] = {
-      uart::UART_CONFIG_PARITY_NONE,
-      uart::UART_CONFIG_PARITY_EVEN,
-      uart::UART_CONFIG_PARITY_ODD,
-  };
-  if (uart_comp->get_baud_rate() == baudrate && uart_comp->get_stop_bits() == stop_bits &&
-      uart_comp->get_data_bits() == data_size && uart_comp->get_parity() == PARITY_MAP[parity]) {
-    ESP_LOGV(TAG, "Settings unchanged, skipping reconfigure [%" PRIu32 "]", this->instance_index_);
-    return SerialProxyResult::SERIAL_PROXY_RESULT_OK;
-  }
-
   // Apply validated parameters
   uart_comp->set_baud_rate(baudrate);
   uart_comp->set_stop_bits(stop_bits);
   uart_comp->set_data_bits(data_size);
 
+  // Map parity value to UARTParityOptions
+  static const uart::UARTParityOptions PARITY_MAP[] = {
+      uart::UART_CONFIG_PARITY_NONE,
+      uart::UART_CONFIG_PARITY_EVEN,
+      uart::UART_CONFIG_PARITY_ODD,
+  };
   uart_comp->set_parity(PARITY_MAP[parity]);
 
   // load_settings() is available on ESP8266 and ESP32 platforms

esphome/components/smt100/sensor.py

@@ -68,13 +68,7 @@ CONFIG_SCHEMA = (
 )
 
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "smt100",
-    baud_rate=9600,
-    require_rx=True,
-    require_tx=True,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
+    "smt100", baud_rate=9600, require_rx=True, require_tx=True
 )
 
 

esphome/components/smt100/smt100.cpp

@@ -65,6 +65,7 @@ void SMT100Component::dump_config() {
   LOG_SENSOR(TAG, "Temperature", this->temperature_sensor_);
   LOG_SENSOR(TAG, "Moisture", this->moisture_sensor_);
   LOG_UPDATE_INTERVAL(this);
+  this->check_uart_settings(9600);
 }
 
 int SMT100Component::readline_(int readch, char *buffer, int len) {

esphome/components/snapshot/__init__.py

@@ -1,76 +0,0 @@
-"""Shared support for writing what a display is showing out to an image file.
-
-The component itself has no configuration. It provides the ``snapshot.take`` action and the C++
-base class behind it, so any display that can hand over its pixels - the in memory display in this
-component, or an SDL window - saves files the same way, under the same directory, with the same
-rules about names.
-"""
-
-from dataclasses import dataclass
-
-from esphome import automation
-import esphome.codegen as cg
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
-from esphome.core import CORE, ID
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType, TemplateArgsType
-
-CODEOWNERS = ["@clydebarrow"]
-
-DOMAIN = "snapshot"
-
-CONF_FILENAME = "filename"
-
-snapshot_ns = cg.esphome_ns.namespace("snapshot")
-Snapshot = snapshot_ns.class_("Snapshot")
-SnapshotAction = snapshot_ns.class_("SnapshotAction", automation.Action)
-
-
-@automation.register_action(
-    "snapshot.take",
-    SnapshotAction,
-    automation.maybe_simple_id(
-        {
-            cv.GenerateID(): cv.use_id(Snapshot),
-            cv.Optional(CONF_FILENAME): cv.templatable(cv.string),
-        }
-    ),
-    synchronous=True,
-)
-async def snapshot_take_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> MockObj:
-    var = cg.new_Pvariable(action_id, template_arg)
-    await cg.register_parented(var, config[CONF_ID])
-    if (filename := config.get(CONF_FILENAME)) is not None:
-        cg.add(var.set_filename(await cg.templatable(filename, args, cg.std_string)))
-    return var
-
-
-@dataclass
-class SnapshotData:
-    directory_defined: bool = False
-
-
-def _get_data() -> SnapshotData:
-    if DOMAIN not in CORE.data:
-        CORE.data[DOMAIN] = SnapshotData()
-    return CORE.data[DOMAIN]
-
-
-async def register_snapshot(var: MockObj, config: ConfigType) -> None:
-    """Set up a component so that the snapshot action can write its picture to a file."""
-    data = _get_data()
-    # Only once, however many displays there are: two defines that say the same thing do not
-    # compare equal, so asking for this per display repeats the line in defines.h.
-    if not data.directory_defined:
-        data.directory_defined = True
-        cg.add_define(
-            "ESPHOME_SNAPSHOT_DIR",
-            (CORE.data_dir / "snapshots" / CORE.name).as_posix(),
-        )
-    cg.add(var.set_snapshot_prefix(str(config[CONF_ID])))

esphome/components/snapshot/display/__init__.py

@@ -1,61 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import display
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_DIMENSIONS,
-    CONF_HEIGHT,
-    CONF_ID,
-    CONF_LAMBDA,
-    CONF_WIDTH,
-    PLATFORM_HOST,
-)
-from esphome.types import ConfigType
-
-from .. import Snapshot, register_snapshot, snapshot_ns
-
-# The base class and the file writing live in the parent component, which nothing else in a
-# configuration using only this platform would pull in.
-AUTO_LOAD = ["snapshot"]
-
-SnapshotDisplay = snapshot_ns.class_(
-    "SnapshotDisplay", display.DisplayBuffer, cg.Component, Snapshot
-)
-
-CONFIG_SCHEMA = cv.All(
-    display.FULL_DISPLAY_SCHEMA.extend(
-        cv.Schema(
-            {
-                cv.GenerateID(): cv.declare_id(SnapshotDisplay),
-                cv.Required(CONF_DIMENSIONS): cv.Any(
-                    cv.dimensions,
-                    cv.Schema(
-                        {
-                            cv.Required(CONF_WIDTH): cv.positive_not_null_int,
-                            cv.Required(CONF_HEIGHT): cv.positive_not_null_int,
-                        }
-                    ),
-                ),
-            }
-        )
-    ),
-    cv.only_on(PLATFORM_HOST),
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    var = cg.new_Pvariable(config[CONF_ID])
-    await display.register_display(var, config)
-    await register_snapshot(var, config)
-
-    dimensions = config[CONF_DIMENSIONS]
-    if isinstance(dimensions, dict):
-        cg.add(var.set_dimensions(dimensions[CONF_WIDTH], dimensions[CONF_HEIGHT]))
-    else:
-        (width, height) = dimensions
-        cg.add(var.set_dimensions(width, height))
-
-    if lamb := config.get(CONF_LAMBDA):
-        lambda_ = await cg.process_lambda(
-            lamb, [(display.DisplayRef, "it")], return_type=cg.void
-        )
-        cg.add(var.set_writer(lambda_))

esphome/components/snapshot/display/snapshot_display.cpp

@@ -1,80 +0,0 @@
-#ifdef USE_HOST
-#include "snapshot_display.h"
-#include "esphome/components/display/display_color_utils.h"
-#include "esphome/core/log.h"
-
-#include <cstring>
-
-namespace esphome::snapshot {
-
-static const char *const TAG = "snapshot.display";
-
-namespace {
-
-/// Spread a channel that only goes up to `max` over the whole 0 to 255 range, so that the
-/// brightest value stays the brightest. This is the same arithmetic SDL uses, which is what makes
-/// a picture taken here come out identical to the same picture taken from an SDL window.
-constexpr uint8_t expand_channel(uint16_t value, uint16_t max) { return static_cast<uint8_t>(value * 255 / max); }
-
-constexpr uint16_t RED_MAX = 0x1F;
-constexpr uint16_t GREEN_MAX = 0x3F;
-constexpr uint16_t BLUE_MAX = 0x1F;
-
-}  // namespace
-
-void SnapshotDisplay::setup() {
-  this->init_internal_(static_cast<uint32_t>(this->width_) * this->height_ * 2);
-  if (this->buffer_ == nullptr) {
-    this->mark_failed(LOG_STR("Could not allocate display buffer"));
-  }
-}
-
-void SnapshotDisplay::dump_config() { LOG_DISPLAY("", "Snapshot", this); }
-
-void SnapshotDisplay::draw_absolute_pixel_internal(int x, int y, Color color) {
-  if (this->buffer_ == nullptr || x < 0 || x >= this->width_ || y < 0 || y >= this->height_)
-    return;
-  this->pixels_()[y * this->width_ + x] = display::ColorUtil::color_to_565(color, display::COLOR_ORDER_RGB);
-}
-
-void SnapshotDisplay::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr,
-                                     display::ColorOrder order, display::ColorBitness bitness, bool big_endian,
-                                     int x_offset, int y_offset, int x_pad) {
-  if (this->buffer_ == nullptr)
-    return;
-  // Anything that is not already laid out the way the buffer is, or that would reach outside it,
-  // goes through the base class, which turns it into one call per pixel with the bounds checked.
-  const bool copyable = this->rotation_ == display::DISPLAY_ROTATION_0_DEGREES &&
-                        bitness == display::COLOR_BITNESS_565 && !big_endian && x_start >= 0 && y_start >= 0 &&
-                        x_start + w <= this->width_ && y_start + h <= this->height_;
-  if (!copyable) {
-    DisplayBuffer::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
-    return;
-  }
-  const size_t stride = static_cast<size_t>(x_offset) + w + x_pad;
-  const uint8_t *src = ptr + (stride * y_offset + x_offset) * 2;
-  for (int y = 0; y != h; y++) {
-    memcpy(&this->pixels_()[(y_start + y) * this->width_ + x_start], src + y * stride * 2, w * 2);
-  }
-}
-
-bool SnapshotDisplay::capture_bgr(uint8_t *dest, size_t row_stride) {
-  if (this->buffer_ == nullptr) {
-    ESP_LOGE(TAG, "Snapshot requested but there is no buffer to read");
-    return false;
-  }
-  const uint16_t *src = this->pixels_();
-  for (int y = 0; y != this->height_; y++) {
-    uint8_t *out = dest + y * row_stride;
-    for (int x = 0; x != this->width_; x++) {
-      const uint16_t pixel = *src++;
-      *out++ = expand_channel(pixel & BLUE_MAX, BLUE_MAX);
-      *out++ = expand_channel((pixel >> 5) & GREEN_MAX, GREEN_MAX);
-      *out++ = expand_channel(pixel >> 11, RED_MAX);
-    }
-  }
-  return true;
-}
-
-}  // namespace esphome::snapshot
-#endif

esphome/components/snapshot/display/snapshot_display.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#ifdef USE_HOST
-#include "esphome/components/display/display_buffer.h"
-#include "esphome/components/snapshot/snapshot.h"
-#include "esphome/core/component.h"
-
-namespace esphome::snapshot {
-
-/// A display with nowhere to show anything: it keeps the picture in memory, where the snapshot
-/// action can pick it up. That makes it a way to see what a configuration draws on a machine with
-/// no screen, and to check the result in a test.
-class SnapshotDisplay final : public display::DisplayBuffer, public Snapshot {
- public:
-  void setup() override;
-  void update() override { this->do_update_(); }
-  void dump_config() override;
-  float get_setup_priority() const override { return setup_priority::HARDWARE; }
-  display::DisplayType get_display_type() override { return display::DISPLAY_TYPE_COLOR; }
-
-  void set_dimensions(uint16_t width, uint16_t height) {
-    this->width_ = width;
-    this->height_ = height;
-  }
-
-  void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, display::ColorOrder order,
-                      display::ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
-
- protected:
-  void draw_absolute_pixel_internal(int x, int y, Color color) override;
-  int get_width_internal() override { return this->width_; }
-  int get_height_internal() override { return this->height_; }
-
-  int snapshot_width() override { return this->width_; }
-  int snapshot_height() override { return this->height_; }
-  bool capture_bgr(uint8_t *dest, size_t row_stride) override;
-
-  /// The picture, one 16 bit RGB565 value per pixel, topmost row first. Owned by DisplayBuffer as
-  /// a byte pointer; this is the same memory seen as what is actually stored in it.
-  uint16_t *pixels_() { return reinterpret_cast<uint16_t *>(this->buffer_); }
-
-  int width_{};
-  int height_{};
-};
-
-}  // namespace esphome::snapshot
-
-#endif

esphome/components/snapshot/snapshot.cpp

@@ -1,248 +0,0 @@
-#ifdef USE_HOST
-#include "snapshot.h"
-#include "esphome/core/log.h"
-
-#include <fcntl.h>
-#include <strings.h>
-#include <unistd.h>
-#include <cctype>
-#include <cerrno>
-#include <cstdio>
-#include <cstring>
-#include <ctime>
-#include <filesystem>
-#include <memory>
-
-namespace esphome::snapshot {
-
-namespace {
-
-constexpr const char *const TAG = "snapshot";
-
-// Longest name we will build a path from. NAME_MAX is 255 and we may append a collision suffix.
-constexpr size_t MAX_NAME_LENGTH = 200;
-// Give up rather than spin forever if every candidate name is taken.
-constexpr unsigned MAX_NAME_ATTEMPTS = 1000;
-// A BMP file header followed by a BITMAPINFOHEADER, which is where the pixels start.
-constexpr size_t BMP_HEADER_SIZE = 54;
-constexpr size_t BMP_INFO_HEADER_SIZE = 40;
-constexpr int BMP_BITS_PER_PIXEL = 24;
-
-/// True if the name already ends in ".bmp". The comparison ignores case, so "shot.BMP" is left
-/// alone rather than turned into "shot.BMP.bmp".
-bool has_bmp_suffix(const std::string &name) {
-  return name.size() >= 4 && strcasecmp(name.c_str() + name.size() - 4, ".bmp") == 0;
-}
-
-/// Reduce a user supplied name to a single safe path component. Everything outside the allowed set
-/// is replaced, so "..", "/" and absolute paths cannot escape the snapshot directory.
-/// Returns an empty string if nothing usable is left.
-std::string sanitise_filename(const char *const name, bool *name_changed) {
-  std::string result;
-  bool all_dots = true;
-  bool changed = false;
-  for (const char *p = name; *p != '\0'; p++) {
-    if (result.size() >= MAX_NAME_LENGTH) {
-      changed = true;
-      break;
-    }
-    char c = *p;
-    if (!(std::isalnum(static_cast<unsigned char>(c)) || c == '.' || c == '_' || c == '-')) {
-      c = '_';
-      changed = true;
-    }
-    if (c != '.')
-      all_dots = false;
-    result.push_back(c);
-  }
-  if (all_dots) {
-    *name_changed = true;
-    return "";
-  }
-  if (!has_bmp_suffix(result))
-    result += ".bmp";
-  *name_changed = changed;
-  return result;
-}
-
-/// Insert "-<attempt>" before the file extension, e.g. "shot.bmp" -> "shot-1.bmp".
-std::string add_suffix(const std::string &name, unsigned attempt) {
-  char suffix[12];
-  snprintf(suffix, sizeof(suffix), "-%u", attempt);
-  auto dot = name.rfind('.');
-  if (dot == std::string::npos)
-    return name + suffix;
-  return name.substr(0, dot) + suffix + name.substr(dot);
-}
-
-/// Directory snapshots are written to. The environment variable lets a test redirect output
-/// without rebuilding, matching how the host platform handles ESPHOME_PREFDIR.
-const char *snapshot_dir() {
-  const char *dir = getenv("ESPHOME_SNAPSHOT_DIR");  // NOLINT(concurrency-mt-unsafe)
-  return dir != nullptr && dir[0] != '\0' ? dir : ESPHOME_SNAPSHOT_DIR;
-}
-
-/// Store a value in as many bytes, least significant first, and step the pointer past it.
-/// BMP is a little endian format whatever the machine writing it uses.
-void put_le(uint8_t *&dest, uint32_t value, size_t bytes) {
-  for (size_t i = 0; i != bytes; i++)
-    *dest++ = static_cast<uint8_t>(value >> (8 * i));
-}
-
-/// The number of bytes one row of `width` pixels takes up in the file. Rows are padded out to a
-/// multiple of four bytes.
-size_t bmp_row_size(int width) { return (static_cast<size_t>(width) * 3 + 3) & ~size_t{3}; }
-
-/// Write pixels out as a 24 bit BMP. The rows given start with the topmost and are `row_stride`
-/// bytes apart, which must leave room for a whole padded row; a BMP holds its rows the other way
-/// up, so they go out last first.
-bool write_bmp(FILE *file, const uint8_t *pixels, int width, int height, size_t row_stride) {
-  const size_t row_size = bmp_row_size(width);
-  const size_t pixel_bytes = row_size * height;
-
-  uint8_t header[BMP_HEADER_SIZE];
-  uint8_t *pos = header;
-  *pos++ = 'B';
-  *pos++ = 'M';
-  put_le(pos, static_cast<uint32_t>(BMP_HEADER_SIZE + pixel_bytes), 4);
-  put_le(pos, 0, 4);  // reserved
-  put_le(pos, BMP_HEADER_SIZE, 4);
-  put_le(pos, BMP_INFO_HEADER_SIZE, 4);
-  put_le(pos, static_cast<uint32_t>(width), 4);
-  put_le(pos, static_cast<uint32_t>(height), 4);
-  put_le(pos, 1, 2);  // one plane
-  put_le(pos, BMP_BITS_PER_PIXEL, 2);
-  put_le(pos, 0, 4);  // not compressed
-  put_le(pos, static_cast<uint32_t>(pixel_bytes), 4);
-  put_le(pos, 0, 4);  // pixels per metre across, unspecified
-  put_le(pos, 0, 4);  // pixels per metre down, unspecified
-  put_le(pos, 0, 4);  // no palette
-  put_le(pos, 0, 4);  // so no palette entry matters more than another
-
-  if (fwrite(header, 1, sizeof(header), file) != sizeof(header))
-    return false;
-  for (int y = height - 1; y >= 0; y--) {
-    if (fwrite(pixels + static_cast<size_t>(y) * row_stride, 1, row_size, file) != row_size)
-      return false;
-  }
-  return true;
-}
-
-/// Reserve a name in the snapshot directory and write the picture to it.
-/// With `exact` set the given name is the only one tried; otherwise a number is added on
-/// collision. Returns true if a file was written.
-bool write_snapshot_file(const uint8_t *pixels, int width, int height, size_t row_stride, const std::string &name,
-                         bool exact) {
-  const std::string dir = snapshot_dir();
-  std::error_code ec;
-  std::filesystem::create_directories(dir, ec);
-  if (ec) {
-    ESP_LOGE(TAG, "Could not create snapshot directory %s: %s", dir.c_str(), ec.message().c_str());
-    return false;
-  }
-
-  // O_EXCL guarantees we never write over a file that is already there.
-  std::string path;
-  int fd = -1;
-  for (unsigned attempt = 0; attempt < MAX_NAME_ATTEMPTS; attempt++) {
-    path = dir + "/" + (attempt == 0 ? name : add_suffix(name, attempt));
-    fd = ::open(path.c_str(), O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW, 0644);
-    if (fd >= 0)
-      break;
-    if (errno != EEXIST) {
-      ESP_LOGE(TAG, "Could not create %s: %s", path.c_str(), strerror(errno));
-      return false;
-    }
-    if (exact) {
-      // The caller asked for this exact name, so silently writing somewhere else would be worse
-      // than failing - a test asserting on the path would pick up a stale file.
-      ESP_LOGE(TAG, "Snapshot %s already exists, not overwriting", path.c_str());
-      return false;
-    }
-  }
-  if (fd < 0) {
-    ESP_LOGE(TAG, "Could not find an unused name for %s in %s", name.c_str(), dir.c_str());
-    return false;
-  }
-
-  FILE *file = fdopen(fd, "wb");
-  if (file == nullptr) {
-    ESP_LOGE(TAG, "Could not open %s: %s", path.c_str(), strerror(errno));
-    ::close(fd);
-    ::unlink(path.c_str());
-    return false;
-  }
-  bool ok = write_bmp(file, pixels, width, height, row_stride);
-  int saved_errno = ok ? 0 : errno;
-  // Closing can fail in its own right - the last of the data is still on its way out.
-  if (fclose(file) != 0) {
-    if (ok)
-      saved_errno = errno;
-    ok = false;
-  }
-  if (!ok) {
-    ESP_LOGE(TAG, "Could not write %s: %s", path.c_str(), strerror(saved_errno));
-    // Leave no truncated file behind - it would block a retry under the same name.
-    ::unlink(path.c_str());
-    return false;
-  }
-  ESP_LOGI(TAG, "Snapshot written to %s", path.c_str());
-  return true;
-}
-
-}  // namespace
-
-// helper function since ESP_LOGW is disallowed in a header file
-void Snapshot::log_action_failed() { ESP_LOGW(TAG, "snapshot.take did not write a file"); }
-
-bool Snapshot::take_snapshot(const char *filename) {
-  const int width = this->snapshot_width();
-  const int height = this->snapshot_height();
-  if (width <= 0 || height <= 0) {
-    ESP_LOGE(TAG, "Snapshot requested but the display is %dx%d", width, height);
-    return false;
-  }
-
-  std::string name;
-  bool exact = false;
-  if (filename != nullptr) {
-    bool name_changed = false;
-    name = sanitise_filename(filename, &name_changed);
-    exact = !name.empty();
-    if (name_changed) {
-      ESP_LOGW(TAG, "Requested snapshot name '%s' is not an acceptable file name, using '%s' instead", filename,
-               name.empty() ? "a name made from the time" : name.c_str());
-    }
-  }
-  if (name.empty()) {
-    struct timespec now {};
-    if (clock_gettime(CLOCK_REALTIME, &now) != 0)
-      now = {};
-    struct tm tm_buf {};
-    if (localtime_r(&now.tv_sec, &tm_buf) == nullptr)
-      tm_buf = {};
-    char stamp[32]{};
-    // ::strftime to be sure of the one from <ctime>; display has an unrelated member of that name
-    if (::strftime(stamp, sizeof(stamp), "%Y%m%d-%H%M%S", &tm_buf) == 0)
-      snprintf(stamp, sizeof(stamp), "unknown-time");
-    char buffer[MAX_NAME_LENGTH];
-    int written =
-        snprintf(buffer, sizeof(buffer), "%s-%s-%03ld.bmp", this->snapshot_prefix_, stamp, now.tv_nsec / 1000000);
-    if (written < 0 || static_cast<size_t>(written) >= sizeof(buffer)) {
-      ESP_LOGW(TAG, "Could not build a timestamped snapshot name, using a fallback");
-      snprintf(buffer, sizeof(buffer), "snapshot.bmp");
-    }
-    name = buffer;
-  }
-
-  // Rows are padded out to a multiple of four bytes, as the file wants them, so each one can be
-  // written straight from the buffer. Zeroed on allocation, which is what the padding must be.
-  const size_t row_stride = bmp_row_size(width);
-  auto pixels = std::make_unique<uint8_t[]>(row_stride * height);
-  if (!this->capture_bgr(pixels.get(), row_stride))
-    return false;
-  return write_snapshot_file(pixels.get(), width, height, row_stride, name, exact);
-}
-
-}  // namespace esphome::snapshot
-#endif

esphome/components/snapshot/snapshot.h

@@ -1,72 +0,0 @@
-#pragma once
-
-#ifdef USE_HOST
-#include "esphome/core/automation.h"
-
-#include <cstddef>
-#include <cstdint>
-#include <string>
-
-// Directory snapshots are written to. Normally set by codegen to a folder under .esphome; the
-// fallback keeps the component compiling for static analysis, where no defines.h is generated.
-#ifndef ESPHOME_SNAPSHOT_DIR
-#define ESPHOME_SNAPSHOT_DIR "."
-#endif
-
-namespace esphome::snapshot {
-
-/// Base for anything that can hand over the picture it is showing so it can be written to a file.
-///
-/// A subclass says how big the picture is and fills in the pixels. Everything else - picking a
-/// name, staying inside the snapshot directory, not writing over anything, and encoding the file -
-/// is done here, so every component that can take a snapshot behaves the same way.
-class Snapshot {
- public:
-  virtual ~Snapshot() = default;
-
-  /// Set the word generated names start with. Codegen passes the component id, so with more than
-  /// one display in a device it is clear which one a file came from.
-  void set_snapshot_prefix(const char *prefix) { this->snapshot_prefix_ = prefix; }
-
-  /// Write the current picture to a BMP file in the snapshot directory.
-  ///
-  /// Pass nullptr to have a name made up from the prefix and the current time. A file that is
-  /// already there is never written over. Returns true if a file was written.
-  bool take_snapshot(const char *filename);
-
-  /// Log that an action-triggered snapshot did not write a file.
-  static void log_action_failed();
-
- protected:
-  /// Width of the picture in pixels.
-  virtual int snapshot_width() = 0;
-  /// Height of the picture in pixels.
-  virtual int snapshot_height() = 0;
-  /// Fill in the picture: three bytes per pixel in blue, green, red order, topmost row first, with
-  /// `row_stride` bytes from the start of one row to the start of the next. Returns false, having
-  /// logged why, if the picture could not be read.
-  virtual bool capture_bgr(uint8_t *dest, size_t row_stride) = 0;
-
-  const char *snapshot_prefix_{"snapshot"};
-};
-
-template<typename... Ts> class SnapshotAction final : public Action<Ts...>, public Parented<Snapshot> {
- public:
-  TEMPLATABLE_VALUE(std::string, filename)
-
- protected:
-  void play(const Ts &...x) override {
-    bool ok;
-    if (this->filename_.has_value()) {
-      ok = this->parent_->take_snapshot(this->filename_.value(x...).c_str());
-    } else {
-      ok = this->parent_->take_snapshot(nullptr);
-    }
-    if (!ok)
-      this->parent_->log_action_failed();
-  }
-};
-
-}  // namespace esphome::snapshot
-
-#endif

esphome/components/t6615/sensor.py

@@ -33,13 +33,7 @@ CONFIG_SCHEMA = (
 )
 
 FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "t6615",
-    baud_rate=19200,
-    require_rx=True,
-    require_tx=True,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
+    "t6615", baud_rate=19200, require_rx=True, require_tx=True
 )
 
 

esphome/components/t6615/t6615.cpp

@@ -88,6 +88,7 @@ void T6615Component::query_ppm_() {
 void T6615Component::dump_config() {
   ESP_LOGCONFIG(TAG, "T6615:");
   LOG_SENSOR("  ", "CO2", this->co2_sensor_);
+  this->check_uart_settings(19200);
 }
 
 }  // namespace esphome::t6615

esphome/components/teleinfo/__init__.py

@@ -35,22 +35,6 @@ CONFIG_SCHEMA = (
 )
 
 
-def _final_validate(config: ConfigType) -> ConfigType:
-    # Historical mode runs at 1200 baud, standard mode at 9600 baud.
-    baud_rate = 1200 if config[CONF_HISTORICAL_MODE] else 9600
-    uart.final_validate_device_schema(
-        "teleinfo",
-        baud_rate=baud_rate,
-        data_bits=7,
-        parity="EVEN",
-        stop_bits=1,
-    )(config)
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID], config[CONF_HISTORICAL_MODE])
     await cg.register_component(var, config)

esphome/components/teleinfo/teleinfo.cpp

@@ -184,7 +184,10 @@ void TeleInfo::publish_value_(const std::string &tag, const std::string &val) {
     element->publish_val(val);
   }
 }
-void TeleInfo::dump_config() { ESP_LOGCONFIG(TAG, "TeleInfo:"); }
+void TeleInfo::dump_config() {
+  ESP_LOGCONFIG(TAG, "TeleInfo:");
+  this->check_uart_settings(baud_rate_, 1, uart::UART_CONFIG_PARITY_EVEN, 7);
+}
 TeleInfo::TeleInfo(bool historical_mode) {
   if (historical_mode) {
     /*
@@ -192,9 +195,11 @@ TeleInfo::TeleInfo(bool historical_mode) {
      */
     checksum_area_end_ = 2;
     separator_ = 0x20;
+    baud_rate_ = 1200;
   } else {
     checksum_area_end_ = 1;
     separator_ = 0x9;
+    baud_rate_ = 9600;
   }
 }
 void TeleInfo::register_teleinfo_listener(TeleInfoListener *listener) { teleinfo_listeners_.push_back(listener); }

esphome/components/teleinfo/teleinfo.h

@@ -31,6 +31,7 @@ class TeleInfo final : public PollingComponent, public uart::UARTDevice {
   std::vector<TeleInfoListener *> teleinfo_listeners_{};
 
  protected:
+  uint32_t baud_rate_;
   int checksum_area_end_;
   int separator_;
   char buf_[MAX_BUF_SIZE];

esphome/components/tormatic/tormatic_cover.cpp

@@ -36,6 +36,8 @@ cover::CoverTraits Tormatic::get_traits() {
 
 void Tormatic::dump_config() {
   LOG_COVER("", "Tormatic Cover", this);
+  this->check_uart_settings(9600, 1, uart::UART_CONFIG_PARITY_NONE, 8);
+
   ESP_LOGCONFIG(TAG,
                 "  Open Duration: %.1fs\n"
                 "  Close Duration: %.1fs",

esphome/components/uart/uart.h

@@ -3,7 +3,6 @@
 #include <vector>
 #include "esphome/core/component.h"
 #include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 #include "uart_component.h"
 
@@ -67,7 +66,6 @@ class UARTDevice {
   }
 
   /// Check that the configuration of the UART bus matches the provided values and otherwise print a warning
-  ESPDEPRECATED("Use uart.final_validate_device_schema() in Python instead. Removed in 2027.3.0", "2026.9.0")
   void check_uart_settings(uint32_t baud_rate, uint8_t stop_bits = 1,
                            UARTParityOptions parity = UART_CONFIG_PARITY_NONE, uint8_t data_bits = 8);
 

esphome/components/ufm01/__init__.py

@@ -30,7 +30,6 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
     require_tx=True,
     require_rx=True,
     baud_rate=2400,
-    data_bits=8,
     parity="EVEN",
     stop_bits=1,
 )

esphome/components/ufm01/ufm01.cpp

@@ -213,6 +213,7 @@ void UFM01Component::dump_config() {
   LOG_BINARY_SENSOR("  ", "Empty Tube", this->empty_tube_binary_sensor_);
   LOG_BINARY_SENSOR("  ", "Flow Rate Out Of Range", this->flow_rate_out_of_range_binary_sensor_);
 #endif
+  this->check_uart_settings(2400, 1, uart::UART_CONFIG_PARITY_EVEN, 8);
 }
 
 void UFM01Component::on_active_frame_(uint8_t data[FRAME_SIZE]) {

esphome/components/uponor_smatrix/__init__.py

@@ -50,7 +50,7 @@ FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
     require_tx=True,
     require_rx=True,
     data_bits=8,
-    parity="NONE",
+    parity=None,
     stop_bits=1,
 )
 

esphome/components/uponor_smatrix/uponor_smatrix.cpp

@@ -29,6 +29,8 @@ void UponorSmatrixComponent::dump_config() {
   }
 #endif
 
+  this->check_uart_settings(19200);
+
   if (!this->unknown_devices_.empty()) {
     ESP_LOGCONFIG(TAG, "  Detected unknown device addresses:");
     for (auto device_address : this->unknown_devices_) {

esphome/components/vbus/__init__.py

@@ -29,14 +29,6 @@ CONFIG_SCHEMA = uart.UART_DEVICE_SCHEMA.extend(
     }
 )
 
-FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "vbus",
-    baud_rate=9600,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
-)
-
 
 async def to_code(config: ConfigType) -> None:
     var = cg.new_Pvariable(config[CONF_ID])

esphome/components/vbus/vbus.cpp

@@ -11,7 +11,10 @@ static const char *const TAG = "vbus";
 // Maximum bytes to log in verbose hex output (16 frames * 4 bytes = 64 bytes typical)
 static constexpr size_t VBUS_MAX_LOG_BYTES = 64;
 
-void VBus::dump_config() { ESP_LOGCONFIG(TAG, "VBus:"); }
+void VBus::dump_config() {
+  ESP_LOGCONFIG(TAG, "VBus:");
+  check_uart_settings(9600);
+}
 
 static void septet_spread(uint8_t *data, int start, int count, uint8_t septet) {
   for (int i = 0; i < count; i++, septet >>= 1) {

esphome/components/wifi/wifi_component.h

@@ -40,6 +40,11 @@
 #include <ESP8266WiFi.h>
 #include <ESP8266WiFiType.h>
 
+#if defined(USE_ESP8266) && USE_ARDUINO_VERSION_CODE < VERSION_CODE(2, 4, 0)
+extern "C" {
+#include <user_interface.h>
+};
+#endif
 #endif
 
 #ifdef USE_RP2

esphome/components/wifi/wifi_component_esp8266.cpp

@@ -21,6 +21,7 @@ extern "C" {
 #include "lwip/apps/sntp.h"
 #include "lwip/netif.h"  // struct netif
 #include <AddrList.h>
+#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0)
 #include "LwipDhcpServer.h"
 #if USE_ARDUINO_VERSION_CODE < VERSION_CODE(3, 1, 0)
 #include <ESP8266WiFi.h>
@@ -29,6 +30,7 @@ extern "C" {
 #define wifi_softap_set_dhcps_lease_time(time) dhcpSoftAP.set_dhcps_lease_time(time)
 #define wifi_softap_set_dhcps_offer_option(offer, mode) dhcpSoftAP.set_dhcps_offer_option(offer, mode)
 #endif
+#endif
 }
 
 #include "esphome/core/application.h"
@@ -291,6 +293,7 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
     conf.bssid_set = 0;
   }
 
+#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
   if (ap.password_.empty()) {
     conf.threshold.authmode = AUTH_OPEN;
   } else {
@@ -307,6 +310,7 @@ bool WiFiComponent::wifi_sta_connect_(const WiFiAP &ap) {
     }
   }
   conf.threshold.rssi = -127;
+#endif
 
   ETS_UART_INTR_DISABLE();
   bool ret = wifi_station_set_config_current(&conf);
@@ -598,6 +602,7 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
 #endif
       break;
     }
+#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
     case EVENT_OPMODE_CHANGED: {
       auto it = event->event_info.opmode_changed;
       ESP_LOGV(TAG, "Changed Mode old=%s new=%s", LOG_STR_ARG(get_op_mode_str(it.old_opmode)),
@@ -615,6 +620,7 @@ void WiFiComponent::wifi_event_callback(System_Event_t *event) {
 #endif
       break;
     }
+#endif
     default:
       break;
   }
@@ -699,6 +705,7 @@ bool WiFiComponent::wifi_scan_start_(bool passive) {
   config.bssid = nullptr;
   config.channel = 0;
   config.show_hidden = 1;
+#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 4, 0)
   config.scan_type = passive ? WIFI_SCAN_TYPE_PASSIVE : WIFI_SCAN_TYPE_ACTIVE;
   // Use shorter dwell times for roaming scans - we only need to detect strong
   // nearby APs, not do a thorough survey. This also reduces off-channel time
@@ -717,6 +724,7 @@ bool WiFiComponent::wifi_scan_start_(bool passive) {
     config.scan_time.active.min = roaming ? SCAN_ACTIVE_MIN_ROAMING_MS : SCAN_ACTIVE_MIN_DEFAULT_MS;
     config.scan_time.active.max = roaming ? SCAN_ACTIVE_MAX_ROAMING_MS : SCAN_ACTIVE_MAX_DEFAULT_MS;
   }
+#endif
   bool ret = wifi_station_scan(&config, &WiFiComponent::s_wifi_scan_done_callback);
   if (!ret) {
     ESP_LOGV(TAG, "wifi_station_scan failed");
@@ -822,7 +830,7 @@ bool WiFiComponent::wifi_ap_ip_config_(const optional<ManualIP> &manual_ip) {
     return false;
   }
 
-#if USE_ARDUINO_VERSION_CODE < VERSION_CODE(3, 1, 0)
+#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(3, 0, 0) && USE_ARDUINO_VERSION_CODE < VERSION_CODE(3, 1, 0)
   dhcpSoftAP.begin(&info);
 #endif
 

esphome/components/wl_134/text_sensor.py

@@ -21,14 +21,6 @@ CONFIG_SCHEMA = (
     .extend(uart.UART_DEVICE_SCHEMA)
 )
 
-FINAL_VALIDATE_SCHEMA = uart.final_validate_device_schema(
-    "wl_134",
-    baud_rate=9600,
-    data_bits=8,
-    parity="NONE",
-    stop_bits=1,
-)
-
 
 async def to_code(config: ConfigType) -> None:
     var = await text_sensor.new_text_sensor(config)

esphome/components/wl_134/wl_134.cpp

@@ -110,5 +110,7 @@ uint64_t Wl134Component::hex_lsb_ascii_to_uint64_(const uint8_t *text, uint8_t t
 void Wl134Component::dump_config() {
   ESP_LOGCONFIG(TAG, "WL-134 Sensor:");
   LOG_TEXT_SENSOR("", "Tag", this);
+  // As specified in the sensor's data sheet
+  this->check_uart_settings(9600, 1, esphome::uart::UART_CONFIG_PARITY_NONE, 8);
 }
 }  // namespace esphome::wl_134

esphome/const.py

@@ -4,7 +4,7 @@ from enum import Enum
 
 from esphome.enum import StrEnum
 
-__version__ = "2026.10.0-dev"
+__version__ = "2026.9.0-dev"
 
 ALLOWED_NAME_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789-_"
 VALID_SUBSTITUTIONS_CHARACTERS = (

esphome/core/defines.h

@@ -13,7 +13,6 @@
 #define ESPHOME_PROJECT_VERSION "v2"
 #define ESPHOME_PROJECT_VERSION_30 "v2"
 #define ESPHOME_VARIANT "ESP32"
-#define ESPHOME_SNAPSHOT_DIR "."
 #define ESPHOME_NAME_ADD_MAC_SUFFIX
 #define ESPHOME_DEBUG_SCHEDULER
 #define ESPHOME_DEBUG_API

esphome/core/log.h

@@ -18,6 +18,7 @@
 
 #ifdef USE_STORE_LOG_STR_IN_FLASH
 #include "WString.h"
+#include "esphome/core/defines.h"  // for USE_ARDUINO_VERSION_CODE
 #endif
 
 // Include ESP-IDF/Arduino based logging methods here so they don't undefine ours later
@@ -176,7 +177,20 @@ struct LogString;
 
 #include <pgmspace.h>
 
+#if USE_ARDUINO_VERSION_CODE >= VERSION_CODE(2, 5, 0)
 #define LOG_STR_ARG(s) ((PGM_P) (s))
+#else
+// Pre-Arduino 2.5, we can't pass a PSTR() to printf(). Emulate support by copying the message to a
+// local buffer first. String length is limited to 63 characters.
+// https://github.com/esp8266/Arduino/commit/6280e98b0360f85fdac2b8f10707fffb4f6e6e31
+#define LOG_STR_ARG(s) \
+  ({ \
+    char __buf[64]; \
+    __buf[63] = '\0'; \
+    strncpy_P(__buf, (PGM_P) (s), 63); \
+    __buf; \
+  })
+#endif
 
 #define LOG_STR(s) (reinterpret_cast<const LogString *>(PSTR(s)))
 #define LOG_STR_LITERAL(s) LOG_STR_ARG(LOG_STR(s))

esphome/platformio/prefetch.py

@@ -16,7 +16,7 @@ name and promote with an atomic rename.
 
 from __future__ import annotations
 
-from collections.abc import Iterator
+from collections.abc import Iterable, Iterator
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager, suppress
 import hashlib
@@ -55,8 +55,8 @@ def _preserved_sys_path() -> Iterator[None]:
         sys.path[:] = saved
 
 
-# Concurrent registry resolutions / HEAD probes (each is network-bound)
-_RESOLVE_WORKERS = 8
+# Cap for network-bound work: resolutions, HEAD probes, clone floor
+_NETWORK_WORKERS = 8
 
 # A hung child must not block the build; downloads resume on the next run
 _PREFETCH_TIMEOUT = 20 * 60
@@ -341,7 +341,7 @@ def _registry_jobs(
     if not pending:
         return [], 0, []
     # Serial resolutions (registry GET + mirror HEAD each) dominate
-    with ThreadPoolExecutor(max_workers=min(_RESOLVE_WORKERS, len(pending))) as ex:
+    with ThreadPoolExecutor(max_workers=min(_NETWORK_WORKERS, len(pending))) as ex:
         results = list(ex.map(_resolve, pending))
     jobs: list[tuple[str, int, Any]] = []
     installable: list[tuple[str, Any]] = []
@@ -374,14 +374,47 @@ def _registry_jobs(
     return jobs, failed, installable
 
 
+# The schemes pio's VCSClientFactory dispatches on (Git/Hg/SvnClient)
+_VCS_URI_PREFIXES = ("git+", "hg+", "svn+", "git://", "hg://", "svn://")
+
+
+def _is_vcs_spec_uri(url: str | None) -> bool:
+    """Whether pio's ``install_from_uri`` would clone this URI (PackageSpec
+    normalizes git URLs to ``git+``). The .git check runs first so an
+    un-normalized repo URL fails as a clone, not as an archive download."""
+    if not url or url.startswith(("file://", "symlink://")):
+        return False
+    if url.split("#", 1)[0].endswith(".git"):
+        return True
+    if url.startswith(("http://", "https://")):
+        return False
+    return url.startswith(_VCS_URI_PREFIXES)
+
+
+# (name, spec) from wave 1, (name, spec, compatibility) from dep waves
+_Entry = tuple[str, Any] | tuple[str, Any, Any]
+
+
+def _entry_is_vcs(entry: _Entry) -> bool:
+    """Whether this pre-install entry is cloned rather than unpacked."""
+    return _is_vcs_spec_uri(entry[1].uri)
+
+
+def _clones_first(entries: Iterable[_Entry]) -> list[_Entry]:
+    """Clones first: they wait on the network, so they must not queue
+    behind CPU-bound archive extractions in the pre-install pool."""
+    return sorted(entries, key=lambda entry: not _entry_is_vcs(entry))
+
+
 def _uri_jobs(
     manager: Any, specs: list[Any], seen: set[str]
 ) -> tuple[list[tuple[str, int, Any]], int, list[tuple[str, Any]]]:
     """Jobs for direct-URL specs; a HEAD sizes each for the combined bar.
 
     Also returns how many HEAD probes errored (an absent length is not an
-    error) and the ``(name, spec)`` pairs whose archives will be
-    installable.
+    error) and the ``(name, spec)`` pairs to pre-install: downloaded
+    archives, plus VCS specs, which have no archive -- the pre-install
+    itself clones them, in parallel instead of one at a time in pio run.
     """
     from esphome.net_retry import fetch_with_retry, http_request
 
@@ -389,13 +422,25 @@ def _uri_jobs(
     installable: list[tuple[str, Any]] = []
     for spec in specs:
         url = spec.uri
-        if not url or not url.startswith(("http://", "https://")):
-            continue  # git+/file specs are cloned/copied, not downloaded
-        if url.split("#", 1)[0].endswith(".git"):
-            continue  # bare-URL VCS spec; PlatformIO clones it
+        if not url:
+            continue
+        is_vcs = _is_vcs_spec_uri(url)
+        if not is_vcs and not url.startswith(("http://", "https://")):
+            if not url.startswith(("file://", "symlink://")):
+                _LOGGER.debug(
+                    "Unrecognized package URI, leaving it to pio run: %s", url
+                )
+            continue  # file/symlink specs are copied in place by pio run
         if manager.get_package(spec):
             continue
         name = spec.name or url.rsplit("/", 1)[-1]
+        if is_vcs:
+            # The pre-install clones it, gated like the cached-archive
+            # branch below: only a custom name is the destination dir.
+            # Platform tool specs always parse as custom-named
+            if spec.has_custom_name():
+                installable.append((name, spec))
+            continue
         # PlatformIO downloads URL specs with no checksum
         dl_path = Path(manager.compute_download_path(url, ""))
         if dl_path.is_file():
@@ -409,7 +454,7 @@ def _uri_jobs(
         if str(dl_path) in seen:
             continue  # another spec already claimed this .part
         seen.add(str(dl_path))
-        candidates.append((spec.name, url, dl_path, spec))
+        candidates.append((name, url, dl_path, spec))
 
     errors: list[str] = []
 
@@ -435,7 +480,7 @@ def _uri_jobs(
 
     if not candidates:
         return [], 0, installable
-    with ThreadPoolExecutor(max_workers=min(_RESOLVE_WORKERS, len(candidates))) as ex:
+    with ThreadPoolExecutor(max_workers=min(_NETWORK_WORKERS, len(candidates))) as ex:
         sizes = list(ex.map(_head_size, [url for _, url, _, _ in candidates]))
     jobs: list[tuple[str, int, Any]] = []
     failed = 0
@@ -583,10 +628,6 @@ def _uri_fetch_job(manager: Any, url: str, dl_path: Path, size: int) -> Any:
     return run
 
 
-# (name, spec) from wave 1, (name, spec, compatibility) from dep waves
-_Entry = tuple[str, Any] | tuple[str, Any, Any]
-
-
 def _dependency_entries(
     manager: Any, entries: list[_Entry], seen_names: set[str]
 ) -> list[_Entry]:
@@ -701,7 +742,14 @@ def _preinstall(
     would hang, not fail). Waves skip dependencies; the installed
     manifests feed the next wave. Any failure falls back to pio run.
     """
-    workers = min(get_usable_cpu_count(), len(entries))
+    entries = _clones_first(entries)
+    clones = sum(1 for entry in entries if _entry_is_vcs(entry))
+    # Network-bound clones run wide even on small-core runners; capped
+    # since each worker builds a sibling manager and may run a
+    # postinstall, and a mixed wave's extractions inherit the width
+    workers = min(
+        max(get_usable_cpu_count(), min(clones, _NETWORK_WORKERS)), len(entries)
+    )
     # One manager per worker (_install mutates instance state); built
     # serially because construction rewires the shared manager logger
     managers: SimpleQueue = SimpleQueue()
@@ -733,7 +781,7 @@ def _preinstall(
             raise
 
     _LOGGER.info(
-        "Installing %d PlatformIO package(s) with %d extraction worker(s): %s",
+        "Installing %d PlatformIO package(s) with %d worker(s): %s",
         len(entries),
         workers,
         ", ".join(name for name, *_ in entries),

requirements.txt

@@ -14,7 +14,7 @@ esptool==5.3.1
 click==8.3.3
 aioesphomeapi==46.3.0
 aiohappyeyeballs==2.7.1  # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi
-zeroconf==0.151.3
+zeroconf==0.151.2
 puremagic==2.2.0
 ruamel.yaml==0.19.1 # dashboard_import
 ruamel.yaml.clib==0.2.15 # dashboard_import
@@ -28,8 +28,8 @@ smpclient==7.2.0
 requests==2.34.2
 py7zr==1.1.3
 platformdirs==4.11.5  # native esp-idf toolchain global cache dir
-ninja==1.13.2  # native esp8266 arduino toolchain build driver
-filelock==3.32.5  # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
+ninja==1.13.0  # native esp8266 arduino toolchain build driver
+filelock==3.32.4  # inter-process locks (PlatformIO cache heal, git clone cache); >=3.32 for FileLock(fallback_to_soft=...), older versions silently drop the kwarg
 
 # esp-idf >= 5.0 requires this
 pyparsing >= 3.3.2

tests/component_tests/remote_transmitter/test_non_blocking_gate.py

@@ -26,7 +26,7 @@ from ..types import SetCoreConfigCallable
         (PlatformFramework.ESP32_IDF, None, True),
         (PlatformFramework.RTL87XX_ARDUINO, FAMILY_RTL8720C, True),
         (PlatformFramework.RTL87XX_ARDUINO, FAMILY_RTL8710B, False),
-        (PlatformFramework.BK72XX_ARDUINO, FAMILY_BK7231N, False),
+        (PlatformFramework.BK72XX_ARDUINO, FAMILY_BK7231N, True),
         (PlatformFramework.BK72XX_ARDUINO, FAMILY_BK7238, True),
         (PlatformFramework.BK72XX_ARDUINO, FAMILY_BK7231T, False),
         (PlatformFramework.ESP8266_ARDUINO, None, False),

tests/component_tests/sdl/test_sdl.py

@@ -1,101 +0,0 @@
-"""Tests for the sdl display schema, in particular the headless option."""
-
-from __future__ import annotations
-
-import pytest
-
-from esphome import config_validation as cv
-from esphome.components.sdl.display import (
-    CONF_SDL_ID,
-    CONFIG_SCHEMA,
-    headless_final_validate,
-)
-from esphome.config import Config
-from esphome.const import PlatformFramework
-from esphome.core import ID
-from esphome.final_validate import full_config
-from esphome.types import ConfigType
-from tests.component_tests.types import SetCoreConfigCallable
-
-
-@pytest.fixture(autouse=True)
-def _host_platform(set_core_config: SetCoreConfigCallable) -> None:
-    set_core_config(PlatformFramework.HOST_NATIVE)
-
-
-def _config(**extra: object) -> ConfigType:
-    config: ConfigType = {
-        "dimensions": {"width": 320, "height": 240},
-        # sdl2-config is not necessarily installed in the test environment
-        "sdl_options": "-lSDL2",
-    }
-    config.update(extra)
-    return config
-
-
-def test_defaults_to_windowed() -> None:
-    """A display without the option is not headless."""
-    assert CONFIG_SCHEMA(_config())["headless"] is False
-
-
-def test_headless_accepted() -> None:
-    """A headless display needs nothing beyond the dimensions."""
-    assert CONFIG_SCHEMA(_config(headless=True))["headless"] is True
-
-
-def test_headless_rejects_window_options() -> None:
-    """Window options are meaningless without a window."""
-    with pytest.raises(cv.Invalid, match="has no effect"):
-        CONFIG_SCHEMA(
-            _config(headless=True, window_options={"position": {"x": 0, "y": 0}})
-        )
-
-
-def test_headless_rejects_snapshot_key() -> None:
-    """A headless display has no keyboard, so the action is the only way in."""
-    with pytest.raises(cv.Invalid, match="snapshot.take"):
-        CONFIG_SCHEMA(_config(headless=True, snapshot_key="SDLK_F12"))
-
-
-def test_snapshot_key_accepted_when_windowed() -> None:
-    """The key is only valid alongside a window."""
-    config = CONFIG_SCHEMA(_config(snapshot_key="SDLK_F12"))
-    assert str(config["snapshot_key"]) == "SDLK_F12"
-
-
-def _declare_sdl_display(headless: bool) -> ID:
-    """Register a full_config with a single sdl display declaration and return a reference to it.
-
-    Mirrors what the real config pipeline leaves behind: a "display" domain entry plus a
-    declare_ids record id_declaration_match_schema uses to find it again.
-    """
-    declared_id = ID("my_sdl", is_declaration=True)
-    fc = Config()
-    fc["display"] = [
-        {
-            "platform": "sdl",
-            "id": declared_id,
-            "headless": headless,
-            "dimensions": {"width": 320, "height": 240},
-        }
-    ]
-    fc.declare_ids.append((declared_id, ["display", 0, "id"]))
-    full_config.set(fc)
-    return ID("my_sdl")
-
-
-@pytest.mark.parametrize("platform", ["binary_sensor", "touchscreen"])
-def test_headless_final_validate_rejects_headless_display(platform: str) -> None:
-    """binary_sensor and touchscreen both need a window, so a headless display is rejected."""
-    sdl_ref = _declare_sdl_display(headless=True)
-    schema = headless_final_validate(platform)
-    with pytest.raises(cv.Invalid, match="needs a window"):
-        schema({CONF_SDL_ID: sdl_ref})
-
-
-@pytest.mark.parametrize("platform", ["binary_sensor", "touchscreen"])
-def test_headless_final_validate_accepts_windowed_display(platform: str) -> None:
-    """The same platforms are accepted once the display has a window."""
-    sdl_ref = _declare_sdl_display(headless=False)
-    schema = headless_final_validate(platform)
-    schema({CONF_SDL_ID: sdl_ref})  # Should not raise.

tests/components/cse7761/test.esp32-idf.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO14
 
 packages:
-  uart_38400_even: !include ../../test_build_components/common/uart_38400_even/esp32-idf.yaml
+  uart_38400: !include ../../test_build_components/common/uart_38400/esp32-idf.yaml
 
 <<: !include common.yaml

tests/components/cse7761/test.esp8266-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO3
 
 packages:
-  uart_38400_even: !include ../../test_build_components/common/uart_38400_even/esp8266-ard.yaml
+  uart_38400: !include ../../test_build_components/common/uart_38400/esp8266-ard.yaml
 
 <<: !include common.yaml

tests/components/cse7761/test.rp2040-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO5
 
 packages:
-  uart_38400_even: !include ../../test_build_components/common/uart_38400_even/rp2040-ard.yaml
+  uart_38400: !include ../../test_build_components/common/uart_38400/rp2040-ard.yaml
 
 <<: !include common.yaml

tests/components/kamstrup_kmp/test.esp32-idf.yaml

@@ -1,4 +1,4 @@
 packages:
-  uart_1200_none_2stopbits: !include ../../test_build_components/common/uart_1200_none_2stopbits/esp32-idf.yaml
+  uart_1200: !include ../../test_build_components/common/uart_1200/esp32-idf.yaml
 
 <<: !include common.yaml

tests/components/kamstrup_kmp/test.esp8266-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   uart_rx_pin: GPIO3
 
 packages:
-  uart_1200_none_2stopbits: !include ../../test_build_components/common/uart_1200_none_2stopbits/esp8266-ard.yaml
+  uart_1200: !include ../../test_build_components/common/uart_1200/esp8266-ard.yaml
 
 <<: !include common.yaml

tests/components/pylontech/test.esp32-idf.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO5
 
 packages:
-  uart_115200: !include ../../test_build_components/common/uart_115200/esp32-idf.yaml
+  uart: !include ../../test_build_components/common/uart/esp32-idf.yaml
 
 <<: !include common.yaml

tests/components/pylontech/test.esp8266-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO2
 
 packages:
-  uart_115200: !include ../../test_build_components/common/uart_115200/esp8266-ard.yaml
+  uart: !include ../../test_build_components/common/uart/esp8266-ard.yaml
 
 <<: !include common.yaml

tests/components/pylontech/test.rp2040-ard.yaml

@@ -3,6 +3,6 @@ substitutions:
   rx_pin: GPIO5
 
 packages:
-  uart_115200: !include ../../test_build_components/common/uart_115200/rp2040-ard.yaml
+  uart: !include ../../test_build_components/common/uart/rp2040-ard.yaml
 
 <<: !include common.yaml

tests/components/remote_transmitter/test.bk72xx-ard.yaml

@@ -2,7 +2,7 @@ remote_transmitter:
   id: xmitr
   pin: GPIO26
   carrier_duty_percent: 50%
-  # non_blocking is bk7238-only; the CI board is a BK7252, so this builds the bit-bang path
+  # non_blocking is bk7231n/bk7238-only; the CI board is a BK7252
 
 packages:
   buttons: !include common-buttons.yaml

tests/components/sdl/common.yaml

@@ -14,15 +14,6 @@ display:
       position:
         x: 100
         y: 100
-    snapshot_key: SDLK_F12
-
-  - platform: sdl
-    id: headless_display
-    headless: true
-    show_test_card: true
-    dimensions:
-      width: 320
-      height: 240
 
   - platform: sdl
     id: second_display
@@ -55,21 +46,3 @@ binary_sensor:
     sdl_id: sdl_sdl_display
     id: key_enter
     key: SDLK_RETURN
-
-esphome:
-  # A name of your own is only good for one snapshot - a second one under the same name fails
-  # rather than writing over the first - so these run once rather than on a repeating interval.
-  on_boot:
-    - delay: 2s
-    - snapshot.take:
-        id: headless_display
-        filename: test_card.bmp
-    - snapshot.take:
-        id: headless_display
-        filename: !lambda 'return "shot.bmp";'
-
-interval:
-  # A generated name has the time in it, so this one can repeat.
-  - interval: 10s
-    then:
-      - snapshot.take: sdl_sdl_display

tests/components/sdl/validate.host.yaml

@@ -1,29 +0,0 @@
-# Config-only test for the headless and screenshot options. The combinations that must be
-# rejected are covered by tests/component_tests/sdl/test_sdl.py; this file checks that the
-# accepted forms validate together.
-host:
-  mac_address: "62:23:45:AF:B3:DD"
-
-display:
-  - platform: sdl
-    id: headless_display
-    headless: true
-    dimensions: 320x240
-
-  - platform: sdl
-    id: windowed_display
-    dimensions: 320x240
-    snapshot_key: SDLK_F12
-
-binary_sensor:
-  - platform: sdl
-    sdl_id: windowed_display
-    id: key_up
-    key: SDLK_UP
-
-interval:
-  - interval: 10s
-    then:
-      - snapshot.take:
-          id: headless_display
-          filename: periodic.bmp