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.
@@ -553,7 +502,6 @@ file does, and it is the authority when they disagree. The most useful starting
     4.  **Lint:** Run `prek` to ensure code is compliant.
     5.  **Commit:** Commit your changes. There is no strict format for commit messages.
     6.  **Pull Request:** Submit a PR against the `dev` branch. The Pull Request title must start with a `[tag]` prefix. For component work, use the component name (e.g., `[display] Fix bug`, `[abc123] Add new component`); for changes to shared/core code that isn't tied to a single component, use `[core]` (e.g., `[core] Add validator`). Update documentation, examples, and add `CODEOWNERS` entries as needed. Pull requests should always be made using the `.github/PULL_REQUEST_TEMPLATE.md` template - fill out all sections completely without removing any parts of the template.
-    7.  **Comments:** When commenting on GitHub PRs or issues, don't tag contributors, especially bots. Avoid referring to list items (e.g. from reviews) with the form #nn - this will be interpreted by GitHub as a reference to issue or PR nn. Keep comments short and exclude irrelevant details, backstories, restatement of previous comments and anything that is already obvious to the reader.
 
 *   **Documentation Contributions:**
     *   Documentation is hosted in the separate `esphome/esphome.io` repository.
@@ -614,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)
@@ -678,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.3
+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/components/climate/__init__.py

@@ -125,19 +125,6 @@ CLIMATE_SWING_MODES = {
 
 validate_climate_swing_mode = cv.enum(CLIMATE_SWING_MODES, upper=True)
 
-ClimateAction = climate_ns.enum("ClimateAction")
-CLIMATE_ACTIONS = {
-    "OFF": ClimateAction.CLIMATE_ACTION_OFF,
-    "COOLING": ClimateAction.CLIMATE_ACTION_COOLING,
-    "HEATING": ClimateAction.CLIMATE_ACTION_HEATING,
-    "IDLE": ClimateAction.CLIMATE_ACTION_IDLE,
-    "DRYING": ClimateAction.CLIMATE_ACTION_DRYING,
-    "FAN": ClimateAction.CLIMATE_ACTION_FAN,
-    "DEFROSTING": ClimateAction.CLIMATE_ACTION_DEFROSTING,
-}
-
-validate_climate_action = cv.enum(CLIMATE_ACTIONS, upper=True)
-
 CONF_MIN_HUMIDITY = "min_humidity"
 CONF_MAX_HUMIDITY = "max_humidity"
 CONF_TARGET_HUMIDITY = "target_humidity"

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/esp32_ble/ble.cpp

@@ -100,38 +100,21 @@ void ESP32BLE::disable() {
 #ifdef USE_ESP32_BLE_ADVERTISING
 void ESP32BLE::advertising_start() {
   this->advertising_init_();
-  this->advertising_ref_count_++;
-  this->advertising_refresh();
-}
-
-void ESP32BLE::advertising_stop() {
-  if (this->advertising_ref_count_ == 0)
+  if (!this->is_active())
     return;
-  this->advertising_ref_count_--;
-  this->advertising_refresh();
-}
-
-void ESP32BLE::advertising_refresh() {
-  if (this->advertising_ == nullptr || !this->is_active())
-    return;
-  // Advertise while any component still needs it, otherwise stop
-  if (this->advertising_ref_count_ == 0) {
-    this->advertising_->stop();
-  } else {
-    this->advertising_->start();
-  }
+  this->advertising_->start();
 }
 
 void ESP32BLE::advertising_set_service_data(const std::vector<uint8_t> &data) {
   this->advertising_init_();
   this->advertising_->set_service_data(data);
-  this->advertising_refresh();
+  this->advertising_start();
 }
 
 void ESP32BLE::advertising_set_manufacturer_data(const std::vector<uint8_t> &data) {
   this->advertising_init_();
   this->advertising_->set_manufacturer_data(data);
-  this->advertising_refresh();
+  this->advertising_start();
 }
 
 void ESP32BLE::advertising_set_service_data_and_name(std::span<const uint8_t> data, bool include_name) {
@@ -153,7 +136,7 @@ void ESP32BLE::advertising_set_service_data_and_name(std::span<const uint8_t> da
     this->advertising_->set_service_data(data);
   }
 
-  this->advertising_refresh();
+  this->advertising_start();
 }
 
 void ESP32BLE::advertising_register_raw_advertisement_callback(std::function<void(bool)> &&callback) {
@@ -164,13 +147,13 @@ void ESP32BLE::advertising_register_raw_advertisement_callback(std::function<voi
 void ESP32BLE::advertising_add_service_uuid(ESPBTUUID uuid) {
   this->advertising_init_();
   this->advertising_->add_service_uuid(uuid);
-  this->advertising_refresh();
+  this->advertising_start();
 }
 
 void ESP32BLE::advertising_remove_service_uuid(ESPBTUUID uuid) {
   this->advertising_init_();
   this->advertising_->remove_service_uuid(uuid);
-  this->advertising_refresh();
+  this->advertising_start();
 }
 #endif
 
@@ -592,10 +575,6 @@ void ESP32BLE::loop_handle_state_transition_not_active_() {
     }
 
     this->state_ = BLE_COMPONENT_STATE_ACTIVE;
-#ifdef USE_ESP32_BLE_ADVERTISING
-    // Requests made before the stack was up (or before it was re-enabled) take effect now
-    this->advertising_refresh();
-#endif
   }
 }
 

esphome/components/esp32_ble/ble.h

@@ -114,17 +114,7 @@ class ESP32BLE final : public Component {
   void set_name(const char *name) { this->name_ = name; }
 
 #ifdef USE_ESP32_BLE_ADVERTISING
-  /** Request advertising on behalf of a component.
-   *
-   * Requests are reference counted: advertising runs until every component that called
-   * advertising_start() has released it again with advertising_stop(). Each component must
-   * pair its calls, so nothing advertises until something actually asks for it.
-   */
   void advertising_start();
-  /// Release a request made with advertising_start(); advertising stops at the last release.
-  void advertising_stop();
-  /// Apply the current payload and request count: advertise while requested, otherwise stop.
-  void advertising_refresh();
   void advertising_set_service_data(const std::vector<uint8_t> &data);
   void advertising_set_manufacturer_data(const std::vector<uint8_t> &data);
   void advertising_set_appearance(uint16_t appearance) { this->appearance_ = appearance; }
@@ -236,9 +226,6 @@ class ESP32BLE final : public Component {
   // 1-byte aligned members (grouped together to minimize padding)
   BLEComponentState state_{BLE_COMPONENT_STATE_OFF};  // 1 byte (uint8_t enum)
   bool enable_on_boot_{};                             // 1 byte
-#ifdef USE_ESP32_BLE_ADVERTISING
-  uint8_t advertising_ref_count_{0};  // 1 byte, number of components requesting advertising
-#endif
 
 #ifdef ESPHOME_ESP32_BLE_EXTENDED_AUTH_PARAMS
   optional<esp_ble_auth_req_t> auth_req_mode_;

esphome/components/esp32_ble_beacon/esp32_ble_beacon.cpp

@@ -67,8 +67,6 @@ void ESP32BLEBeacon::setup() {
       this->on_advertise_();
     }
   });
-  // A beacon always needs the device to advertise, and never releases the request
-  global_ble->advertising_start();
 }
 
 void ESP32BLEBeacon::on_advertise_() {

esphome/components/esp32_ble_server/__init__.py

@@ -596,18 +596,6 @@ async def to_code(config):
     cg.add(var.set_parent(parent))
     cg.add(parent.advertising_set_appearance(config[CONF_APPEARANCE]))
     cg.add(var.set_max_clients(config[CONF_MAX_CLIENTS]))
-    # Only advertise for the server itself when the configuration gives clients something to
-    # find. A server that is auto-loaded purely to host a runtime service (esp32_improv) stays
-    # silent until that service asks for advertising.
-    cg.add(
-        var.set_advertising_required(
-            CONF_MANUFACTURER_DATA in config
-            or any(
-                not uuid_is(service_config[CONF_UUID], DEVICE_INFORMATION_SERVICE_UUID)
-                for service_config in config[CONF_SERVICES]
-            )
-        )
-    )
     if CONF_MANUFACTURER_DATA in config:
         cg.add(var.set_manufacturer_data(config[CONF_MANUFACTURER_DATA]))
     for service_config in config[CONF_SERVICES]:

esphome/components/esp32_ble_server/ble_server.cpp

@@ -81,7 +81,6 @@ void BLEServer::loop() {
       if (this->device_information_service_->is_running()) {
         this->state_ = RUNNING;
         this->restart_advertising_();
-        this->request_advertising_();
         ESP_LOGD(TAG, "BLE server setup successfully");
       } else if (this->device_information_service_->is_created()) {
         this->device_information_service_->start();
@@ -99,20 +98,6 @@ void BLEServer::restart_advertising_() {
   }
 }
 
-void BLEServer::request_advertising_() {
-  if (!this->advertising_required_ || this->advertising_requested_)
-    return;
-  this->advertising_requested_ = true;
-  this->parent_->advertising_start();
-}
-
-void BLEServer::release_advertising_() {
-  if (!this->advertising_requested_)
-    return;
-  this->advertising_requested_ = false;
-  this->parent_->advertising_stop();
-}
-
 BLEService *BLEServer::create_service(ESPBTUUID uuid, bool advertise, uint16_t num_handles) {
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   char uuid_buf[esp32_ble::UUID_STR_LEN];
@@ -185,7 +170,7 @@ void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t ga
       this->add_client_(param->connect.conn_id);
       // Resume advertising so additional clients can discover and connect
       if (this->client_count_ < this->max_clients_) {
-        this->parent_->advertising_refresh();
+        this->parent_->advertising_start();
       }
       this->dispatch_callbacks_(CallbackType::ON_CONNECT, param->connect.conn_id);
       break;
@@ -193,7 +178,7 @@ void BLEServer::gatts_event_handler(esp_gatts_cb_event_t event, esp_gatt_if_t ga
     case ESP_GATTS_DISCONNECT_EVT: {
       ESP_LOGD(TAG, "BLE Client disconnected");
       this->remove_client_(param->disconnect.conn_id);
-      this->parent_->advertising_refresh();
+      this->parent_->advertising_start();
       this->dispatch_callbacks_(CallbackType::ON_DISCONNECT, param->disconnect.conn_id);
       break;
     }
@@ -241,8 +226,6 @@ void BLEServer::remove_client_(uint16_t conn_id) {
 }
 
 void BLEServer::ble_before_disabled_event_handler() {
-  // Advertising is re-requested once the server is running again after BLE is re-enabled
-  this->release_advertising_();
   // Delete all clients
   this->client_count_ = 0;
   // Delete all services

esphome/components/esp32_ble_server/ble_server.h

@@ -38,13 +38,6 @@ class BLEServer final : public Component, public Parented<ESP32BLE> {
     this->restart_advertising_();
   }
 
-  /** Whether this server needs the device to advertise so clients can find and connect to it.
-   *
-   * False for a server that only hosts services created at runtime (e.g. esp32_improv), which
-   * request advertising themselves for as long as they need it.
-   */
-  void set_advertising_required(bool required) { this->advertising_required_ = required; }
-
   void set_max_clients(uint8_t max_clients) { this->max_clients_ = max_clients; }
   uint8_t get_max_clients() const { return this->max_clients_; }
 
@@ -89,8 +82,6 @@ class BLEServer final : public Component, public Parented<ESP32BLE> {
   };
 
   void restart_advertising_();
-  void request_advertising_();
-  void release_advertising_();
 
   int8_t find_client_index_(uint16_t conn_id) const;
   void add_client_(uint16_t conn_id);
@@ -102,8 +93,6 @@ class BLEServer final : public Component, public Parented<ESP32BLE> {
   std::vector<uint8_t> manufacturer_data_{};
   esp_gatt_if_t gatts_if_{0};
   bool registered_{false};
-  bool advertising_required_{true};
-  bool advertising_requested_{false};
 
   uint16_t clients_[USE_ESP32_BLE_MAX_CONNECTIONS]{};
   uint8_t client_count_{0};

esphome/components/esp32_improv/esp32_improv_component.cpp

@@ -112,7 +112,6 @@ void ESP32ImprovComponent::loop() {
       this->state_callback_.call(this->state_, this->error_state_);
 #endif
     }
-    this->release_advertising_();
     this->incoming_data_.clear();
     return;
   }
@@ -144,9 +143,8 @@ void ESP32ImprovComponent::loop() {
           ESP_LOGV(TAG, "Starting with device name advertising");
           this->advertising_device_name_ = true;
           this->last_name_adv_time_ = App.get_loop_component_start_time();
-          // Set the payload before requesting, so advertising starts exactly once
           esp32_ble::global_ble->advertising_set_service_data_and_name(std::span<const uint8_t>{}, true);
-          this->request_advertising_();
+          esp32_ble::global_ble->advertising_start();
 
           // Set initial state based on whether we have an authorizer
           this->set_state_(this->get_initial_state_(), false);
@@ -328,8 +326,6 @@ void ESP32ImprovComponent::stop() {
   this->set_timeout("end-service", STOP_ADVERTISING_DELAY, [this] {
     if (this->state_ == improv::STATE_STOPPED || this->service_ == nullptr)
       return;
-    // Release first so removing the service UUID does not restart advertising on the way out
-    this->release_advertising_();
     this->service_->stop();
     this->set_state_(improv::STATE_STOPPED);
   });
@@ -524,20 +520,6 @@ void ESP32ImprovComponent::update_advertising_type_() {
   }
 }
 
-void ESP32ImprovComponent::request_advertising_() {
-  if (this->advertising_requested_)
-    return;
-  this->advertising_requested_ = true;
-  esp32_ble::global_ble->advertising_start();
-}
-
-void ESP32ImprovComponent::release_advertising_() {
-  if (!this->advertising_requested_)
-    return;
-  this->advertising_requested_ = false;
-  esp32_ble::global_ble->advertising_stop();
-}
-
 improv::State ESP32ImprovComponent::get_initial_state_() const {
 #ifdef USE_BINARY_SENSOR
   // If we have an authorizer, start in awaiting authorization state

esphome/components/esp32_improv/esp32_improv_component.h

@@ -104,11 +104,8 @@ class ESP32ImprovComponent final : public Component, public improv_base::ImprovB
   bool status_indicator_state_{false};
   uint32_t last_name_adv_time_{0};
   bool advertising_device_name_{false};
-  bool advertising_requested_{false};
   void set_status_indicator_state_(bool state);
   void update_advertising_type_();
-  void request_advertising_();
-  void release_advertising_();
 
   void set_state_(improv::State state, bool update_advertising = true);
   void set_error_(improv::Error error);

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/mipi_dsi/mipi_dsi.cpp

@@ -35,8 +35,8 @@ void MipiDsi::setup() {
       .bus_id = 0,  // index from 0, specify the DSI host to use
       .num_data_lanes =
           this->lanes_,  // Number of data lanes to use, can't set a value that exceeds the chip's capability
-      // phy_clk_src left at 0 to enable runtime auto-select.
-      .lane_bit_rate_mbps = this->lane_bit_rate_,  // Bit rate of the data lanes, in Mbps
+      .phy_clk_src = MIPI_DSI_PHY_CLK_SRC_DEFAULT,  // Clock source for the DPHY
+      .lane_bit_rate_mbps = this->lane_bit_rate_,   // Bit rate of the data lanes, in Mbps
   };
   auto err = esp_lcd_new_dsi_bus(&bus_config, &this->bus_handle_);
   if (err != ESP_OK) {

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/template/climate/__init__.py

@@ -1,465 +0,0 @@
-from esphome import automation
-import esphome.codegen as cg
-from esphome.components import climate, sensor
-from esphome.components.climate import climate_ns
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ACTION,
-    CONF_CURRENT_TEMPERATURE,
-    CONF_CUSTOM_FAN_MODE,
-    CONF_CUSTOM_FAN_MODES,
-    CONF_CUSTOM_PRESET,
-    CONF_CUSTOM_PRESETS,
-    CONF_FAN_MODE,
-    CONF_HUMIDITY_SENSOR,
-    CONF_ID,
-    CONF_INITIAL_STATE,
-    CONF_MODE,
-    CONF_OPTIMISTIC,
-    CONF_PRESET,
-    CONF_RESTORE_MODE,
-    CONF_SENSOR,
-    CONF_SUPPORTED_FAN_MODES,
-    CONF_SUPPORTED_MODES,
-    CONF_SUPPORTED_PRESETS,
-    CONF_SUPPORTED_SWING_MODES,
-    CONF_SWING_MODE,
-    CONF_TARGET_TEMPERATURE,
-    CONF_TARGET_TEMPERATURE_HIGH,
-    CONF_TARGET_TEMPERATURE_LOW,
-)
-from esphome.core import ID
-from esphome.cpp_generator import MockObj, TemplateArgsType
-from esphome.types import ConfigType
-
-from .. import template_ns
-
-CONF_CURRENT_HUMIDITY = "current_humidity"
-CONF_TARGET_HUMIDITY = "target_humidity"
-CONF_SUPPORTS_ACTION = "supports_action"
-CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE = "supports_two_point_target_temperature"
-CONF_SUPPORTS_TARGET_HUMIDITY = "supports_target_humidity"
-CONF_SUPPORTS_CURRENT_TEMPERATURE = "supports_current_temperature"
-CONF_SUPPORTS_CURRENT_HUMIDITY = "supports_current_humidity"
-CONF_SET_MODE_ACTION = "set_mode_action"
-CONF_SET_TARGET_TEMPERATURE_ACTION = "set_target_temperature_action"
-CONF_SET_TARGET_TEMPERATURE_LOW_ACTION = "set_target_temperature_low_action"
-CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION = "set_target_temperature_high_action"
-CONF_SET_TARGET_HUMIDITY_ACTION = "set_target_humidity_action"
-CONF_SET_FAN_MODE_ACTION = "set_fan_mode_action"
-CONF_SET_CUSTOM_FAN_MODE_ACTION = "set_custom_fan_mode_action"
-CONF_SET_SWING_MODE_ACTION = "set_swing_mode_action"
-CONF_SET_PRESET_ACTION = "set_preset_action"
-CONF_SET_CUSTOM_PRESET_ACTION = "set_custom_preset_action"
-
-TemplateClimate = template_ns.class_("TemplateClimate", climate.Climate, cg.Component)
-TemplateClimatePublishAction = template_ns.class_(
-    "TemplateClimatePublishAction",
-    automation.Action,
-    cg.Parented.template(TemplateClimate),
-)
-
-TemplateClimateRestoreMode = template_ns.enum(
-    "TemplateClimateRestoreMode", is_class=True
-)
-CLIMATE_RESTORE_MODES = {
-    "NO_RESTORE": TemplateClimateRestoreMode.TEMPLATE_CLIMATE_RESTORE_MODE_NO_RESTORE,
-    "RESTORE": TemplateClimateRestoreMode.TEMPLATE_CLIMATE_RESTORE_MODE_RESTORE,
-}
-
-# Per-field actions that forward a requested value on. The third item is the type of `x`.
-SET_ACTIONS = (
-    (CONF_SET_MODE_ACTION, "get_set_mode_trigger", climate.ClimateMode),
-    (
-        CONF_SET_TARGET_TEMPERATURE_ACTION,
-        "get_set_target_temperature_trigger",
-        cg.float_,
-    ),
-    (
-        CONF_SET_TARGET_TEMPERATURE_LOW_ACTION,
-        "get_set_target_temperature_low_trigger",
-        cg.float_,
-    ),
-    (
-        CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION,
-        "get_set_target_temperature_high_trigger",
-        cg.float_,
-    ),
-    (CONF_SET_TARGET_HUMIDITY_ACTION, "get_set_target_humidity_trigger", cg.float_),
-    (CONF_SET_FAN_MODE_ACTION, "get_set_fan_mode_trigger", climate.ClimateFanMode),
-    (
-        CONF_SET_CUSTOM_FAN_MODE_ACTION,
-        "get_set_custom_fan_mode_trigger",
-        cg.StringRef,
-    ),
-    (
-        CONF_SET_SWING_MODE_ACTION,
-        "get_set_swing_mode_trigger",
-        climate.ClimateSwingMode,
-    ),
-    (CONF_SET_PRESET_ACTION, "get_set_preset_trigger", climate.ClimatePreset),
-    (CONF_SET_CUSTOM_PRESET_ACTION, "get_set_custom_preset_trigger", cg.StringRef),
-)
-
-# supports_* keys have no default so that an omitted key can mean "derive it from the sensor or
-# set action that makes the trait useful", which is not expressible once a default fills it in.
-DERIVED_SUPPORTS = (
-    (CONF_SUPPORTS_CURRENT_TEMPERATURE, (CONF_SENSOR,)),
-    (CONF_SUPPORTS_CURRENT_HUMIDITY, (CONF_HUMIDITY_SENSOR,)),
-    (
-        CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE,
-        (
-            CONF_SET_TARGET_TEMPERATURE_LOW_ACTION,
-            CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION,
-        ),
-    ),
-    (CONF_SUPPORTS_TARGET_HUMIDITY, (CONF_SET_TARGET_HUMIDITY_ACTION,)),
-)
-
-
-# Custom fan modes/presets are opaque user-defined strings with no build-time correctness check
-# elsewhere (Climate::set_supported_custom_fan_modes()/set_supported_custom_presets() don't block
-# empty entries), so reject empty ones here -- they could never be selected at runtime anyway.
-validate_custom_climate_string = cv.All(cv.string_strict, cv.Length(min=1))
-
-
-def _validate_two_point(config: ConfigType) -> ConfigType:
-    has_low = CONF_TARGET_TEMPERATURE_LOW in config
-    has_high = CONF_TARGET_TEMPERATURE_HIGH in config
-    if has_low != has_high:
-        raise cv.Invalid(
-            f"'{CONF_TARGET_TEMPERATURE_LOW}' and '{CONF_TARGET_TEMPERATURE_HIGH}' must be used together"
-        )
-    if (has_low or has_high) and CONF_TARGET_TEMPERATURE in config:
-        raise cv.Invalid(
-            f"'{CONF_TARGET_TEMPERATURE}' cannot be used together with "
-            f"'{CONF_TARGET_TEMPERATURE_LOW}'/'{CONF_TARGET_TEMPERATURE_HIGH}'"
-        )
-    return config
-
-
-def _validate_set_actions(config: ConfigType) -> ConfigType:
-    has_low = CONF_SET_TARGET_TEMPERATURE_LOW_ACTION in config
-    has_high = CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION in config
-    if has_low != has_high:
-        raise cv.Invalid(
-            f"'{CONF_SET_TARGET_TEMPERATURE_LOW_ACTION}' and "
-            f"'{CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION}' must be used together"
-        )
-    if (has_low or has_high) and CONF_SET_TARGET_TEMPERATURE_ACTION in config:
-        raise cv.Invalid(
-            f"'{CONF_SET_TARGET_TEMPERATURE_ACTION}' cannot be used together with "
-            f"'{CONF_SET_TARGET_TEMPERATURE_LOW_ACTION}'/'{CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION}'"
-        )
-    return config
-
-
-def _resolve_supports(config: ConfigType) -> ConfigType:
-    # An explicit true stays valid without either, since climate.template.publish can report the
-    # value; an explicit false that contradicts the configuration is an error, not a silent override.
-    for key, sources in DERIVED_SUPPORTS:
-        configured = [source for source in sources if source in config]
-        if key not in config:
-            config[key] = bool(configured)
-        elif not config[key] and configured:
-            raise cv.Invalid(
-                f"'{key}' cannot be false while '{configured[0]}' is configured",
-                path=[key],
-            )
-    return config
-
-
-def _validate_initial_state(config: ConfigType) -> ConfigType:
-    # Climate keeps target_temperature and target_temperature_low in a union, so writing the wrong
-    # one of the pair corrupts the setpoint with no runtime complaint.
-    if (initial_state := config.get(CONF_INITIAL_STATE)) is None:
-        return config
-
-    two_point = config[CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE]
-    if two_point and CONF_TARGET_TEMPERATURE in initial_state:
-        raise cv.Invalid(
-            f"'{CONF_TARGET_TEMPERATURE}' is not available while "
-            f"'{CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE}' is enabled; use "
-            f"'{CONF_TARGET_TEMPERATURE_LOW}'/'{CONF_TARGET_TEMPERATURE_HIGH}' instead",
-            path=[CONF_INITIAL_STATE, CONF_TARGET_TEMPERATURE],
-        )
-    if not two_point:
-        for key in (CONF_TARGET_TEMPERATURE_LOW, CONF_TARGET_TEMPERATURE_HIGH):
-            if key in initial_state:
-                raise cv.Invalid(
-                    f"'{key}' requires '{CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE}' to be enabled",
-                    path=[CONF_INITIAL_STATE, key],
-                )
-    if (
-        CONF_TARGET_HUMIDITY in initial_state
-        and not config[CONF_SUPPORTS_TARGET_HUMIDITY]
-    ):
-        raise cv.Invalid(
-            f"'{CONF_TARGET_HUMIDITY}' requires '{CONF_SUPPORTS_TARGET_HUMIDITY}' to be enabled",
-            path=[CONF_INITIAL_STATE, CONF_TARGET_HUMIDITY],
-        )
-    return config
-
-
-# Same settable fields as climate.template.publish, minus current_temperature/current_humidity/
-# action: those are reported values (from a sensor or the device), not meaningful static defaults.
-INITIAL_STATE_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.Optional(CONF_MODE): climate.validate_climate_mode,
-            cv.Optional(CONF_TARGET_TEMPERATURE): cv.temperature,
-            cv.Optional(CONF_TARGET_TEMPERATURE_LOW): cv.temperature,
-            cv.Optional(CONF_TARGET_TEMPERATURE_HIGH): cv.temperature,
-            cv.Optional(CONF_TARGET_HUMIDITY): cv.percentage_int,
-            cv.Exclusive(CONF_FAN_MODE, "fan_mode"): climate.validate_climate_fan_mode,
-            cv.Exclusive(
-                CONF_CUSTOM_FAN_MODE, "fan_mode"
-            ): validate_custom_climate_string,
-            cv.Optional(CONF_SWING_MODE): climate.validate_climate_swing_mode,
-            cv.Exclusive(CONF_PRESET, "preset"): climate.validate_climate_preset,
-            cv.Exclusive(CONF_CUSTOM_PRESET, "preset"): validate_custom_climate_string,
-        }
-    ),
-    _validate_two_point,
-)
-
-CONFIG_SCHEMA = cv.All(
-    climate.climate_schema(TemplateClimate)
-    .extend(
-        {
-            cv.Optional(CONF_SENSOR): cv.use_id(sensor.Sensor),
-            cv.Optional(CONF_HUMIDITY_SENSOR): cv.use_id(sensor.Sensor),
-            # action only ever arrives through climate.template.publish, so unlike the other
-            # supports_* keys there is no set action to derive it from.
-            cv.Optional(CONF_SUPPORTS_ACTION, default=False): cv.boolean,
-            cv.Optional(CONF_SUPPORTS_CURRENT_TEMPERATURE): cv.boolean,
-            cv.Optional(CONF_SUPPORTS_CURRENT_HUMIDITY): cv.boolean,
-            cv.Optional(CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE): cv.boolean,
-            cv.Optional(CONF_SUPPORTS_TARGET_HUMIDITY): cv.boolean,
-            cv.Required(CONF_SUPPORTED_MODES): cv.All(
-                cv.ensure_list(climate.validate_climate_mode), cv.Unique()
-            ),
-            cv.Optional(CONF_SUPPORTED_FAN_MODES): cv.All(
-                cv.ensure_list(climate.validate_climate_fan_mode), cv.Unique()
-            ),
-            cv.Optional(CONF_CUSTOM_FAN_MODES): cv.All(
-                cv.ensure_list(validate_custom_climate_string), cv.Unique()
-            ),
-            cv.Optional(CONF_SUPPORTED_SWING_MODES): cv.All(
-                cv.ensure_list(climate.validate_climate_swing_mode), cv.Unique()
-            ),
-            cv.Optional(CONF_SUPPORTED_PRESETS): cv.All(
-                cv.ensure_list(climate.validate_climate_preset), cv.Unique()
-            ),
-            cv.Optional(CONF_CUSTOM_PRESETS): cv.All(
-                cv.ensure_list(validate_custom_climate_string), cv.Unique()
-            ),
-            cv.Optional(CONF_OPTIMISTIC, default=True): cv.boolean,
-            cv.Optional(CONF_RESTORE_MODE, default="RESTORE"): cv.enum(
-                CLIMATE_RESTORE_MODES, upper=True
-            ),
-            cv.Optional(CONF_INITIAL_STATE): INITIAL_STATE_SCHEMA,
-            cv.Optional(CONF_SET_MODE_ACTION): automation.validate_automation(
-                single=True
-            ),
-            cv.Optional(
-                CONF_SET_TARGET_TEMPERATURE_ACTION
-            ): automation.validate_automation(single=True),
-            cv.Optional(
-                CONF_SET_TARGET_TEMPERATURE_LOW_ACTION
-            ): automation.validate_automation(single=True),
-            cv.Optional(
-                CONF_SET_TARGET_TEMPERATURE_HIGH_ACTION
-            ): automation.validate_automation(single=True),
-            cv.Optional(
-                CONF_SET_TARGET_HUMIDITY_ACTION
-            ): automation.validate_automation(single=True),
-            cv.Optional(CONF_SET_FAN_MODE_ACTION): automation.validate_automation(
-                single=True
-            ),
-            cv.Optional(
-                CONF_SET_CUSTOM_FAN_MODE_ACTION
-            ): automation.validate_automation(single=True),
-            cv.Optional(CONF_SET_SWING_MODE_ACTION): automation.validate_automation(
-                single=True
-            ),
-            cv.Optional(CONF_SET_PRESET_ACTION): automation.validate_automation(
-                single=True
-            ),
-            cv.Optional(CONF_SET_CUSTOM_PRESET_ACTION): automation.validate_automation(
-                single=True
-            ),
-        }
-    )
-    .extend(cv.COMPONENT_SCHEMA),
-    _validate_set_actions,
-    _resolve_supports,
-    _validate_initial_state,
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await climate.register_climate(var, config)
-
-    if (sens := config.get(CONF_SENSOR)) is not None:
-        cg.add(var.set_sensor(await cg.get_variable(sens)))
-
-    if (sens := config.get(CONF_HUMIDITY_SENSOR)) is not None:
-        cg.add(var.set_humidity_sensor(await cg.get_variable(sens)))
-
-    for key, flag in (
-        (CONF_SUPPORTS_ACTION, climate_ns.CLIMATE_SUPPORTS_ACTION),
-        (
-            CONF_SUPPORTS_CURRENT_TEMPERATURE,
-            climate_ns.CLIMATE_SUPPORTS_CURRENT_TEMPERATURE,
-        ),
-        (CONF_SUPPORTS_CURRENT_HUMIDITY, climate_ns.CLIMATE_SUPPORTS_CURRENT_HUMIDITY),
-        (
-            CONF_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE,
-            climate_ns.CLIMATE_SUPPORTS_TWO_POINT_TARGET_TEMPERATURE,
-        ),
-        (CONF_SUPPORTS_TARGET_HUMIDITY, climate_ns.CLIMATE_SUPPORTS_TARGET_HUMIDITY),
-    ):
-        if config[key]:
-            cg.add(var.add_feature_flags(flag))
-
-    for mode in config[CONF_SUPPORTED_MODES]:
-        cg.add(var.add_supported_mode(mode))
-
-    for mode in config.get(CONF_SUPPORTED_FAN_MODES, []):
-        cg.add(var.add_supported_fan_mode(mode))
-
-    if CONF_CUSTOM_FAN_MODES in config:
-        cg.add(
-            var.set_supported_custom_fan_modes(
-                cg.ArrayInitializer(*config[CONF_CUSTOM_FAN_MODES])
-            )
-        )
-
-    for mode in config.get(CONF_SUPPORTED_SWING_MODES, []):
-        cg.add(var.add_supported_swing_mode(mode))
-
-    for preset in config.get(CONF_SUPPORTED_PRESETS, []):
-        cg.add(var.add_supported_preset(preset))
-
-    if CONF_CUSTOM_PRESETS in config:
-        cg.add(
-            var.set_supported_custom_presets(
-                cg.ArrayInitializer(*config[CONF_CUSTOM_PRESETS])
-            )
-        )
-
-    for key, trigger_getter, arg_type in SET_ACTIONS:
-        if (conf := config.get(key)) is not None:
-            await automation.build_automation(
-                getattr(var, trigger_getter)(), [(arg_type, "x")], conf
-            )
-
-    cg.add(var.set_optimistic(config[CONF_OPTIMISTIC]))
-    cg.add(var.set_restore_mode(config[CONF_RESTORE_MODE]))
-
-    if (initial_state := config.get(CONF_INITIAL_STATE)) is not None:
-        if (v := initial_state.get(CONF_MODE)) is not None:
-            cg.add(var.set_mode(v))
-        if (v := initial_state.get(CONF_TARGET_TEMPERATURE)) is not None:
-            cg.add(var.set_target_temperature(v))
-        if (v := initial_state.get(CONF_TARGET_TEMPERATURE_LOW)) is not None:
-            cg.add(var.set_target_temperature_low(v))
-        if (v := initial_state.get(CONF_TARGET_TEMPERATURE_HIGH)) is not None:
-            cg.add(var.set_target_temperature_high(v))
-        if (v := initial_state.get(CONF_TARGET_HUMIDITY)) is not None:
-            cg.add(var.set_target_humidity(v))
-        if (v := initial_state.get(CONF_FAN_MODE)) is not None:
-            cg.add(var.set_fan_mode(v))
-        if (v := initial_state.get(CONF_CUSTOM_FAN_MODE)) is not None:
-            cg.add(var.set_custom_fan_mode(v))
-        if (v := initial_state.get(CONF_SWING_MODE)) is not None:
-            cg.add(var.set_swing_mode(v))
-        if (v := initial_state.get(CONF_PRESET)) is not None:
-            cg.add(var.set_preset(v))
-        if (v := initial_state.get(CONF_CUSTOM_PRESET)) is not None:
-            cg.add(var.set_custom_preset(v))
-
-
-CLIMATE_TEMPLATE_PUBLISH_ACTION_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.use_id(TemplateClimate),
-            cv.Optional(CONF_CURRENT_TEMPERATURE): cv.templatable(cv.temperature),
-            cv.Optional(CONF_CURRENT_HUMIDITY): cv.templatable(cv.percentage_int),
-            cv.Optional(CONF_TARGET_TEMPERATURE): cv.templatable(cv.temperature),
-            cv.Optional(CONF_TARGET_TEMPERATURE_LOW): cv.templatable(cv.temperature),
-            cv.Optional(CONF_TARGET_TEMPERATURE_HIGH): cv.templatable(cv.temperature),
-            cv.Optional(CONF_TARGET_HUMIDITY): cv.templatable(cv.percentage_int),
-            cv.Optional(CONF_MODE): cv.templatable(climate.validate_climate_mode),
-            cv.Optional(CONF_ACTION): cv.templatable(climate.validate_climate_action),
-            cv.Exclusive(CONF_FAN_MODE, "fan_mode"): cv.templatable(
-                climate.validate_climate_fan_mode
-            ),
-            cv.Exclusive(CONF_CUSTOM_FAN_MODE, "fan_mode"): cv.templatable(
-                validate_custom_climate_string
-            ),
-            cv.Optional(CONF_SWING_MODE): cv.templatable(
-                climate.validate_climate_swing_mode
-            ),
-            cv.Exclusive(CONF_PRESET, "preset"): cv.templatable(
-                climate.validate_climate_preset
-            ),
-            cv.Exclusive(CONF_CUSTOM_PRESET, "preset"): cv.templatable(
-                validate_custom_climate_string
-            ),
-        }
-    ),
-    _validate_two_point,
-)
-
-
-@automation.register_action(
-    "climate.template.publish",
-    TemplateClimatePublishAction,
-    CLIMATE_TEMPLATE_PUBLISH_ACTION_SCHEMA,
-    synchronous=True,
-)
-async def climate_template_publish_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 (v := config.get(CONF_CURRENT_TEMPERATURE)) is not None:
-        cg.add(var.set_current_temperature(await cg.templatable(v, args, cg.float_)))
-    if (v := config.get(CONF_CURRENT_HUMIDITY)) is not None:
-        cg.add(var.set_current_humidity(await cg.templatable(v, args, cg.float_)))
-    if (v := config.get(CONF_TARGET_TEMPERATURE)) is not None:
-        cg.add(var.set_target_temperature(await cg.templatable(v, args, cg.float_)))
-    if (v := config.get(CONF_TARGET_TEMPERATURE_LOW)) is not None:
-        cg.add(var.set_target_temperature_low(await cg.templatable(v, args, cg.float_)))
-    if (v := config.get(CONF_TARGET_TEMPERATURE_HIGH)) is not None:
-        cg.add(
-            var.set_target_temperature_high(await cg.templatable(v, args, cg.float_))
-        )
-    if (v := config.get(CONF_TARGET_HUMIDITY)) is not None:
-        cg.add(var.set_target_humidity(await cg.templatable(v, args, cg.float_)))
-    if (v := config.get(CONF_MODE)) is not None:
-        cg.add(var.set_mode(await cg.templatable(v, args, climate.ClimateMode)))
-    if (v := config.get(CONF_ACTION)) is not None:
-        cg.add(var.set_action(await cg.templatable(v, args, climate.ClimateAction)))
-    if (v := config.get(CONF_FAN_MODE)) is not None:
-        cg.add(var.set_fan_mode(await cg.templatable(v, args, climate.ClimateFanMode)))
-    if (v := config.get(CONF_CUSTOM_FAN_MODE)) is not None:
-        cg.add(var.set_custom_fan_mode(await cg.templatable(v, args, cg.std_string)))
-    if (v := config.get(CONF_SWING_MODE)) is not None:
-        cg.add(
-            var.set_swing_mode(await cg.templatable(v, args, climate.ClimateSwingMode))
-        )
-    if (v := config.get(CONF_PRESET)) is not None:
-        cg.add(var.set_preset(await cg.templatable(v, args, climate.ClimatePreset)))
-    if (v := config.get(CONF_CUSTOM_PRESET)) is not None:
-        cg.add(var.set_custom_preset(await cg.templatable(v, args, cg.std_string)))
-
-    return var

esphome/components/template/climate/automation.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include "template_climate.h"
-#include "esphome/core/automation.h"
-
-namespace esphome::template_ {
-
-template<typename... Ts>
-class TemplateClimatePublishAction final : public Action<Ts...>, public Parented<TemplateClimate> {
- public:
-  TEMPLATABLE_VALUE(float, current_temperature)
-  TEMPLATABLE_VALUE(float, current_humidity)
-  TEMPLATABLE_VALUE(float, target_temperature)
-  TEMPLATABLE_VALUE(float, target_temperature_low)
-  TEMPLATABLE_VALUE(float, target_temperature_high)
-  TEMPLATABLE_VALUE(float, target_humidity)
-  TEMPLATABLE_VALUE(climate::ClimateMode, mode)
-  TEMPLATABLE_VALUE(climate::ClimateAction, action)
-  TEMPLATABLE_VALUE(climate::ClimateFanMode, fan_mode)
-  TEMPLATABLE_VALUE(std::string, custom_fan_mode)
-  TEMPLATABLE_VALUE(climate::ClimateSwingMode, swing_mode)
-  TEMPLATABLE_VALUE(climate::ClimatePreset, preset)
-  TEMPLATABLE_VALUE(std::string, custom_preset)
-
-  void play(const Ts &...x) override {
-    if (this->current_temperature_.has_value())
-      this->parent_->current_temperature = this->current_temperature_.value(x...);
-    if (this->current_humidity_.has_value())
-      this->parent_->current_humidity = this->current_humidity_.value(x...);
-    if (this->target_temperature_.has_value())
-      this->parent_->set_target_temperature(this->target_temperature_.value(x...));
-    if (this->target_temperature_low_.has_value())
-      this->parent_->set_target_temperature_low(this->target_temperature_low_.value(x...));
-    if (this->target_temperature_high_.has_value())
-      this->parent_->set_target_temperature_high(this->target_temperature_high_.value(x...));
-    if (this->target_humidity_.has_value())
-      this->parent_->set_target_humidity(this->target_humidity_.value(x...));
-    if (this->mode_.has_value())
-      this->parent_->set_mode(this->mode_.value(x...));
-    if (this->action_.has_value())
-      this->parent_->action = this->action_.value(x...);
-    if (this->fan_mode_.has_value())
-      this->parent_->set_fan_mode(this->fan_mode_.value(x...));
-    if (this->custom_fan_mode_.has_value())
-      this->parent_->set_custom_fan_mode(StringRef(this->custom_fan_mode_.value(x...)));
-    if (this->swing_mode_.has_value())
-      this->parent_->set_swing_mode(this->swing_mode_.value(x...));
-    if (this->preset_.has_value())
-      this->parent_->set_preset(this->preset_.value(x...));
-    if (this->custom_preset_.has_value())
-      this->parent_->set_custom_preset(StringRef(this->custom_preset_.value(x...)));
-
-    this->parent_->publish_state();
-  }
-};
-
-}  // namespace esphome::template_

esphome/components/template/climate/template_climate.cpp

@@ -1,164 +0,0 @@
-#include "template_climate.h"
-#include "esphome/core/log.h"
-
-namespace esphome::template_ {
-
-static const char *const TAG = "template.climate";
-
-void TemplateClimate::setup() {
-  if (this->restore_mode_ == TemplateClimateRestoreMode::TEMPLATE_CLIMATE_RESTORE_MODE_RESTORE) {
-    auto restore = this->restore_state_();
-    if (restore.has_value()) {
-      restore->apply(this);
-    }
-  }
-
-  // Sensors publish every reading, not just changes, so only re-publish when the value moved.
-  // NAN means the sensor went unavailable and is passed through rather than dropped; the second
-  // check stops an unavailable sensor re-publishing forever, since NAN never equals NAN.
-#ifdef USE_SENSOR
-  if (this->sensor_ != nullptr) {
-    this->current_temperature = this->sensor_->state;
-    this->sensor_->add_on_state_callback([this](float state) {
-      if (state != this->current_temperature && !(std::isnan(state) && std::isnan(this->current_temperature))) {
-        this->current_temperature = state;
-        this->publish_state();
-      }
-    });
-  }
-
-  if (this->humidity_sensor_ != nullptr) {
-    this->current_humidity = this->humidity_sensor_->state;
-    this->humidity_sensor_->add_on_state_callback([this](float state) {
-      if (state != this->current_humidity && !(std::isnan(state) && std::isnan(this->current_humidity))) {
-        this->current_humidity = state;
-        this->publish_state();
-      }
-    });
-  }
-#endif
-}
-
-void TemplateClimate::dump_config() {
-  LOG_CLIMATE("", "Template Climate", this);
-  ESP_LOGCONFIG(TAG, "  Optimistic: %s", YESNO(this->optimistic_));
-}
-
-void TemplateClimate::control(const climate::ClimateCall &call) {
-  // Each field present fires its set_*_action; on_control sees the whole call. optimistic: true
-  // also applies the values right away, false waits for a climate.template.publish report.
-  if (auto mode = call.get_mode()) {
-    if (this->optimistic_)
-      this->mode = *mode;
-    this->set_mode_trigger_.trigger(*mode);
-  }
-
-  if (auto target_temp = call.get_target_temperature()) {
-    if (this->optimistic_)
-      this->target_temperature = *target_temp;
-    this->set_target_temperature_trigger_.trigger(*target_temp);
-  }
-
-  if (auto target_temp_low = call.get_target_temperature_low()) {
-    if (this->optimistic_)
-      this->target_temperature_low = *target_temp_low;
-    this->set_target_temperature_low_trigger_.trigger(*target_temp_low);
-  }
-
-  if (auto target_temp_high = call.get_target_temperature_high()) {
-    if (this->optimistic_)
-      this->target_temperature_high = *target_temp_high;
-    this->set_target_temperature_high_trigger_.trigger(*target_temp_high);
-  }
-
-  if (auto target_humidity = call.get_target_humidity()) {
-    if (this->optimistic_)
-      this->target_humidity = *target_humidity;
-    this->set_target_humidity_trigger_.trigger(*target_humidity);
-  }
-
-  if (auto fan_mode = call.get_fan_mode()) {
-    if (this->optimistic_)
-      this->set_fan_mode_(*fan_mode);
-    this->set_fan_mode_trigger_.trigger(*fan_mode);
-  }
-
-  if (call.has_custom_fan_mode()) {
-    if (this->optimistic_)
-      this->set_custom_fan_mode_(call.get_custom_fan_mode());
-    this->set_custom_fan_mode_trigger_.trigger(call.get_custom_fan_mode());
-  }
-
-  if (auto swing_mode = call.get_swing_mode()) {
-    if (this->optimistic_)
-      this->swing_mode = *swing_mode;
-    this->set_swing_mode_trigger_.trigger(*swing_mode);
-  }
-
-  if (auto preset = call.get_preset()) {
-    if (this->optimistic_)
-      this->set_preset_(*preset);
-    this->set_preset_trigger_.trigger(*preset);
-  }
-
-  if (call.has_custom_preset()) {
-    if (this->optimistic_)
-      this->set_custom_preset_(call.get_custom_preset());
-    this->set_custom_preset_trigger_.trigger(call.get_custom_preset());
-  }
-
-  if (this->optimistic_)
-    this->publish_state();
-}
-
-// A climate.template.publish report (and initial_state:) never goes through ClimateCall::validate_(),
-// so check here instead -- otherwise a typo is published as state the receiving end will reject.
-void TemplateClimate::set_mode(climate::ClimateMode mode) {
-  if (!this->traits_.supports_mode(mode)) {
-    ESP_LOGW(TAG, "'%s' - Unsupported mode %u", this->get_name().c_str(), static_cast<unsigned>(mode));
-    return;
-  }
-  this->mode = mode;
-}
-
-void TemplateClimate::set_swing_mode(climate::ClimateSwingMode swing_mode) {
-  if (!this->traits_.supports_swing_mode(swing_mode)) {
-    ESP_LOGW(TAG, "'%s' - Unsupported swing mode %u", this->get_name().c_str(), static_cast<unsigned>(swing_mode));
-    return;
-  }
-  this->swing_mode = swing_mode;
-}
-
-void TemplateClimate::set_fan_mode(climate::ClimateFanMode fan_mode) {
-  if (!this->traits_.supports_fan_mode(fan_mode)) {
-    ESP_LOGW(TAG, "'%s' - Unsupported fan mode %u", this->get_name().c_str(), static_cast<unsigned>(fan_mode));
-    return;
-  }
-  this->set_fan_mode_(fan_mode);
-}
-
-void TemplateClimate::set_preset(climate::ClimatePreset preset) {
-  if (!this->traits_.supports_preset(preset)) {
-    ESP_LOGW(TAG, "'%s' - Unsupported preset %u", this->get_name().c_str(), static_cast<unsigned>(preset));
-    return;
-  }
-  this->set_preset_(preset);
-}
-
-void TemplateClimate::set_custom_fan_mode(StringRef mode) {
-  if (this->find_custom_fan_mode_(mode.c_str(), mode.size()) == nullptr) {
-    ESP_LOGW(TAG, "'%s' - Unsupported custom fan mode '%s'", this->get_name().c_str(), mode.c_str());
-    return;
-  }
-  this->set_custom_fan_mode_(mode);
-}
-
-void TemplateClimate::set_custom_preset(StringRef preset) {
-  if (this->find_custom_preset_(preset.c_str(), preset.size()) == nullptr) {
-    ESP_LOGW(TAG, "'%s' - Unsupported custom preset '%s'", this->get_name().c_str(), preset.c_str());
-    return;
-  }
-  this->set_custom_preset_(preset);
-}
-
-}  // namespace esphome::template_

esphome/components/template/climate/template_climate.h

@@ -1,92 +0,0 @@
-#pragma once
-
-#include "esphome/core/automation.h"
-#include "esphome/core/component.h"
-#include "esphome/components/climate/climate.h"
-#ifdef USE_SENSOR
-#include "esphome/components/sensor/sensor.h"
-#endif
-
-namespace esphome::template_ {
-
-enum class TemplateClimateRestoreMode {
-  TEMPLATE_CLIMATE_RESTORE_MODE_NO_RESTORE,
-  TEMPLATE_CLIMATE_RESTORE_MODE_RESTORE,
-};
-
-class TemplateClimate final : public climate::Climate, public Component {
- public:
-  void setup() override;
-  void dump_config() override;
-
-  climate::ClimateTraits traits() override { return this->traits_; }
-
-  void add_feature_flags(uint32_t flags) { this->traits_.add_feature_flags(flags); }
-
-#ifdef USE_SENSOR
-  // The matching feature flag is added from codegen, so the configuration alone decides it.
-  void set_sensor(sensor::Sensor *sensor) { this->sensor_ = sensor; }
-  void set_humidity_sensor(sensor::Sensor *sensor) { this->humidity_sensor_ = sensor; }
-#endif
-
-  void add_supported_mode(climate::ClimateMode mode) { this->traits_.add_supported_mode(mode); }
-  void add_supported_fan_mode(climate::ClimateFanMode mode) { this->traits_.add_supported_fan_mode(mode); }
-  void add_supported_swing_mode(climate::ClimateSwingMode mode) { this->traits_.add_supported_swing_mode(mode); }
-  void add_supported_preset(climate::ClimatePreset preset) { this->traits_.add_supported_preset(preset); }
-
-  void set_optimistic(bool optimistic) { this->optimistic_ = optimistic; }
-  void set_restore_mode(TemplateClimateRestoreMode restore_mode) { this->restore_mode_ = restore_mode; }
-
-  // Fired from control() for each field the call carries, so a device-backed config can forward
-  // it on. Which of these are configured also decides the two-point/target-humidity traits.
-  Trigger<climate::ClimateMode> *get_set_mode_trigger() { return &this->set_mode_trigger_; }
-  Trigger<float> *get_set_target_temperature_trigger() { return &this->set_target_temperature_trigger_; }
-  Trigger<float> *get_set_target_temperature_low_trigger() { return &this->set_target_temperature_low_trigger_; }
-  Trigger<float> *get_set_target_temperature_high_trigger() { return &this->set_target_temperature_high_trigger_; }
-  Trigger<float> *get_set_target_humidity_trigger() { return &this->set_target_humidity_trigger_; }
-  Trigger<climate::ClimateFanMode> *get_set_fan_mode_trigger() { return &this->set_fan_mode_trigger_; }
-  Trigger<StringRef> *get_set_custom_fan_mode_trigger() { return &this->set_custom_fan_mode_trigger_; }
-  Trigger<climate::ClimateSwingMode> *get_set_swing_mode_trigger() { return &this->set_swing_mode_trigger_; }
-  Trigger<climate::ClimatePreset> *get_set_preset_trigger() { return &this->set_preset_trigger_; }
-  Trigger<StringRef> *get_set_custom_preset_trigger() { return &this->set_custom_preset_trigger_; }
-
-  // Used by TemplateClimatePublishAction, which is not a Climate subclass and so cannot reach the
-  // protected setters, and by codegen to apply `initial_state:` before setup() runs.
-  void set_target_temperature(float value) { this->target_temperature = value; }
-  void set_target_temperature_low(float value) { this->target_temperature_low = value; }
-  void set_target_temperature_high(float value) { this->target_temperature_high = value; }
-  void set_target_humidity(float value) { this->target_humidity = value; }
-  void set_mode(climate::ClimateMode mode);
-  void set_swing_mode(climate::ClimateSwingMode mode);
-  void set_fan_mode(climate::ClimateFanMode mode);
-  void set_custom_fan_mode(const char *mode) { this->set_custom_fan_mode(StringRef(mode)); }
-  void set_custom_fan_mode(StringRef mode);
-  void set_preset(climate::ClimatePreset preset);
-  void set_custom_preset(const char *preset) { this->set_custom_preset(StringRef(preset)); }
-  void set_custom_preset(StringRef preset);
-
- protected:
-  void control(const climate::ClimateCall &call) override;
-
-  climate::ClimateTraits traits_;
-  bool optimistic_{false};
-  TemplateClimateRestoreMode restore_mode_{TemplateClimateRestoreMode::TEMPLATE_CLIMATE_RESTORE_MODE_NO_RESTORE};
-
-#ifdef USE_SENSOR
-  sensor::Sensor *sensor_{nullptr};
-  sensor::Sensor *humidity_sensor_{nullptr};
-#endif
-
-  Trigger<climate::ClimateMode> set_mode_trigger_;
-  Trigger<float> set_target_temperature_trigger_;
-  Trigger<float> set_target_temperature_low_trigger_;
-  Trigger<float> set_target_temperature_high_trigger_;
-  Trigger<float> set_target_humidity_trigger_;
-  Trigger<climate::ClimateFanMode> set_fan_mode_trigger_;
-  Trigger<StringRef> set_custom_fan_mode_trigger_;
-  Trigger<climate::ClimateSwingMode> set_swing_mode_trigger_;
-  Trigger<climate::ClimatePreset> set_preset_trigger_;
-  Trigger<StringRef> set_custom_preset_trigger_;
-};
-
-}  // namespace esphome::template_

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/usb_uart/usb_uart.cpp

@@ -434,12 +434,11 @@ void USBUartTypeCdcAcm::on_connected() {
       auto err_comm = usb_host_interface_claim(this->handle_, this->device_handle_,
                                                channel->cdc_dev_.interrupt_interface_number, 0);
       if (err_comm != ESP_OK) {
-        // Continue anyway: the interface number stays valid for CDC request addressing
         ESP_LOGW(TAG, "Could not claim comm interface %d: %s", channel->cdc_dev_.interrupt_interface_number,
                  esp_err_to_name(err_comm));
+        channel->cdc_dev_.interrupt_interface_number = 0xFF;  // Mark as unavailable, but continue anyway
       } else {
         ESP_LOGD(TAG, "Claimed comm interface %d", channel->cdc_dev_.interrupt_interface_number);
-        channel->cdc_dev_.interrupt_interface_claimed = true;
       }
     }
     auto err =
@@ -466,15 +465,14 @@ void USBUartTypeCdcAcm::on_disconnected() {
       usb_host_endpoint_halt(this->device_handle_, channel->cdc_dev_.out_ep->bEndpointAddress);
       usb_host_endpoint_flush(this->device_handle_, channel->cdc_dev_.out_ep->bEndpointAddress);
     }
-    // Only tear down the notify pipe when we claimed its interface ourselves;
-    // no transfer is ever submitted on it, so there is nothing else to cancel.
-    if (channel->cdc_dev_.notify_ep != nullptr && channel->cdc_dev_.interrupt_interface_claimed) {
+    if (channel->cdc_dev_.notify_ep != nullptr) {
       usb_host_endpoint_halt(this->device_handle_, channel->cdc_dev_.notify_ep->bEndpointAddress);
       usb_host_endpoint_flush(this->device_handle_, channel->cdc_dev_.notify_ep->bEndpointAddress);
     }
-    if (channel->cdc_dev_.interrupt_interface_claimed) {
+    if (channel->cdc_dev_.interrupt_interface_number != 0xFF &&
+        channel->cdc_dev_.interrupt_interface_number != channel->cdc_dev_.bulk_interface_number) {
       usb_host_interface_release(this->handle_, this->device_handle_, channel->cdc_dev_.interrupt_interface_number);
-      channel->cdc_dev_.interrupt_interface_claimed = false;
+      channel->cdc_dev_.interrupt_interface_number = 0xFF;
     }
     usb_host_interface_release(this->handle_, this->device_handle_, channel->cdc_dev_.bulk_interface_number);
     // Reset the input and output started flags to their initial state to avoid the possibility of spurious restarts

esphome/components/usb_uart/usb_uart.h

@@ -34,10 +34,7 @@ struct CdcEps {
   const usb_ep_desc_t *in_ep;
   const usb_ep_desc_t *out_ep;
   uint8_t bulk_interface_number;
-  // Also the wIndex target for CDC class requests (SET_LINE_CODING etc.), so it
-  // must remain valid even when the interface itself is not claimed.
   uint8_t interrupt_interface_number;
-  bool interrupt_interface_claimed{false};
 };
 
 enum CH34xChipType : uint8_t {

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/__init__.py

@@ -66,14 +66,13 @@ from esphome.const import (
 )
 from esphome.core import (
     CORE,
-    ID,
     CoroPriority,
     EsphomeError,
     HexInt,
     coroutine_with_priority,
 )
 import esphome.final_validate as fv
-from esphome.types import ConfigType, TemplateArgsType
+from esphome.types import ConfigType
 
 from . import wpa2_eap
 
@@ -209,7 +208,6 @@ WiFiEnabledCondition = wifi_ns.class_("WiFiEnabledCondition", Condition)
 WiFiAPActiveCondition = wifi_ns.class_("WiFiAPActiveCondition", Condition)
 WiFiEnableAction = wifi_ns.class_("WiFiEnableAction", automation.Action)
 WiFiDisableAction = wifi_ns.class_("WiFiDisableAction", automation.Action)
-WiFiRoamAction = wifi_ns.class_("WiFiRoamAction", automation.Action)
 WiFiConfigureAction = wifi_ns.class_(
     "WiFiConfigureAction", automation.Action, cg.Component
 )
@@ -822,18 +820,6 @@ async def wifi_disable_to_code(config, action_id, template_arg, args):
     return cg.new_Pvariable(action_id, template_arg)
 
 
-@automation.register_action(
-    "wifi.roam", WiFiRoamAction, cv.Schema({}), synchronous=True
-)
-async def wifi_roam_to_code(
-    config: ConfigType,
-    action_id: ID,
-    template_arg: cg.TemplateArguments,
-    args: TemplateArgsType,
-) -> cg.MockObj:
-    return cg.new_Pvariable(action_id, template_arg)
-
-
 KEEP_SCAN_RESULTS_KEY = "wifi_keep_scan_results"
 RUNTIME_POWER_SAVE_KEY = "wifi_runtime_power_save"
 RUNTIME_ROAMING_SUPPRESSION_KEY = "wifi_runtime_roaming_suppression"

esphome/components/wifi/automation.h

@@ -31,11 +31,6 @@ template<typename... Ts> class WiFiDisableAction final : public Action<Ts...> {
   void play(const Ts &...x) override { global_wifi_component->disable(); }
 };
 
-template<typename... Ts> class WiFiRoamAction final : public Action<Ts...> {
- public:
-  void play(const Ts &...x) override { global_wifi_component->force_roam_check(); }
-};
-
 template<typename... Ts> class WiFiConfigureAction final : public Action<Ts...>, public Component {
  public:
   TEMPLATABLE_VALUE(std::string, ssid)

esphome/components/wifi/wifi_component.cpp

@@ -846,18 +846,17 @@ void WiFiComponent::loop() {
           this->notify_connect_state_listeners_();
 #endif
 
-          // Post-connect roaming: check for better AP. A scan may have been started by an
-          // explicit force_roam_check() even when post_connect_roaming_ is disabled, so the
-          // scan must always be consumed here to avoid leaving roaming_state_ stuck.
-          if (this->is_roaming_scan_active()) {
-            if (this->scan_done_) {
-              this->process_roaming_scan_();
+          // Post-connect roaming: check for better AP
+          if (this->post_connect_roaming_) {
+            if (this->is_roaming_scan_active()) {
+              if (this->scan_done_) {
+                this->process_roaming_scan_();
+              }
+              // else: scan in progress, wait
+            } else if (this->roaming_state_ == RoamingState::IDLE && this->roaming_attempts_ < ROAMING_MAX_ATTEMPTS &&
+                       now - this->roaming_last_check_ >= ROAMING_CHECK_INTERVAL && !this->roaming_suppressed_()) {
+              this->check_roaming_(now);
             }
-            // else: scan in progress, wait
-          } else if (this->post_connect_roaming_ && this->roaming_state_ == RoamingState::IDLE &&
-                     this->roaming_attempts_ < ROAMING_MAX_ATTEMPTS &&
-                     now - this->roaming_last_check_ >= ROAMING_CHECK_INTERVAL && !this->roaming_suppressed_()) {
-            this->check_roaming_(now);
           }
         }
         break;
@@ -2464,17 +2463,6 @@ void WiFiComponent::notify_scan_results_listeners_() {
 }
 #endif  // USE_WIFI_SCAN_RESULTS_LISTENERS
 
-void WiFiComponent::force_roam_check() {
-  if (!this->is_connected() || this->roaming_state_ != RoamingState::IDLE || this->roaming_suppressed_()) {
-    ESP_LOGD(TAG, "Roam check requested, but not able to check now");
-    return;
-  }
-  // Reset the attempt counter so a prior run of failed roams doesn't block this explicit request
-  // Note that this re-arms automatic roaming if enabled.
-  this->roaming_attempts_ = 0;
-  this->check_roaming_(millis());
-}
-
 void WiFiComponent::check_roaming_(uint32_t now) {
   // Guard: not for hidden networks (may not appear in scan)
   const WiFiAP *selected = this->get_selected_sta_();
@@ -2496,11 +2484,7 @@ void WiFiComponent::check_roaming_(uint32_t now) {
 
   ESP_LOGD(TAG, "Roam scan (%d dBm, attempt %u/%u)", rssi, this->roaming_attempts_, ROAMING_MAX_ATTEMPTS);
   this->roaming_state_ = RoamingState::SCANNING;
-  if (!this->wifi_scan_start_(this->passive_scan_)) {
-    // Scan failed to start (e.g. busy) - don't get stuck in SCANNING forever
-    ESP_LOGD(TAG, "Roam scan failed to start");
-    this->roaming_state_ = RoamingState::IDLE;
-  }
+  this->wifi_scan_start_(this->passive_scan_);
 }
 
 void WiFiComponent::process_roaming_scan_() {

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
@@ -565,12 +570,6 @@ class WiFiComponent final : public Component {
   void set_keep_scan_results(bool keep_scan_results) { this->keep_scan_results_ = keep_scan_results; }
   void set_post_connect_roaming(bool enabled) { this->post_connect_roaming_ = enabled; }
 
-  /** Force an immediate post-connect roaming check, bypassing the periodic interval and the
-   * per-connection attempt limit. Does nothing (besides a debug log) if not connected, if a
-   * roam scan or connect is already in progress, or if roaming is currently suppressed.
-   */
-  void force_roam_check();
-
 #ifdef USE_WIFI_CONNECT_TRIGGER
   Trigger<> *get_connect_trigger() { return &this->connect_trigger_; }
 #endif

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