Merge branch 'dev' into uart-debug-event-flash

Identical lambdas can carry separate static state, so callers need a way
to keep such tables apart while still getting a collision free name.

AGENTS.md

@@ -144,9 +144,6 @@ file does, and it is the authority when they disagree. The most useful starting
 
 *   **C++ Preprocessor Directives:**
     *   **Avoid `#define` for constants:** Using `#define` for constants is discouraged and should be replaced with `const` variables or enums.
-    *   **A constant with a compile-time initializer is `static constexpr`,** not `static const`, at namespace scope
-        and inside functions; `static const` is only for a value computed at run time. A function-local
-        `static constexpr` table is a static constant to clang-tidy, so it is `UPPER_SNAKE_CASE` too.
     *   **Use `#define` only for:**
         - Conditional compilation (`#ifdef`, `#ifndef`)
         - Compile-time sizes calculated during Python code generation (e.g., configuring `std::array` or `StaticVector` dimensions via `cg.add_define()`)
@@ -220,9 +217,6 @@ file does, and it is the authority when they disagree. The most useful starting
         listener base (a second vptr per entity).
     *   **A global feature define** says the code is compiled in, not that this instance uses it: keep the
         per-instance check (`if (this->aux_device_ == ...)`) inside the `#ifdef`.
-    *   **Model-specific code** sits behind a define the Python side emits only for configs that use that model
-        (`cg.add_define("USE_SELEC_METER_EM4M")`), so the other models' builds leave it out; the runtime model check
-        stays inside the `#ifdef`.
     *   **Failures after `setup()`:** `mark_failed()` is for `setup()` only. A runtime read or write failure
         sets `status_set_warning()` and the next success clears it; writes skip work when `is_failed()`.
     *   **Fixed platform facts compile to nothing:** gate on `#ifdef USE_ESP8266` and friends, not on a
@@ -573,9 +567,6 @@ file does, and it is the authority when they disagree. The most useful starting
     An intentionally empty body (an unused `register_dumper` builder, for example) gets a one-line docstring, not `pass`.
 
 *   **Configuration Validation:**
-    *   **One schema per model:** when a component's options depend on a `model` key, use `cv.typed_schema({...},
-        key=CONF_MODEL, default_type=...)` with each model's own keys and defaults, not one schema plus a validator
-        that rejects keys and fills defaults afterwards.
     *   **Reuse existing validators:** Before writing a custom validator, check for an existing one in `config_validation.py` and compose it in `cv.All(...)` rather than duplicating logic across components. For example, rename a config key with `cv.rename_key(CONF_OLD, CONF_NEW, removed_in="2026.6.0")`, and reject mutually-exclusive keys with `cv.has_at_most_one_key(...)` / `cv.has_exactly_one_key(...)`. See how `api` composes `cv.has_exactly_one_key` + `cv.rename_key`.
     *   **Common Validators:** `cv.int_`, `cv.float_`, `cv.string`, `cv.boolean`, `cv.int_range(min=0, max=100)`, `cv.positive_int`, `cv.percentage`.
     *   **Complex Validation:** `cv.All(cv.string, cv.Length(min=1, max=50))`, `cv.Any(cv.int_, cv.string)`.
@@ -618,9 +609,6 @@ file does, and it is the authority when they disagree. The most useful starting
         `on_tx` lambda with a static counter and `inject_to_rx_buffer` (see `uart_mock_ld2412_requery_after_giveup.yaml`).
     *   **Keep build-test variants few:** one `test.<platform>.yaml` per platform the code actually differs
         on. A variant per board for platform-identical code only adds CI time.
-    *   **A test that needs a shared component in a particular state** (`esp32_ble` security settings, an option
-        that PSRAM rejects) cannot be grouped: the merged block wins and the whole batch fails. Add the component to
-        `ISOLATED_COMPONENTS` in `script/analyze_component_buses.py`, or move the option to a `test-<variant>` file.
     *   **Component Tests:** YAML-based compilation tests are located in `tests/`. The structure is as follows:
         ```
         tests/

CODEOWNERS

@@ -212,7 +212,6 @@ esphome/components/factory_reset/* @anatoly-savchenkov
 esphome/components/fastled_base/* @OttoWinter
 esphome/components/feedback/* @ianchi
 esphome/components/file/* @esphome/core
-esphome/components/filter_lifetime/* @tuct
 esphome/components/fingerprint_grow/* @alexborro @loongyh @OnFreund
 esphome/components/font/* @clydebarrow @esphome/core
 esphome/components/friedrich/* @rwrozelle
@@ -243,9 +242,6 @@ esphome/components/haier/button/* @paveldn
 esphome/components/haier/sensor/* @paveldn
 esphome/components/haier/switch/* @paveldn
 esphome/components/haier/text_sensor/* @paveldn
-esphome/components/haier_tundra/* @fauxpark
-esphome/components/haier_tundra/button/* @fauxpark
-esphome/components/haier_tundra/switch/* @fauxpark
 esphome/components/havells_solar/* @sourabhjaiswal
 esphome/components/hbridge/fan/* @WeekendWarrior
 esphome/components/hbridge/light/* @DotNetDann
@@ -290,7 +286,6 @@ esphome/components/i2s_audio/microphone/* @jesserockz
 esphome/components/i2s_audio/speaker/* @jesserockz @kahrendt
 esphome/components/i2s_clockless_led_strip/* @j9brown
 esphome/components/iaqcore/* @yozik04
-esphome/components/icm20689/* @lboue
 esphome/components/icnt86/* @danepowell
 esphome/components/ili9xxx/* @clydebarrow @nielsnl68
 esphome/components/improv_base/* @esphome/core
@@ -439,7 +434,6 @@ esphome/components/ota/* @esphome/core
 esphome/components/output/* @esphome/core
 esphome/components/packet_transport/* @clydebarrow
 esphome/components/pca6416a/* @Mat931
-esphome/components/pca9505/* @ajfriesen @ssieb
 esphome/components/pca9554/* @bdraco @clydebarrow @hwstar
 esphome/components/pcf85063/* @brogon
 esphome/components/pcf8563/* @KoenBreeman

esphome/__main__.py

@@ -483,9 +483,12 @@ def has_ota() -> bool:
 
 def has_native_ota() -> bool:
     """Check if native API OTA upload is available (``platform: esphome``)."""
-    from esphome.espota2 import esphome_ota_items
-
-    return bool(esphome_ota_items(CORE.config))
+    if CONF_OTA not in CORE.config:
+        return False
+    return any(
+        ota_item.get(CONF_PLATFORM) == CONF_ESPHOME
+        for ota_item in CORE.config[CONF_OTA]
+    )
 
 
 def has_web_server_ota() -> bool:
@@ -1356,17 +1359,14 @@ def _choose_ota_platform(config: ConfigType, requested: str | None) -> str:
     return CONF_WEB_SERVER
 
 
-def _esphome_ota_conf(config: ConfigType) -> ConfigType | None:
-    """The validated esphome OTA platform block, if configured."""
-    from esphome.espota2 import esphome_ota_items
-
-    return next(iter(esphome_ota_items(config)), None)
-
-
 def _upload_via_native_api(
     config: ConfigType, network_devices: list[str], args: ArgsProtocol
 ) -> tuple[int, str | None]:
-    ota_conf = _esphome_ota_conf(config) or {}
+    ota_conf: ConfigType = {}
+    for ota_item in config.get(CONF_OTA, []):
+        if ota_item.get(CONF_PLATFORM) == CONF_ESPHOME:
+            ota_conf = ota_item
+            break
 
     from esphome import espota2
     from esphome.components.noise import static_encryption_key
@@ -1457,8 +1457,10 @@ def _old_key_notice(config: ConfigType) -> None:
     `upload` may send a stale image that still carries the previous key."""
     from esphome import espota2
 
-    for item in espota2.esphome_ota_items(config):
-        if (item.get(CONF_ENCRYPTION) or {}).get(espota2.CONF_OLD_KEY):
+    for item in config.get(CONF_OTA, []):
+        if item.get(CONF_PLATFORM) == CONF_ESPHOME and (
+            item.get(CONF_ENCRYPTION) or {}
+        ).get(espota2.CONF_OLD_KEY):
             _LOGGER.warning(espota2.OLD_KEY_REMOVE_NOTICE)
 
 
@@ -1466,12 +1468,12 @@ def _upload_via_web_server(
     config: ConfigType, network_devices: list[str], binary: Path
 ) -> tuple[int, str | None]:
     from esphome import web_server_ota
-    from esphome.espota2 import esphome_ota_items
     from esphome.web_server_helpers import get_web_server_connection
 
     if any(
-        ota_item.get(CONF_ENCRYPTION) is not None
-        for ota_item in esphome_ota_items(config)
+        ota_item.get(CONF_PLATFORM) == CONF_ESPHOME
+        and ota_item.get(CONF_ENCRYPTION) is not None
+        for ota_item in config.get(CONF_OTA, [])
     ):
         _LOGGER.warning(
             "This config has OTA encryption, but the web_server OTA path sends "

esphome/automation.py

@@ -906,21 +906,6 @@ async def while_action_to_code(
     return var
 
 
-def _shadow_iteration(args: TemplateArgsType) -> TemplateArgsType:
-    """Rename an inherited `iteration` so the inner repeat's own counter can shadow it."""
-    names = {name for _, name in args}
-    renamed: TemplateArgsType = []
-    for type_, name in args:
-        if name == "iteration":
-            depth = 1
-            while f"iteration_{depth}" in names:
-                depth += 1
-            name = f"iteration_{depth}"
-            names.add(name)
-        renamed.append((type_, name))
-    return renamed
-
-
 @register_action(
     "repeat",
     RepeatAction,
@@ -944,7 +929,7 @@ async def repeat_action_to_code(
     actions = await build_action_list(
         config[CONF_THEN],
         cg.TemplateArguments(cg.uint32, *template_arg.args),
-        [(cg.uint32, "iteration"), *_shadow_iteration(args)],
+        [(cg.uint32, "iteration"), *args],
     )
     for action in actions:
         cg.add(var.add_then_action(action))

esphome/components/bedjet/bedjet_const.h

@@ -1,11 +1,10 @@
 #pragma once
 
 #include <set>
-#include "esphome/core/log.h"
 
 namespace esphome::bedjet {
 
-ESPHOME_LOG_TAG(TAG, "bedjet");
+static const char *const TAG = "bedjet";
 
 /// Converts a BedJet fan step to a speed percentage, in the range of 5% to 100%.
 inline static uint8_t bedjet_fan_step_to_speed(const uint8_t fan) {

esphome/components/ble_client/automation.cpp

@@ -4,7 +4,7 @@
 
 namespace esphome::ble_client {
 
-const char *const Automation::TAG = "ble_client.automation";  // NOLINT: ble_client never builds for ESP8266
+const char *const Automation::TAG = "ble_client.automation";
 
 }  // namespace esphome::ble_client
 

esphome/components/bme280_i2c/bme280_i2c.h

@@ -2,11 +2,10 @@
 
 #include "esphome/components/bme280_base/bme280_base.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/core/log.h"
 
 namespace esphome::bme280_i2c {
 
-ESPHOME_LOG_TAG(TAG, "bme280_i2c.sensor");
+static const char *const TAG = "bme280_i2c.sensor";
 
 class BME280I2CComponent final : public esphome::bme280_base::BME280Component, public i2c::I2CDevice {
   bool read_byte(uint8_t a_register, uint8_t *data) override;

esphome/components/bmp280_i2c/bmp280_i2c.h

@@ -2,11 +2,10 @@
 
 #include "esphome/components/bmp280_base/bmp280_base.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/core/log.h"
 
 namespace esphome::bmp280_i2c {
 
-ESPHOME_LOG_TAG(TAG, "bmp280_i2c.sensor");
+static const char *const TAG = "bmp280_i2c.sensor";
 
 /// This class implements support for the BMP280 Temperature+Pressure i2c sensor.
 class BMP280I2CComponent final : public esphome::bmp280_base::BMP280Component, public i2c::I2CDevice {

esphome/components/bmp581_i2c/bmp581_i2c.h

@@ -2,11 +2,10 @@
 
 #include "esphome/components/bmp581_base/bmp581_base.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/core/log.h"
 
 namespace esphome::bmp581_i2c {
 
-ESPHOME_LOG_TAG(TAG, "bmp581_i2c.sensor");
+static const char *const TAG = "bmp581_i2c.sensor";
 
 /// This class implements support for the BMP581 Temperature+Pressure i2c sensor.
 class BMP581I2CComponent final : public esphome::bmp581_base::BMP581Component, public i2c::I2CDevice {

esphome/components/chsc6x/chsc6x_touchscreen.h

@@ -8,7 +8,7 @@
 
 namespace esphome::chsc6x {
 
-ESPHOME_LOG_TAG(TAG, "chsc6x.touchscreen");
+static const char *const TAG = "chsc6x.touchscreen";
 
 static const uint8_t CHSC6X_REG_STATUS = 0x00;
 static const uint8_t CHSC6X_REG_STATUS_TOUCH = 0x00;

esphome/components/cst816/touchscreen/cst816_touchscreen.h

@@ -8,7 +8,7 @@
 
 namespace esphome::cst816 {
 
-ESPHOME_LOG_TAG(TAG, "cst816.touchscreen");
+static const char *const TAG = "cst816.touchscreen";
 
 static const uint8_t REG_STATUS = 0x00;
 static const uint8_t REG_TOUCH_NUM = 0x02;

esphome/components/cst9220/touchscreen/cst9220_touchscreen.h

@@ -8,7 +8,7 @@
 
 namespace esphome::cst9220 {
 
-ESPHOME_LOG_TAG(TAG, "cst9220.touchscreen");
+static const char *const TAG = "cst9220.touchscreen";
 
 // The CST92xx family uses 16-bit (big-endian) register addresses.
 static const uint16_t REG_TOUCH_DATA = 0xD000;  // touch report

esphome/components/deep_sleep/__init__.py

@@ -143,8 +143,6 @@ def validate_wakeup_pin(
         processed_pins: list[ConfigType] = [{CONF_PIN: value}]
     else:
         processed_pins = list(value)
-        if not processed_pins:
-            raise cv.Invalid("'wakeup_pin' needs at least one entry")
 
     for i, pin_config in enumerate(processed_pins):
         # now validate each item
@@ -156,34 +154,29 @@ def validate_wakeup_pin(
 
 
 def validate_config(config: ConfigType) -> ConfigType:
-    wakeup_pins = config.get(CONF_WAKEUP_PIN)
-    has_pin_mode = CONF_WAKEUP_PIN_MODE in config
-    if has_pin_mode and wakeup_pins is None:
+    # right now only BK72XX supports the list format for wakeup pins
+    if CORE.is_bk72xx:
+        if CONF_WAKEUP_PIN_MODE in config:
+            wakeup_pins = config.get(CONF_WAKEUP_PIN, [])
+            if len(wakeup_pins) > 1:
+                raise cv.Invalid(
+                    "You need to remove the global wakeup_pin_mode and define it per pin"
+                )
+            if wakeup_pins:
+                if CONF_WAKEUP_PIN_MODE in wakeup_pins[0]:
+                    raise cv.Invalid(
+                        "Specify wakeup_pin_mode either at the top level under deep_sleep "
+                        "or under the pin entry, not both"
+                    )
+                wakeup_pins[0][CONF_WAKEUP_PIN_MODE] = config.pop(CONF_WAKEUP_PIN_MODE)
+    elif (
+        isinstance(config.get(CONF_WAKEUP_PIN), list)
+        and len(config[CONF_WAKEUP_PIN]) > 1
+    ):
         raise cv.Invalid(
-            "'wakeup_pin_mode' requires 'wakeup_pin'", path=[CONF_WAKEUP_PIN_MODE]
+            "Your platform does not support providing multiple entries in wakeup_pin"
         )
-    multiple_pins = wakeup_pins is not None and len(wakeup_pins) > 1
-    # wakeup_pin is limited to ESP32 and BK72XX, and only BK72XX accepts a list
-    if not CORE.is_bk72xx:
-        if multiple_pins:
-            raise cv.Invalid(
-                "ESP32 does not support multiple entries for 'wakeup_pin'",
-                path=[CONF_WAKEUP_PIN],
-            )
-    elif has_pin_mode:
-        if multiple_pins:
-            raise cv.Invalid(
-                "Remove the global 'wakeup_pin_mode' and define it per pin",
-                path=[CONF_WAKEUP_PIN_MODE],
-            )
-        if CONF_WAKEUP_PIN_MODE in (pin := wakeup_pins[0]):
-            raise cv.Invalid(
-                "Specify 'wakeup_pin_mode' either at the top level under 'deep_sleep' "
-                "or under the pin entry, not both",
-                path=[CONF_WAKEUP_PIN, 0, CONF_WAKEUP_PIN_MODE],
-            )
-        # Move the global mode into the single pin entry, which to_code() reads
-        pin[CONF_WAKEUP_PIN_MODE] = config.pop(CONF_WAKEUP_PIN_MODE)
+
     return config
 
 
@@ -210,11 +203,11 @@ def _validate_sleep_duration(value: core.TimePeriod) -> core.TimePeriod:
     if CORE.is_bk72xx:
         max_duration = core.TimePeriod(hours=36)
         if value > max_duration:
-            raise cv.Invalid("'sleep_duration' cannot be more than 36 hours on BK72XX")
+            raise cv.Invalid("sleep duration cannot be more than 36 hours on BK72XX")
     elif CORE.using_zephyr:
         max_duration = core.TimePeriod(days=49)
         if value > max_duration:
-            raise cv.Invalid("'sleep_duration' cannot be more than 49 days on Zephyr")
+            raise cv.Invalid("sleep duration cannot be more than 49 days on Zephyr")
     return value
 
 
@@ -297,10 +290,7 @@ CONFIG_SCHEMA = cv.All(
                 cv.positive_time_period_milliseconds,
                 _validate_sleep_duration,
             ),
-            cv.Optional(CONF_WAKEUP_PIN): cv.All(
-                cv.only_on([PLATFORM_ESP32, PLATFORM_BK72XX]),
-                validate_wakeup_pin,
-            ),
+            cv.Optional(CONF_WAKEUP_PIN): validate_wakeup_pin,
             cv.Optional(CONF_WAKEUP_PIN_MODE): cv.All(
                 cv.only_on([PLATFORM_ESP32, PLATFORM_BK72XX]),
                 cv.enum(WAKEUP_PIN_MODES, upper=True),
@@ -357,10 +347,11 @@ async def to_code(config: ConfigType) -> None:
 
     if CONF_SLEEP_DURATION in config:
         cg.add(var.set_sleep_duration(config[CONF_SLEEP_DURATION]))
-    if (wakeup_pins := config.get(CONF_WAKEUP_PIN)) is not None:
+    if CONF_WAKEUP_PIN in config:
+        pins_as_list = config.get(CONF_WAKEUP_PIN, [])
         if CORE.is_bk72xx:
-            cg.add(var.init_wakeup_pins(len(wakeup_pins)))
-            for item in wakeup_pins:
+            cg.add(var.init_wakeup_pins(len(pins_as_list)))
+            for item in pins_as_list:
                 cg.add(
                     var.add_wakeup_pin(
                         await cg.gpio_pin_expression(item[CONF_PIN]),
@@ -370,7 +361,7 @@ async def to_code(config: ConfigType) -> None:
                     )
                 )
         else:
-            pin = await cg.gpio_pin_expression(wakeup_pins[0][CONF_PIN])
+            pin = await cg.gpio_pin_expression(pins_as_list[0][CONF_PIN])
             cg.add(var.set_wakeup_pin(pin))
     if CONF_WAKEUP_PIN_MODE in config:
         cg.add(var.set_wakeup_pin_mode(config[CONF_WAKEUP_PIN_MODE]))

esphome/components/display/display_color_utils.h

@@ -1,6 +1,4 @@
 #pragma once
-#include <array>
-#include <cstdint>
 #include "esphome/core/color.h"
 
 namespace esphome::display {
@@ -156,54 +154,4 @@ class ColorUtil {
     return color;
   }
 };
-
-/** Rec.601 luma weights (0.299/0.587/0.114), scaled by 256 */
-static constexpr uint16_t REC601_LUMA_R = 77;
-static constexpr uint16_t REC601_LUMA_G = 150;
-static constexpr uint16_t REC601_LUMA_B = 29;
-
-/** Rec.601 luma of an RGB color, for optimum perceptual brightness */
-constexpr uint8_t rec601_luma(Color color) {
-  return (uint8_t) ((REC601_LUMA_R * color.r + REC601_LUMA_G * color.g + REC601_LUMA_B * color.b + 128u) >> 8);
-}
-
-/** Map an RGB color to a single monochrome bit: 1 = white, 0 = black */
-constexpr uint8_t color_to_mono(Color color) { return rec601_luma(color) >= 128 ? 1 : 0; }
-
-/** color_to_mono() of an RGB565 value as ColorUtil::to_color() reads it, from table lookups instead of a division
- * per channel.
- */
-class Rgb565ToMono {
- public:
-  explicit Rgb565ToMono(ColorOrder order) {
-    // Rec.601 weight of the 5-bit, 6-bit and 5-bit fields, by the channel each one holds in this order
-    uint16_t high = REC601_LUMA_R, middle = REC601_LUMA_G, low = REC601_LUMA_B;
-    if (order == COLOR_ORDER_BGR) {
-      high = REC601_LUMA_B;
-      low = REC601_LUMA_R;
-    } else if (order == COLOR_ORDER_GRB) {
-      high = REC601_LUMA_G;
-      middle = REC601_LUMA_R;
-    }
-    // Each field value scaled to 0..255, then weighted
-    for (unsigned i = 0; i != 32; i++) {
-      this->high_[i] = high * esp_scale(i, 31);
-      this->low_[i] = low * esp_scale(i, 31);
-    }
-    for (unsigned i = 0; i != 64; i++)
-      this->middle_[i] = middle * esp_scale(i, 63);
-  }
-
-  uint8_t operator()(uint16_t value) const {
-    const uint32_t weighted = this->high_[value >> 11] + this->middle_[(value >> 5) & 0x3F] + this->low_[value & 0x1F];
-    return ((weighted + 128u) >> 8) >= 128 ? 1 : 0;
-  }
-
- protected:
-  // Weighted contribution of each value of each field
-  std::array<uint16_t, 32> high_{};
-  std::array<uint16_t, 64> middle_{};
-  std::array<uint16_t, 32> low_{};
-};
-
 }  // namespace esphome::display

esphome/components/emontx/__init__.py

@@ -23,18 +23,11 @@ DEPENDENCIES = ["uart"]
 
 emontx_ns = cg.esphome_ns.namespace("emontx")
 EmonTx = emontx_ns.class_("EmonTx", cg.Component, uart.UARTDevice)
-LockOnReboot = emontx_ns.enum("LockOnReboot", is_class=True)
 
 CONF_EMONTX_ID = "emontx_id"
 CONF_TAG_NAME = "tag_name"
 CONF_ON_JSON = "on_json"
 CONF_LOCK_ON_REBOOT = "lock_on_reboot"
-LOCK_ON_REBOOT_AUTO = "auto"
-LOCK_ON_REBOOT_MODES = {
-    LOCK_ON_REBOOT_AUTO: LockOnReboot.LOCK_ON_REBOOT_AUTO,
-    True: LockOnReboot.LOCK_ON_REBOOT_ALWAYS,
-    False: LockOnReboot.LOCK_ON_REBOOT_NEVER,
-}
 
 DOMAIN = "emontx"
 
@@ -66,9 +59,7 @@ CONFIG_SCHEMA = (
             cv.GenerateID(): cv.declare_id(EmonTx),
             cv.Optional(CONF_ON_JSON): _synchronous_automation_schema(),
             cv.Optional(CONF_ON_DATA): _synchronous_automation_schema(),
-            cv.Optional(CONF_LOCK_ON_REBOOT, default=LOCK_ON_REBOOT_AUTO): cv.Any(
-                cv.boolean, cv.one_of(LOCK_ON_REBOOT_AUTO, lower=True)
-            ),
+            cv.Optional(CONF_LOCK_ON_REBOOT, default=False): cv.boolean,
         }
     )
     .extend(cv.COMPONENT_SCHEMA)
@@ -144,11 +135,8 @@ async def to_code(config: ConfigType) -> None:
     await uart.register_uart_device(var, config)
     await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
-    lock = config[CONF_LOCK_ON_REBOOT]
-    cg.add(var.set_lock_on_reboot(LOCK_ON_REBOOT_MODES[lock]))
-    if lock == LOCK_ON_REBOOT_AUTO:
-        # Locking depends on the firmware version the emonTx reports
-        cg.add_define("USE_EMONTX_VERSION")
+    if config[CONF_LOCK_ON_REBOOT]:
+        cg.add(var.set_lock_on_reboot(True))
 
 
 # Action: emontx.send_command

esphome/components/emontx/emontx.cpp

@@ -1,91 +1,23 @@
 #include "emontx.h"
 #include "esphome/core/log.h"
-#include "esphome/core/progmem.h"
 #include "esphome/components/json/json_util.h"
 
 namespace esphome::emontx {
 
 ESPHOME_LOG_TAG(TAG, "emontx");
 
-static constexpr uint32_t UNLOCK_ID = 0;
-// The emonTx joins bytes received while a command is pending into that command, so the next one waits
-static constexpr uint32_t COMMAND_GAP_MS = 250;
-
-#ifdef USE_EMONTX_VERSION
-static constexpr uint32_t VERSION_REQUEST_ID = 1;
-// Without a reply, 'v' is sent again every VERSION_RETRY_FRAMES data lines, VERSION_MAX_ATTEMPTS times in all
-static constexpr uint8_t VERSION_RETRY_FRAMES = 2;
-static constexpr uint8_t VERSION_MAX_ATTEMPTS = 3;
-// Line of the 'v' reply (and of the boot banner) carrying the release, e.g. "  - Version:    v1.1.1"
-static const char VERSION_PREFIX[] PROGMEM = "  - Version:";
-// Every data line starts with the message counter, in JSON or text format
-static const char MSG_JSON_PREFIX[] PROGMEM = "{\"MSG\":";
-static const char MSG_TEXT_PREFIX[] PROGMEM = "MSG:";
-// First firmware with 'emonlock' and 'emonunlock'; older firmware takes them for the bootloader command
-static constexpr uint32_t LOCK_MIN_MAJOR = 1;
-static constexpr uint32_t LOCK_MIN_MINOR = 2;
-
-// True if line starts with the PROGMEM prefix and has more after it
-static bool starts_with(const char *line, size_t len, const char *prefix, size_t prefix_len) {
-  return len > prefix_len && ESPHOME_strncmp_P(line, prefix, prefix_len) == 0;
-}
-
-// Reads the decimal number (up to 9 digits) at pos and moves pos past it; false if there is none
-static bool read_number(const char *&pos, const char *end, uint32_t &value) {
-  const char *start = pos;
-  value = 0;
-  while (pos < end && pos - start < 9 && *pos >= '0' && *pos <= '9')
-    value = value * 10 + (*pos++ - '0');
-  return pos != start;
-}
-
-// True for a release such as "v1.2.0" or "v1.3.0-rc1" from LOCK_MIN_MAJOR.LOCK_MIN_MINOR on
-static bool supports_lock(const char *version, const char *end) {
-  if (version < end && (*version == 'v' || *version == 'V'))
-    version++;
-  uint32_t major;
-  if (!read_number(version, end, major) || version == end || *version != '.')
-    return false;
-  version++;
-  uint32_t minor;
-  if (!read_number(version, end, minor))
-    return false;
-  return major > LOCK_MIN_MAJOR || (major == LOCK_MIN_MAJOR && minor >= LOCK_MIN_MINOR);
-}
-#endif
-
 void EmonTx::setup() {
   this->buffer_pos_ = 0;
-  if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_ALWAYS) {
-    // The line feed ends any boot noise
-    this->write_byte('\n');
-    this->set_timeout(UNLOCK_ID, COMMAND_GAP_MS, [this]() {
-      this->unlock_();
-#ifdef USE_EMONTX_VERSION
-      if (this->wants_version_())
-        this->request_version_();
-#endif
-    });
+  if (!this->lock_on_reboot_)
     return;
-  }
-#ifdef USE_EMONTX_VERSION
-  // With AUTO, the reply decides whether to unlock
-  if (this->wants_version_())
-    this->request_version_();
-#endif
-}
-
-void EmonTx::unlock_() {
-  ESP_LOGI(TAG, "Unlocking emonTx");
+  // The line feed ends any boot noise first
+  ESP_LOGI(TAG, "Unlocking emonTx after boot");
+  this->write_byte('\n');
   this->send_command("emonunlock");
 }
 
 void EmonTx::on_shutdown() {
-  bool lock = this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_ALWAYS;
-#ifdef USE_EMONTX_VERSION
-  lock |= this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO && this->lock_supported_;
-#endif
-  if (!lock)
+  if (!this->lock_on_reboot_)
     return;
   if (this->is_paused()) {
     ESP_LOGW(TAG, "Not locking emonTx before shutdown, UART is paused");
@@ -116,11 +48,6 @@ void EmonTx::loop() {
     uint8_t dropped;
     while (this->available() > 0 && this->read_byte(&dropped))
       this->discarding_line_ = dropped != '\n';
-#ifdef USE_EMONTX_VERSION
-    // The emonTx may have been flashed, or a request dropped, during the pause
-    if (this->wants_version_())
-      this->request_version_();
-#endif
   }
 
   // Read all available data to prevent UART buffer overflow
@@ -150,12 +77,6 @@ void EmonTx::loop() {
           ESP_LOGV(TAG, "Line is JSON, parsing...");
           this->parse_json_(this->buffer_.data(), len);
         }
-#ifdef USE_EMONTX_VERSION
-        if (this->wants_version_()) {
-          this->parse_msg_number_(this->buffer_.data(), len);
-          this->parse_version_line_(this->buffer_.data(), len);
-        }
-#endif
       }
     } else if (received == '\r' || this->discarding_line_) {
       // Ignore CR, and the rest of a line that overflowed or was interrupted by a pause
@@ -191,91 +112,12 @@ void EmonTx::parse_json_(const char *data, size_t len) {
   }
 }
 
-#ifdef USE_EMONTX_VERSION
-void EmonTx::request_version_() {
-  // The firmware may have changed; until the reply, an unknown version gets no lock commands
-  this->lock_supported_ = false;
-  this->version_frames_left_ = VERSION_RETRY_FRAMES * VERSION_MAX_ATTEMPTS;
-  this->send_version_request_();
-}
-
-// The line feed ends any pending input; the reply is picked up in loop() by parse_version_line_()
-void EmonTx::send_version_request_() {
-  if (this->is_paused())
-    return;
-  this->write_byte('\n');
-  this->set_timeout(VERSION_REQUEST_ID, COMMAND_GAP_MS, [this]() { this->send_command("v"); });
-}
-
-void EmonTx::parse_msg_number_(const char *line, size_t len) {
-  const char *pos;
-  if (starts_with(line, len, MSG_JSON_PREFIX, sizeof(MSG_JSON_PREFIX) - 1)) {
-    pos = line + sizeof(MSG_JSON_PREFIX) - 1;
-  } else if (starts_with(line, len, MSG_TEXT_PREFIX, sizeof(MSG_TEXT_PREFIX) - 1)) {
-    pos = line + sizeof(MSG_TEXT_PREFIX) - 1;
-  } else {
-    return;
-  }
-  uint32_t msg_number;
-  if (!read_number(pos, line + len, msg_number))
-    return;
-
-  // MSG restarts at 1 when the emonTx reboots, as it does after a firmware update
-  if (msg_number <= this->last_msg_number_) {
-    this->request_version_();
-  } else if (this->version_frames_left_ > 0) {
-    if (--this->version_frames_left_ == 0) {
-      ESP_LOGW(TAG, "No firmware version from the emonTx, it may still be locked");
-    } else if (this->version_frames_left_ % VERSION_RETRY_FRAMES == 0) {
-      this->send_version_request_();
-    }
-  }
-  this->last_msg_number_ = msg_number;
-}
-
-void EmonTx::parse_version_line_(const char *line, size_t len) {
-  constexpr size_t prefix_len = sizeof(VERSION_PREFIX) - 1;
-  if (!starts_with(line, len, VERSION_PREFIX, prefix_len))
-    return;
-  const char *version = line + prefix_len;
-  const char *end = line + len;
-  while (version < end && *version == ' ')
-    version++;
-  if (version == end)
-    return;
-  ESP_LOGI(TAG, "emonTx firmware version: %.*s", static_cast<int>(end - version), version);
-  this->version_frames_left_ = 0;
-#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
-  if (this->version_text_sensor_ != nullptr)
-    this->version_text_sensor_->publish_state(version, end - version);
-#endif
-
-  bool supported = supports_lock(version, end);
-  if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO && supported && !this->unlock_sent_) {
-    // Once the rest of the reply has gone out; a pause drops it, and the version request on resume retries
-    this->set_timeout(UNLOCK_ID, COMMAND_GAP_MS, [this]() {
-      if (this->is_paused())
-        return;
-      this->unlock_();
-      this->unlock_sent_ = true;
-    });
-  }
-  this->lock_supported_ = supported;
-}
-#endif
-
 /**
  * @brief Logs the EmonTx component configuration details.
  */
 void EmonTx::dump_config() {
   ESP_LOGCONFIG(TAG, "EmonTx:");
-  const char *lock = LOG_STR_LITERAL("no");
-  if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_ALWAYS) {
-    lock = LOG_STR_LITERAL("yes");
-  } else if (this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO) {
-    lock = LOG_STR_LITERAL("auto");
-  }
-  ESP_LOGCONFIG(TAG, "  Lock on reboot: %s", lock);
+  ESP_LOGCONFIG(TAG, "  Lock on reboot: %s", YESNO(this->lock_on_reboot_));
 
 #ifdef USE_SENSOR
   ESP_LOGCONFIG(TAG, "  Registered sensors: %zu", this->sensors_.size());
@@ -285,9 +127,6 @@ void EmonTx::dump_config() {
 #else
   ESP_LOGCONFIG(TAG, "  Sensor support: DISABLED");
 #endif
-#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
-  LOG_TEXT_SENSOR("  ", "Firmware version", this->version_text_sensor_);
-#endif
 }
 
 /**

esphome/components/emontx/emontx.h

@@ -13,21 +13,12 @@
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"
 #endif
-#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
-#include "esphome/components/text_sensor/text_sensor.h"
-#endif
 
 namespace esphome::emontx {
 
 /// Maximum line length in bytes (plus one byte reserved for null terminator)
 static constexpr size_t MAX_LINE_LENGTH = 1024;
 
-enum class LockOnReboot : uint8_t {
-  LOCK_ON_REBOOT_NEVER,
-  LOCK_ON_REBOOT_ALWAYS,
-  LOCK_ON_REBOOT_AUTO,  // Only when the emonTx reports firmware v1.2.0 or later
-};
-
 /**
  * @class EmonTx
  * @brief Main class for the EmonTx component.
@@ -36,9 +27,6 @@ enum class LockOnReboot : uint8_t {
  * extracts tags and values, and publishes them to registered sensors.
  */
 class EmonTx final : public Component, public uart::UARTDevice {
-#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
-  SUB_TEXT_SENSOR(version)
-#endif
  public:
   EmonTx() = default;
 
@@ -62,8 +50,8 @@ class EmonTx final : public Component, public uart::UARTDevice {
   bool is_paused() const { return this->paused_.load(std::memory_order_relaxed); }
 
   /// Lock the emonTx ('emonlock') before a reboot, so serial garbage during the reboot is not taken
-  /// as a command, and unlock it after boot. Needs emonTx firmware v1.2.0 or later, which AUTO checks.
-  void set_lock_on_reboot(LockOnReboot lock_on_reboot) { this->lock_on_reboot_ = lock_on_reboot; }
+  /// as a command, and unlock it in setup(). Needs emonTx firmware v1.2.0 or later.
+  void set_lock_on_reboot(bool lock_on_reboot) { this->lock_on_reboot_ = lock_on_reboot; }
 
 #ifdef USE_SENSOR
   void init_sensors(size_t count) { this->sensors_.init(count); }
@@ -72,20 +60,6 @@ class EmonTx final : public Component, public uart::UARTDevice {
 
  protected:
   void parse_json_(const char *data, size_t len);
-  void unlock_();
-#ifdef USE_EMONTX_VERSION
-  bool wants_version_() const {
-#ifdef USE_EMONTX_VERSION_TEXT_SENSOR
-    if (this->version_text_sensor_ != nullptr)
-      return true;
-#endif
-    return this->lock_on_reboot_ == LockOnReboot::LOCK_ON_REBOOT_AUTO;
-  }
-  void request_version_();
-  void send_version_request_();
-  void parse_msg_number_(const char *line, size_t len);
-  void parse_version_line_(const char *line, size_t len);
-#endif
 
 #ifdef USE_SENSOR
   FixedVector<std::pair<const char *, sensor::Sensor *>> sensors_{};
@@ -95,14 +69,8 @@ class EmonTx final : public Component, public uart::UARTDevice {
   uint16_t buffer_pos_{0};
   std::atomic<bool> paused_{false};
   bool was_paused_{false};
-  LockOnReboot lock_on_reboot_{LockOnReboot::LOCK_ON_REBOOT_NEVER};
+  bool lock_on_reboot_{false};
   bool discarding_line_{false};  // Set after an overflow or a pause until the end of that line
-#ifdef USE_EMONTX_VERSION
-  bool lock_supported_{false};      // The last version reported is v1.2.0 or later
-  bool unlock_sent_{false};         // AUTO has sent 'emonunlock' since boot
-  uint8_t version_frames_left_{0};  // Data lines still to wait for a version reply; 0 when none is owed
-  uint32_t last_msg_number_{0};
-#endif
   std::array<char, MAX_LINE_LENGTH + 1> buffer_{};
 };
 

esphome/components/emontx/text_sensor/__init__.py

@@ -1,24 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import text_sensor
-import esphome.config_validation as cv
-from esphome.const import CONF_VERSION, ENTITY_CATEGORY_DIAGNOSTIC, ICON_CHIP
-from esphome.types import ConfigType
-
-from .. import CONF_EMONTX_ID, EmonTx
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_EMONTX_ID): cv.use_id(EmonTx),
-        cv.Optional(CONF_VERSION): text_sensor.text_sensor_schema(
-            entity_category=ENTITY_CATEGORY_DIAGNOSTIC, icon=ICON_CHIP
-        ),
-    }
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_EMONTX_ID])
-    text_sensors = text_sensor.sub_text_sensors(config)
-    if await text_sensors(CONF_VERSION, hub.set_version_text_sensor) is not None:
-        cg.add_define("USE_EMONTX_VERSION")
-        cg.add_define("USE_EMONTX_VERSION_TEXT_SENSOR")

esphome/components/epaper_spi/colorconv.h

@@ -2,7 +2,6 @@
 
 #include <cstdint>
 #include <algorithm>
-#include "esphome/components/display/display_color_utils.h"
 #include "esphome/core/color.h"
 
 /* Utility for converting internal \a Color RGB representation to supported IC hardware color keys
@@ -14,15 +13,21 @@
 
 namespace esphome::epaper_spi {
 
-// The Rec.601 luma helpers and the RGB565 mono lookup live in the shared display utilities, so other
-// drivers (e.g. it8951 in its 1 bit per pixel mode) can use them too.
-using display::color_to_mono;
-using display::rec601_luma;
-using display::Rgb565ToMono;
-
 /** Delta for when to regard as gray */
 static constexpr uint8_t COLORCONV_GRAY_THRESHOLD = 50;
 
+/** Rec.601 luma (0.299/0.587/0.114 weights, scaled by 256) for optimum perceptual brightness */
+constexpr uint8_t rec601_luma(Color color) {
+  return (uint8_t) ((77u * color.r + 150u * color.g + 29u * color.b + 128u) >> 8);
+}
+
+/** Map RGB color to a single monochrome bit
+ *
+ * @param color RGB color to convert from
+ * @return      1 = white, 0 = black
+ */
+constexpr uint8_t color_to_mono(Color color) { return rec601_luma(color) >= 128 ? 1 : 0; }
+
 /** Map RGB color to one of 4 discrete gray levels (2 bits per pixel)
  *
  * @param color RGB color to convert from

esphome/components/epaper_spi/epaper_spi.cpp

@@ -131,7 +131,9 @@ void EPaperBase::update() {
 }
 
 void EPaperBase::wait_for_idle_(bool should_wait) {
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   this->waiting_for_idle_start_ = millis();
+#endif
   this->waiting_for_idle_ = should_wait;
 }
 
@@ -154,10 +156,6 @@ void EPaperBase::loop() {
       ESP_LOGV(TAG, "Screen was busy for %u ms", (unsigned) (millis() - this->waiting_for_idle_start_));
 #endif
     } else {
-      if (now - this->waiting_for_idle_start_ > this->busy_timeout_seconds_ * 1000u) {
-        this->abandon_update_();
-        return;
-      }
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
       if (now - this->waiting_for_idle_last_print_ >= 1000) {
         ESP_LOGV(TAG, "Waiting for idle in state %s", this->epaper_state_to_string_());
@@ -170,20 +168,6 @@ void EPaperBase::loop() {
   this->process_state_();
 }
 
-// The busy pin never cleared: give up on this update so later ones are not refused, and make the next one full
-void EPaperBase::abandon_update_() {
-  ESP_LOGE(TAG, "Display stayed busy for %u s in state %s; check the busy pin", (unsigned) this->busy_timeout_seconds_,
-           this->epaper_state_to_string_());
-  this->status_set_warning(LOG_STR("Busy pin timeout"));
-  if (this->state_ == EPaperState::TRANSFER_DATA)
-    this->abort_transfer();
-  // Leave the panel powered down rather than with its high-voltage drivers enabled
-  this->power_off();
-  this->full_update_requested_ = true;
-  this->current_data_index_ = 0;
-  this->set_state_(EPaperState::IDLE);
-}
-
 /**
  * Process the state machine.
  * Typical state sequence:
@@ -258,7 +242,6 @@ void EPaperBase::process_state_() {
       break;
     case EPaperState::DEEP_SLEEP:
       this->deep_sleep();
-      this->status_clear_warning();
       this->set_state_(EPaperState::IDLE);
       ESP_LOGD(TAG, "Display update took %" PRIu32 " ms", millis() - this->update_start_time_);
       break;
@@ -362,120 +345,6 @@ void HOT EPaperBase::draw_pixel_at(int x, int y, Color color) {
   }
 }
 
-namespace {
-// One source row of an RGB565 block, written into a contiguous 1 bit per pixel buffer. Without SwapAxes the row lies
-// along a buffer row and the bit moves by step; with it the row lies along a bit column and the byte moves by step
-// rows.
-template<bool SwapAxes, bool BigEndianSource>
-void HOT write_rgb565_row(uint8_t *byte, uint8_t mask, int step, size_t row_width, const uint8_t *source, int count,
-                          const Rgb565ToMono &to_mono) {
-  const ptrdiff_t byte_step = SwapAxes ? step * static_cast<ptrdiff_t>(row_width) : 0;
-  for (; count != 0; count--, source += 2) {
-    const uint16_t value = BigEndianSource ? (source[0] << 8) | source[1] : source[0] | (source[1] << 8);
-    if (to_mono(value)) {
-      *byte |= mask;
-    } else {
-      *byte &= ~mask;
-    }
-    if constexpr (SwapAxes) {
-      byte += byte_step;
-    } else if (step > 0) {
-      mask >>= 1;
-      if (mask == 0) {
-        mask = 0x80;
-        byte++;
-      }
-    } else {
-      mask <<= 1;
-      if (mask == 0) {
-        mask = 0x01;
-        byte--;
-      }
-    }
-  }
-}
-}  // namespace
-
-// Each source column maps to one buffer coordinate and each source row to the other, each moving by 1 per pixel, so
-// the visible part of a block and its dirty area are worked out once for the whole block.
-void HOT EPaperBase::draw_rgb565_block_(uint8_t *buffer, int x_start, int y_start, int w, int h, const uint8_t *ptr,
-                                        ColorOrder order, bool big_endian, int x_offset, int y_offset, int x_pad) {
-  const bool swap = this->effective_transform_ & SWAP_XY;
-  const bool mirror_x = this->effective_transform_ & MIRROR_X;
-  const bool mirror_y = this->effective_transform_ & MIRROR_Y;
-  // The buffer axis a source column moves along, and the one a source row moves along
-  const int column_limit = swap ? this->height_ : this->width_;
-  const int row_limit = swap ? this->width_ : this->height_;
-  const bool column_mirrored = swap ? mirror_y : mirror_x;
-  const bool row_mirrored = swap ? mirror_x : mirror_y;
-  const int first_column = std::max(0, -x_start);
-  const int end_column = std::min(w, column_limit - x_start);
-  const int first_row = std::max(0, -y_start);
-  const int end_row = std::min(h, row_limit - y_start);
-  if (first_column >= end_column || first_row >= end_row)
-    return;
-  auto column_to_buffer = [&](int column) {
-    const int u = x_start + column;
-    return column_mirrored ? column_limit - 1 - u : u;
-  };
-  auto row_to_buffer = [&](int row) {
-    const int v = y_start + row;
-    return row_mirrored ? row_limit - 1 - v : v;
-  };
-
-  const int column_low = std::min(column_to_buffer(first_column), column_to_buffer(end_column - 1));
-  const int row_low = std::min(row_to_buffer(first_row), row_to_buffer(end_row - 1));
-  const int columns = end_column - first_column;
-  const int rows = end_row - first_row;
-  const int x_low = swap ? row_low : column_low;
-  const int y_low = swap ? column_low : row_low;
-  const int x_high = x_low + (swap ? rows : columns);
-  const int y_high = y_low + (swap ? columns : rows);
-
-  const Rgb565ToMono to_mono(order);
-  const size_t line_stride = x_offset + w + x_pad;
-  const size_t row_width = this->row_width_;
-  const int step = column_mirrored ? -1 : 1;
-  for (int row = first_row; row != end_row; row++) {
-    const uint8_t *source = ptr + ((y_offset + row) * line_stride + x_offset + first_column) * 2;
-    const int along = column_to_buffer(first_column);
-    const int across = row_to_buffer(row);
-    const int x = swap ? across : along;
-    const int y = swap ? along : across;
-    uint8_t *byte = buffer + y * row_width + x / 8;
-    const uint8_t mask = 0x80u >> (x % 8);
-    if (swap) {
-      if (big_endian) {
-        write_rgb565_row<true, true>(byte, mask, step, row_width, source, columns, to_mono);
-      } else {
-        write_rgb565_row<true, false>(byte, mask, step, row_width, source, columns, to_mono);
-      }
-    } else if (big_endian) {
-      write_rgb565_row<false, true>(byte, mask, step, row_width, source, columns, to_mono);
-    } else {
-      write_rgb565_row<false, false>(byte, mask, step, row_width, source, columns, to_mono);
-    }
-  }
-  this->x_low_ = clamp_at_most(this->x_low_, x_low);
-  this->x_high_ = clamp_at_least(this->x_high_, x_high);
-  this->y_low_ = clamp_at_most(this->y_low_, y_low);
-  this->y_high_ = clamp_at_least(this->y_high_, y_high);
-}
-
-// Writes an RGB565 block of pixels, as LVGL sends them, straight into a 1 bit per pixel buffer that is one block (the
-// usual case): the same result as draw_pixel_at() for each pixel. Anything else goes through draw_pixel_at().
-void HOT EPaperBase::draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
-                                    ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) {
-  size_t contiguous_length;
-  uint8_t *contiguous = this->buffer_.get_span(0, contiguous_length);
-  if (!this->buffer_is_mono() || this->get_clipping().is_set() || bitness != COLOR_BITNESS_565 ||
-      contiguous_length != this->buffer_length_) {
-    Display::draw_pixels_at(x_start, y_start, w, h, ptr, order, bitness, big_endian, x_offset, y_offset, x_pad);
-    return;
-  }
-  this->draw_rgb565_block_(contiguous, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset, x_pad);
-}
-
 void EPaperBase::dump_config() {
   LOG_DISPLAY("", "E-Paper SPI", this);
   ESP_LOGCONFIG(TAG,

esphome/components/epaper_spi/epaper_spi.h

@@ -107,8 +107,6 @@ class EPaperBase : public Display,
   int get_width() override { return this->effective_transform_ & SWAP_XY ? this->height_ : this->width_; }
   int get_height() override { return this->effective_transform_ & SWAP_XY ? this->width_ : this->height_; }
   void draw_pixel_at(int x, int y, Color color) override;
-  void draw_pixels_at(int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
-                      ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
   // Make the next update a full one. Applied when that update starts, so one in progress is not affected.
   void request_full_update() { this->full_update_requested_ = true; }
   // True from the start of an update until the display has refreshed and gone back to sleep.
@@ -127,14 +125,9 @@ class EPaperBase : public Display,
   virtual bool initialise(bool partial);
   void send_init_sequence_(const uint8_t *sequence, size_t length);
   void wait_for_idle_(bool should_wait);
-  void abandon_update_();
   bool init_buffer_(size_t buffer_length);
   void update_effective_transform_();
   bool rotate_coordinates_(int &x, int &y);
-  void draw_rgb565_block_(uint8_t *buffer, int x_start, int y_start, int w, int h, const uint8_t *ptr, ColorOrder order,
-                          bool big_endian, int x_offset, int y_offset, int x_pad);
-  // Whether the buffer holds 1 bit per pixel as draw_pixel_at() writes it, so draw_pixels_at() can write it directly
-  virtual bool buffer_is_mono() const { return false; }
 
   /**
    * Methods that must be implemented by concrete classes to control the display
@@ -144,8 +137,6 @@ class EPaperBase : public Display,
    * @return true if done, false if it should be called next loop
    */
   virtual bool transfer_data() = 0;
-  // Called when an update is abandoned in the middle of transfer_data(), to release anything it left open
-  virtual void abort_transfer() {}
   /**
    * Refresh the screen after data transfer
    */
@@ -196,20 +187,18 @@ class EPaperBase : public Display,
   // point to the pixel past the last one updated, i.e. may range up to width/height.
   uint16_t x_low_{}, y_low_{}, x_high_{}, y_high_{};
 
-  uint32_t waiting_for_idle_start_{};
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
   uint32_t waiting_for_idle_last_print_{};
+  uint32_t waiting_for_idle_start_{};
 #endif
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_DEBUG
   uint32_t update_start_time_{};
 #endif
 
   // properties with specific initialisers go last
-  uint32_t reset_duration_{10};
-  // Longer than any panel takes to refresh; past it the busy pin is assumed stuck
-  uint16_t busy_timeout_seconds_{120};
-  uint8_t full_update_every_{1};
   EPaperState state_{EPaperState::IDLE};
+  uint32_t reset_duration_{10};
+  uint8_t full_update_every_{1};
 };
 
 }  // namespace esphome::epaper_spi

esphome/components/epaper_spi/epaper_spi_mono.h

@@ -15,7 +15,6 @@ class EPaperMono : public EPaperBase {
   }
 
  protected:
-  bool buffer_is_mono() const override { return true; }
   void refresh_screen(bool partial) override;
   void power_on() override {}
   void power_off() override{};

esphome/components/epaper_spi/epaper_spi_ssd1677.cpp

@@ -58,9 +58,7 @@ bool HOT EPaperSSD1677::transfer_data() {
   // A full update ignores 0x26, and the copy may not hold a real frame yet (first update after
   // boot): send the new frame to both planes.
   const bool send_copy = this->plane_ == 0 && this->update_count_ != 0;
-  // A mono buffer already holds the frame as a RAM plane does, so it can be sent as it is; a deeper
-  // buffer (the four-level model) returns false and packs the plane in plane_row().
-  const bool direct = send_copy || this->buffer_is_mono();
+  const bool direct = send_copy || this->buffer_is_plane();
   const auto &source = send_copy ? this->sent_ : this->buffer_;
   const size_t row_length = this->plane_row_length_();
   const size_t plane_length = row_length * this->height_;

esphome/components/epaper_spi/epaper_spi_ssd1677.h

@@ -34,6 +34,9 @@ class EPaperSSD1677 : public EPaperMono {
   void init_comparison_frame_();
   // Bytes in one row of a RAM plane: 8 pixels per byte, whatever the buffer holds.
   size_t plane_row_length_() const { return (this->width_ + 7) / 8; }
+  // Whether the buffer already holds the frame as a RAM plane does, so it can be sent as it is.
+  // A subclass with a deeper buffer returns false and overrides plane_row().
+  virtual bool buffer_is_plane() const { return true; }
   // Row y of the frame as a RAM plane holds it, 1 bit per pixel with 1 = white.
   virtual void plane_row(size_t y, uint8_t *out);
   bool reset() override;

esphome/components/epaper_spi/epaper_spi_ssd1677_gray4.h

@@ -38,9 +38,9 @@ class EPaperSSD1677Gray4 : public EPaperSSD1677 {
   void draw_pixel_at(int x, int y, Color color) override;
 
  protected:
-  bool buffer_is_mono() const override { return false; }
   // A partial update if partial updates are enabled and this is not a full one.
   bool is_partial_push_() const { return this->update_count_ != 0 && this->sent_.is_valid(); }
+  bool buffer_is_plane() const override { return false; }
   void plane_row(size_t y, uint8_t *out) override;
   void refresh_screen(bool partial) override;
   bool transfer_data() override;

esphome/components/epaper_spi/epaper_spi_t133a01.cpp

@@ -364,15 +364,6 @@ bool HOT EPaperT133A01::transfer_data() {
   return true;
 }
 
-void EPaperT133A01::abort_transfer() {
-  // A data stream is open, with one of the chip selects held low, whenever transfer_data() has started sending rows
-  if (this->current_data_index_ == 0)
-    return;
-  this->disable();
-  this->cs_pin_->digital_write(true);
-  this->cs1_pin_->digital_write(true);
-}
-
 void EPaperT133A01::dump_config() {
   EPaperBase::dump_config();
   LOG_PIN("  CS Pin: ", this->cs_pin_);

esphome/components/epaper_spi/epaper_spi_t133a01.h

@@ -46,7 +46,6 @@ class EPaperT133A01 : public EPaperBase {
   void deep_sleep() override;
 
   bool transfer_data() override;
-  void abort_transfer() override;
 
   /**
    * Send a command (and optional data) selecting one or both controllers.

esphome/components/epaper_spi/epaper_spi_uc8179.h

@@ -37,7 +37,6 @@ class EPaperUC8179 final : public EPaperBase {
   }
 
  protected:
-  bool buffer_is_mono() const override { return true; }
   bool initialise(bool partial) override;
   bool transfer_data() override;
   void refresh_screen(bool partial) override;

esphome/components/es8388/es8388.cpp

@@ -111,36 +111,24 @@ void ES8388::setup() {
   // Power on ADC, Enable LIN&RIN, Power off MICBIAS, set int1lp to low power mode
   ES8388_ERROR_FAILED(this->write_byte(ES8388_ADCPOWER, 0x09));
 
-#ifdef USE_ES8388_SELECT
+#ifdef USE_SELECT
   if (this->dac_output_select_ != nullptr) {
-    if (this->dac_output_initial_.has_value()) {
-      const DacOutputLine line = this->dac_output_initial_.value();
-      ES8388_ERROR_FAILED(this->set_dac_output(line));
-      this->dac_output_select_->publish_state(static_cast<size_t>(line));
-    } else {
-      auto dac_power = this->get_dac_power();
-      if (dac_power.has_value()) {
-        if (this->dac_output_select_->has_index(dac_power.value())) {
-          this->dac_output_select_->publish_state(dac_power.value());
-        } else {
-          ESP_LOGW(TAG, "Unknown DAC output power value: %d", dac_power.value());
-        }
+    auto dac_power = this->get_dac_power();
+    if (dac_power.has_value()) {
+      if (this->dac_output_select_->has_index(dac_power.value())) {
+        this->dac_output_select_->publish_state(dac_power.value());
+      } else {
+        ESP_LOGW(TAG, "Unknown DAC output power value: %d", dac_power.value());
       }
     }
   }
   if (this->adc_input_mic_select_ != nullptr) {
-    if (this->adc_input_mic_initial_.has_value()) {
-      const AdcInputMicLine line = this->adc_input_mic_initial_.value();
-      ES8388_ERROR_FAILED(this->set_adc_input_mic(line));
-      this->adc_input_mic_select_->publish_state(static_cast<size_t>(line));
-    } else {
-      auto mic_input = this->get_mic_input();
-      if (mic_input.has_value()) {
-        if (this->adc_input_mic_select_->has_index(mic_input.value())) {
-          this->adc_input_mic_select_->publish_state(mic_input.value());
-        } else {
-          ESP_LOGW(TAG, "Unknown ADC input mic value: %d", mic_input.value());
-        }
+    auto mic_input = this->get_mic_input();
+    if (mic_input.has_value()) {
+      if (this->adc_input_mic_select_->has_index(mic_input.value())) {
+        this->adc_input_mic_select_->publish_state(mic_input.value());
+      } else {
+        ESP_LOGW(TAG, "Unknown ADC input mic value: %d", mic_input.value());
       }
     }
   }
@@ -150,7 +138,7 @@ void ES8388::setup() {
 void ES8388::dump_config() {
   ESP_LOGCONFIG(TAG, "ES8388 Audio Codec:");
   LOG_I2C_DEVICE(this);
-#ifdef USE_ES8388_SELECT
+#ifdef USE_SELECT
   LOG_SELECT("  ", "DacOutputSelect", this->dac_output_select_);
   LOG_SELECT("  ", "ADCInputMicSelect", this->adc_input_mic_select_);
 #endif

esphome/components/es8388/es8388.h

@@ -5,7 +5,7 @@
 #include "esphome/components/audio_dac/audio_dac.h"
 #include "esphome/components/i2c/i2c.h"
 #include "esphome/core/component.h"
-#ifdef USE_ES8388_SELECT
+#ifdef USE_SELECT
 #include "esphome/components/select/select.h"
 #endif
 
@@ -26,7 +26,7 @@ enum AdcInputMicLine : uint8_t {
 };
 
 class ES8388 final : public audio_dac::AudioDac, public Component, public i2c::I2CDevice {
-#ifdef USE_ES8388_SELECT
+#ifdef USE_SELECT
   SUB_SELECT(dac_output)
   SUB_SELECT(adc_input_mic)
 #endif
@@ -68,22 +68,11 @@ class ES8388 final : public audio_dac::AudioDac, public Component, public i2c::I
   bool set_dac_output(DacOutputLine line);
   bool set_adc_input_mic(AdcInputMicLine line);
 
-#ifdef USE_ES8388_SELECT
-  /// Line to apply in setup() instead of keeping what the codec reports.
-  void set_dac_output_initial(DacOutputLine line) { this->dac_output_initial_ = line; }
-  void set_adc_input_mic_initial(AdcInputMicLine line) { this->adc_input_mic_initial_ = line; }
-#endif
-
  protected:
   /// @brief Mutes or unmutes the DAC audio out
   /// @param mute_state True to mute, false to unmute
   /// @return True if successful and false otherwise
   bool set_mute_state_(bool mute_state);
-
-#ifdef USE_ES8388_SELECT
-  optional<DacOutputLine> dac_output_initial_{};
-  optional<AdcInputMicLine> adc_input_mic_initial_{};
-#endif
 };
 
 }  // namespace esphome::es8388

esphome/components/es8388/select/__init__.py

@@ -1,11 +1,7 @@
 import esphome.codegen as cg
 from esphome.components import select
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_INITIAL_OPTION,
-    ENTITY_CATEGORY_CONFIG,
-    ICON_CHIP,  # noqa: F401
-)
+from esphome.const import ENTITY_CATEGORY_CONFIG, ICON_CHIP  # noqa: F401
 from esphome.types import ConfigType
 
 from ..audio_dac import CONF_ES8388_ID, ES8388, es8388_ns
@@ -13,21 +9,6 @@ from ..audio_dac import CONF_ES8388_ID, ES8388, es8388_ns
 CONF_DAC_OUTPUT = "dac_output"
 CONF_ADC_INPUT_MIC = "adc_input_mic"
 
-DacOutputLine = es8388_ns.enum("DacOutputLine")
-DAC_OUTPUT_OPTIONS = {
-    "LINE1": DacOutputLine.DAC_OUTPUT_LINE1,
-    "LINE2": DacOutputLine.DAC_OUTPUT_LINE2,
-    "BOTH": DacOutputLine.DAC_OUTPUT_BOTH,
-}
-DAC_OUTPUT_OPTION_NAMES = list(DAC_OUTPUT_OPTIONS)
-AdcInputMicLine = es8388_ns.enum("AdcInputMicLine")
-ADC_INPUT_MIC_OPTIONS = {
-    "LINE1": AdcInputMicLine.ADC_INPUT_MIC_LINE1,
-    "LINE2": AdcInputMicLine.ADC_INPUT_MIC_LINE2,
-    "DIFFERENCE": AdcInputMicLine.ADC_INPUT_MIC_DIFFERENCE,
-}
-ADC_INPUT_MIC_OPTION_NAMES = list(ADC_INPUT_MIC_OPTIONS)
-
 DacOutputSelect = es8388_ns.class_("DacOutputSelect", select.Select)
 ADCInputMicSelect = es8388_ns.class_("ADCInputMicSelect", select.Select)
 
@@ -38,45 +19,24 @@ CONFIG_SCHEMA = cv.All(
             DacOutputSelect,
             entity_category=ENTITY_CATEGORY_CONFIG,
             icon=ICON_CHIP,
-        ).extend(
-            {
-                cv.Optional(CONF_INITIAL_OPTION): cv.enum(
-                    DAC_OUTPUT_OPTIONS, upper=True
-                ),
-            }
         ),
         cv.Optional(CONF_ADC_INPUT_MIC): select.select_schema(
             ADCInputMicSelect,
             entity_category=ENTITY_CATEGORY_CONFIG,
             icon=ICON_CHIP,
-        ).extend(
-            {
-                cv.Optional(CONF_INITIAL_OPTION): cv.enum(
-                    ADC_INPUT_MIC_OPTIONS, upper=True
-                ),
-            }
         ),
     }
 )
 
 
 async def to_code(config: ConfigType) -> None:
-    cg.add_define("USE_ES8388_SELECT")
     hub = await cg.get_variable(config[CONF_ES8388_ID])
     selects = select.sub_selects(config, parent=hub)
     await selects(
-        CONF_DAC_OUTPUT, hub.set_dac_output_select, options=DAC_OUTPUT_OPTION_NAMES
+        CONF_DAC_OUTPUT, hub.set_dac_output_select, options=["LINE1", "LINE2", "BOTH"]
     )
     await selects(
         CONF_ADC_INPUT_MIC,
         hub.set_adc_input_mic_select,
-        options=ADC_INPUT_MIC_OPTION_NAMES,
+        options=["LINE1", "LINE2", "DIFFERENCE"],
     )
-    if (
-        initial := config.get(CONF_DAC_OUTPUT, {}).get(CONF_INITIAL_OPTION)
-    ) is not None:
-        cg.add(hub.set_dac_output_initial(initial))
-    if (
-        initial := config.get(CONF_ADC_INPUT_MIC, {}).get(CONF_INITIAL_OPTION)
-    ) is not None:
-        cg.add(hub.set_adc_input_mic_initial(initial))

esphome/components/esp32_camera/esp32_camera.cpp

@@ -282,7 +282,7 @@ void ESP32Camera::loop() {
   }
   this->frame_count_++;
   if (now - this->last_log_time_ >= FRAME_LOG_INTERVAL_MS) {
-    ESP_LOGD(TAG, "Received %u images in last %" PRIu32 "s", this->frame_count_, FRAME_LOG_INTERVAL_MS / 1000);
+    ESP_LOGD(TAG, "Received %u images in last %us", this->frame_count_, FRAME_LOG_INTERVAL_MS / 1000);
     this->last_log_time_ = now;
     this->frame_count_ = 0;
   }

esphome/components/ezo/ezo.h

@@ -3,12 +3,11 @@
 #include "esphome/core/component.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/i2c/i2c.h"
-#include "esphome/core/log.h"
 #include <deque>
 
 namespace esphome::ezo {
 
-ESPHOME_LOG_TAG(TAG, "ezo.sensor");
+static const char *const TAG = "ezo.sensor";
 
 enum EzoCommandType : uint8_t {
   EZO_READ = 0,

esphome/components/file/image.py

@@ -330,9 +330,7 @@ async def write_image(
         if byte_order is not None:
             # Check for valid type has already been done in validate_settings
             encoder.set_big_endian(byte_order == "BIG_ENDIAN")
-        pixels = encoder.convert(
-            image.resize((width, height)), path
-        ).get_flattened_data()
+        pixels = encoder.convert(image.resize((width, height)), path).getdata()
         for row in range(height):
             for col in range(width):
                 encoder.encode(pixels[row * width + col])

esphome/components/filter_lifetime/__init__.py

@@ -1,2 +0,0 @@
-CODEOWNERS = ["@tuct"]
-DOMAIN = "filter_lifetime"

esphome/components/filter_lifetime/filter_lifetime.cpp

@@ -1,112 +0,0 @@
-#include "filter_lifetime.h"
-#include "esphome/core/application.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-#include <algorithm>
-#include <cmath>
-
-namespace esphome::filter_lifetime {
-
-ESPHOME_LOG_TAG(TAG, "filter_lifetime");
-
-static constexpr uint32_t SECONDS_PER_HOUR = 3600;
-static constexpr float MINUTES_PER_DAY = 24.0f * 60.0f;
-
-void FilterLifetime::setup() {
-  this->pref_ = this->make_entity_preference<uint32_t>();
-  this->pref_.load(&this->runtime_seconds_);
-  this->last_update_ = millis();
-  this->publish_values_();
-}
-
-void FilterLifetime::update() {
-  const uint32_t now = App.get_loop_component_start_time();
-  const uint32_t elapsed_ms = now - this->last_update_;
-  this->last_update_ = now;
-
-  if (this->get_is_on_()) {
-    float speed = this->get_current_speed_();
-    if (std::isnan(speed))
-      speed = 0.0f;
-    speed = std::clamp(speed, 0.0f, 100.0f);
-    const uint32_t prev_hours = this->runtime_seconds_ / SECONDS_PER_HOUR;
-    this->carry_ms_ += static_cast<uint32_t>(elapsed_ms * (speed / 100.0f));
-    this->runtime_seconds_ += this->carry_ms_ / 1000;
-    this->carry_ms_ %= 1000;
-    // Save once per hour of runtime (and in on_shutdown): every save erases a flash sector on ESP8266.
-    if (this->runtime_seconds_ / SECONDS_PER_HOUR != prev_hours)
-      this->pref_.save(&this->runtime_seconds_);
-    ESP_LOGV(TAG, "Elapsed %" PRIu32 " ms at %.0f%%, runtime %" PRIu32 " s", elapsed_ms, speed, this->runtime_seconds_);
-  }
-  this->publish_values_();
-}
-
-void FilterLifetime::publish_values_() {
-  const float runtime_minutes = this->runtime_seconds_ / 60.0f;
-  const float max_minutes = this->max_lifetime_minutes_;
-  const float remaining_minutes = std::max(0.0f, max_minutes - runtime_minutes);
-  this->publish_state(100.0f * remaining_minutes / max_minutes);
-  if (this->runtime_hours_sensor_ != nullptr)
-    this->runtime_hours_sensor_->publish_state(runtime_minutes / 60.0f);
-  if (this->remaining_days_sensor_ != nullptr)
-    this->remaining_days_sensor_->publish_state(remaining_minutes / MINUTES_PER_DAY);
-}
-
-void FilterLifetime::on_shutdown() { this->pref_.save(&this->runtime_seconds_); }
-
-void FilterLifetime::reset_filter() {
-  this->runtime_seconds_ = 0;
-  this->carry_ms_ = 0;
-  this->pref_.save(&this->runtime_seconds_);
-  this->publish_values_();
-  ESP_LOGI(TAG, "Filter lifetime reset");
-}
-
-bool FilterLifetime::get_is_on_() {
-#ifdef USE_BINARY_SENSOR
-  // Reads false until the sensor first publishes, so nothing accumulates before then.
-  if (this->is_on_sensor_ != nullptr)
-    return this->is_on_sensor_->state;
-#endif
-  if (this->is_on_lambda_ != nullptr)
-    return this->is_on_lambda_();
-  return true;
-}
-
-float FilterLifetime::get_current_speed_() {
-  if (this->current_speed_sensor_ != nullptr)
-    return this->current_speed_sensor_->state;  // NaN before the first publish, treated as 0
-  if (this->current_speed_lambda_ != nullptr)
-    return this->current_speed_lambda_();
-  return 100.0f;
-}
-
-void FilterLifetime::dump_config() {
-  LOG_SENSOR("", "Filter Lifetime", this);
-  ESP_LOGCONFIG(TAG,
-                "  Max lifetime: %" PRIu32 " min (%.1f days)\n"
-                "  Runtime: %.1f h",
-                this->max_lifetime_minutes_, this->max_lifetime_minutes_ / MINUTES_PER_DAY,
-                this->runtime_seconds_ / 3600.0f);
-#ifdef USE_BINARY_SENSOR
-  if (this->is_on_sensor_ != nullptr) {
-    LOG_BINARY_SENSOR("  ", "Is-on sensor", this->is_on_sensor_);
-  } else
-#endif
-  {
-    ESP_LOGCONFIG(TAG, "  Is-on: %s",
-                  this->is_on_lambda_ != nullptr ? LOG_STR_LITERAL("lambda") : LOG_STR_LITERAL("always"));
-  }
-  if (this->current_speed_sensor_ != nullptr) {
-    LOG_SENSOR("  ", "Speed sensor", this->current_speed_sensor_);
-  } else {
-    ESP_LOGCONFIG(TAG, "  Speed: %s",
-                  this->current_speed_lambda_ != nullptr ? LOG_STR_LITERAL("lambda") : LOG_STR_LITERAL("100%"));
-  }
-  LOG_SENSOR("  ", "Runtime hours", this->runtime_hours_sensor_);
-  LOG_SENSOR("  ", "Remaining days", this->remaining_days_sensor_);
-  LOG_UPDATE_INTERVAL(this);
-}
-
-}  // namespace esphome::filter_lifetime

esphome/components/filter_lifetime/filter_lifetime.h

@@ -1,50 +0,0 @@
-#pragma once
-
-#include "esphome/components/sensor/sensor.h"
-#include "esphome/core/component.h"
-#include "esphome/core/defines.h"
-#ifdef USE_BINARY_SENSOR
-#include "esphome/components/binary_sensor/binary_sensor.h"
-#endif
-
-namespace esphome::filter_lifetime {
-
-class FilterLifetime : public sensor::Sensor, public PollingComponent {
- public:
-  void setup() override;
-  void update() override;
-  void dump_config() override;
-  void on_shutdown() override;
-  void reset_filter();
-
-  void set_max_lifetime(uint32_t minutes) { this->max_lifetime_minutes_ = minutes; }
-  void set_is_on_lambda(bool (*is_on)()) { this->is_on_lambda_ = is_on; }
-#ifdef USE_BINARY_SENSOR
-  void set_is_on_sensor(binary_sensor::BinarySensor *sensor) { this->is_on_sensor_ = sensor; }
-#endif
-  void set_current_speed_lambda(float (*speed)()) { this->current_speed_lambda_ = speed; }
-  void set_current_speed_sensor(sensor::Sensor *sensor) { this->current_speed_sensor_ = sensor; }
-  void set_runtime_hours_sensor(sensor::Sensor *sensor) { this->runtime_hours_sensor_ = sensor; }
-  void set_remaining_days_sensor(sensor::Sensor *sensor) { this->remaining_days_sensor_ = sensor; }
-
- protected:
-  bool get_is_on_();
-  float get_current_speed_();
-  void publish_values_();
-
-  bool (*is_on_lambda_)(){nullptr};
-  float (*current_speed_lambda_)(){nullptr};
-#ifdef USE_BINARY_SENSOR
-  binary_sensor::BinarySensor *is_on_sensor_{nullptr};
-#endif
-  sensor::Sensor *current_speed_sensor_{nullptr};
-  sensor::Sensor *runtime_hours_sensor_{nullptr};
-  sensor::Sensor *remaining_days_sensor_{nullptr};
-  ESPPreferenceObject pref_;
-  uint32_t max_lifetime_minutes_{0};
-  uint32_t last_update_{0};
-  uint32_t runtime_seconds_{0};  // Speed-weighted running time, persisted
-  uint32_t carry_ms_{0};         // Weighted milliseconds not yet counted as a second
-};
-
-}  // namespace esphome::filter_lifetime

esphome/components/filter_lifetime/sensor.py

@@ -1,94 +0,0 @@
-from esphome import automation
-import esphome.codegen as cg
-from esphome.components import binary_sensor, sensor
-import esphome.config_validation as cv
-from esphome.const import (
-    DEVICE_CLASS_DURATION,
-    STATE_CLASS_MEASUREMENT,
-    STATE_CLASS_TOTAL_INCREASING,
-    UNIT_HOUR,
-    UNIT_PERCENT,
-)
-from esphome.types import ConfigType
-
-CONF_MAX_LIFETIME = "max_lifetime"
-CONF_IS_ON = "is_on"
-CONF_IS_ON_SENSOR = "is_on_sensor"
-CONF_CURRENT_SPEED = "current_speed"
-CONF_CURRENT_SPEED_SENSOR = "current_speed_sensor"
-CONF_RUNTIME_HOURS = "runtime_hours"
-CONF_REMAINING_DAYS = "remaining_days"
-UNIT_DAY = "d"
-
-filter_lifetime_ns = cg.esphome_ns.namespace("filter_lifetime")
-FilterLifetime = filter_lifetime_ns.class_(
-    "FilterLifetime", sensor.Sensor, cg.PollingComponent
-)
-
-CONFIG_SCHEMA = cv.All(
-    sensor.sensor_schema(
-        FilterLifetime,
-        unit_of_measurement=UNIT_PERCENT,
-        accuracy_decimals=2,
-        icon="mdi:air-filter",
-        state_class=STATE_CLASS_MEASUREMENT,
-    )
-    .extend(
-        {
-            cv.Required(CONF_MAX_LIFETIME): cv.All(
-                cv.positive_time_period_minutes,
-                cv.Range(min=cv.TimePeriod(minutes=1)),
-            ),
-            cv.Optional(CONF_IS_ON): cv.returning_lambda,
-            cv.Optional(CONF_IS_ON_SENSOR): cv.use_id(binary_sensor.BinarySensor),
-            cv.Optional(CONF_CURRENT_SPEED): cv.returning_lambda,
-            cv.Optional(CONF_CURRENT_SPEED_SENSOR): cv.use_id(sensor.Sensor),
-            cv.Optional(CONF_RUNTIME_HOURS): sensor.sensor_schema(
-                unit_of_measurement=UNIT_HOUR,
-                accuracy_decimals=1,
-                device_class=DEVICE_CLASS_DURATION,
-                state_class=STATE_CLASS_TOTAL_INCREASING,
-                icon="mdi:timer-outline",
-            ),
-            cv.Optional(CONF_REMAINING_DAYS): sensor.sensor_schema(
-                unit_of_measurement=UNIT_DAY,
-                accuracy_decimals=0,
-                device_class=DEVICE_CLASS_DURATION,
-                icon="mdi:calendar-clock",
-            ),
-        }
-    )
-    .extend(cv.polling_component_schema("60s")),
-    cv.has_at_most_one_key(CONF_IS_ON, CONF_IS_ON_SENSOR),
-    cv.has_at_most_one_key(CONF_CURRENT_SPEED, CONF_CURRENT_SPEED_SENSOR),
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    var = await sensor.new_sensor(config)
-    await cg.register_component(var, config)
-
-    cg.add(var.set_max_lifetime(config[CONF_MAX_LIFETIME]))
-
-    if (is_on := config.get(CONF_IS_ON)) is not None:
-        cg.add(var.set_is_on_lambda(await cg.templatable(is_on, [], bool)))
-    elif (is_on_sensor := config.get(CONF_IS_ON_SENSOR)) is not None:
-        cg.add(var.set_is_on_sensor(await cg.get_variable(is_on_sensor)))
-
-    if (current_speed := config.get(CONF_CURRENT_SPEED)) is not None:
-        cg.add(
-            var.set_current_speed_lambda(await cg.templatable(current_speed, [], float))
-        )
-    elif (speed_sensor := config.get(CONF_CURRENT_SPEED_SENSOR)) is not None:
-        cg.add(var.set_current_speed_sensor(await cg.get_variable(speed_sensor)))
-
-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_RUNTIME_HOURS, var.set_runtime_hours_sensor)
-    await sensors(CONF_REMAINING_DAYS, var.set_remaining_days_sensor)
-
-
-automation.register_apply_action(
-    "filter_lifetime.reset_filter",
-    cv.Schema({cv.GenerateID(): cv.use_id(FilterLifetime)}),
-    automation.ApplyCall("reset_filter()"),
-)

esphome/components/haier_tundra/__init__.py

@@ -1,2 +0,0 @@
-DOMAIN = "haier_tundra"
-CODEOWNERS = ["@fauxpark"]

esphome/components/haier_tundra/button/__init__.py

@@ -1,43 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import button
-import esphome.config_validation as cv
-from esphome.const import CONF_LIGHT
-from esphome.types import ConfigType
-
-from ..climate import HaierTundra, haier_tundra_ns
-
-CODEOWNERS = ["@fauxpark"]
-
-HaierTundraButton = haier_tundra_ns.class_(
-    "HaierTundraButton", button.Button, cg.Component
-)
-ButtonKind = haier_tundra_ns.enum("ButtonKind", is_class=True)
-
-ICON_LED_OUTLINE = "mdi:led-outline"
-ICON_SPRAY_BOTTLE = "mdi:spray-bottle"
-
-CONF_HAIER_TUNDRA_ID = "haier_tundra_id"
-CONF_SELF_CLEAN = "self_clean"
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_HAIER_TUNDRA_ID): cv.use_id(HaierTundra),
-        cv.Optional(CONF_LIGHT): button.button_schema(
-            HaierTundraButton, icon=ICON_LED_OUTLINE
-        ),
-        cv.Optional(CONF_SELF_CLEAN): button.button_schema(
-            HaierTundraButton, icon=ICON_SPRAY_BOTTLE
-        ),
-    }
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_HAIER_TUNDRA_ID])
-    for key, kind in (
-        (CONF_LIGHT, ButtonKind.BUTTON_KIND_LIGHT),
-        (CONF_SELF_CLEAN, ButtonKind.BUTTON_KIND_SELF_CLEAN),
-    ):
-        if (conf := config.get(key)) is not None:
-            var = await button.new_button(conf, hub, kind)
-            await cg.register_component(var, conf)

esphome/components/haier_tundra/button/haier_tundra_button.cpp

@@ -1,18 +0,0 @@
-#include "haier_tundra_button.h"
-#include "esphome/core/log.h"
-
-namespace esphome::haier_tundra {
-
-ESPHOME_LOG_TAG(TAG, "haier_tundra.button");
-
-void HaierTundraButton::dump_config() { LOG_BUTTON("", "Haier Tundra Button", this); }
-
-void HaierTundraButton::press_action() {
-  if (this->kind_ == ButtonKind::BUTTON_KIND_LIGHT) {
-    this->parent_->toggle_light();
-  } else {
-    this->parent_->start_self_clean();
-  }
-}
-
-}  // namespace esphome::haier_tundra

esphome/components/haier_tundra/button/haier_tundra_button.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/button/button.h"
-#include "esphome/components/haier_tundra/haier_tundra.h"
-
-namespace esphome::haier_tundra {
-
-enum class ButtonKind : uint8_t {
-  BUTTON_KIND_LIGHT,
-  BUTTON_KIND_SELF_CLEAN,
-};
-
-class HaierTundraButton final : public button::Button, public Component, public Parented<HaierTundra> {
- public:
-  HaierTundraButton(HaierTundra *parent, ButtonKind kind) : Parented(parent), kind_(kind) {}
-  void dump_config() override;
-
- protected:
-  void press_action() override;
-
-  ButtonKind kind_;
-};
-
-}  // namespace esphome::haier_tundra

esphome/components/haier_tundra/climate.py

@@ -1,51 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import climate_ir, remote_base
-import esphome.config_validation as cv
-from esphome.const import CONF_ID, CONF_PLATFORM
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-AUTO_LOAD = ["climate_ir"]
-
-haier_tundra_ns = cg.esphome_ns.namespace("haier_tundra")
-HaierTundra = haier_tundra_ns.class_("HaierTundra", climate_ir.ClimateIR)
-
-CONF_UNIT = "unit"
-Unit = haier_tundra_ns.enum("Unit")
-UNITS = {
-    "a": Unit.HAIER_HEADER_UNIT_A,
-    "b": Unit.HAIER_HEADER_UNIT_B,
-}
-
-CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(HaierTundra).extend(
-    {
-        cv.Optional(CONF_UNIT, default="a"): cv.enum(UNITS, lower=True),
-    }
-)
-
-
-def _final_validate_unit(config: ConfigType) -> None:
-    # Each transmitter may drive at most one unit A and one unit B
-    climates = fv.full_config.get()["climate"]
-    seen = set()
-
-    for climate in climates:
-        if CONF_PLATFORM in climate and climate[CONF_PLATFORM] == "haier_tundra":
-            unit_tx_pair = (
-                climate[CONF_UNIT],
-                climate[remote_base.CONF_TRANSMITTER_ID],
-            )
-
-            if unit_tx_pair in seen and climate[CONF_ID] == config[CONF_ID]:
-                raise cv.Invalid(
-                    "Only one of each unit is allowed per transmitter", path=[CONF_UNIT]
-                )
-            seen.add(unit_tx_pair)
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate_unit
-
-
-async def to_code(config: ConfigType) -> None:
-    remote_base.request_protocol("haier")
-    await climate_ir.new_climate_ir(config, config[CONF_UNIT])

esphome/components/haier_tundra/haier_tundra.cpp

@@ -1,260 +0,0 @@
-#include "haier_tundra.h"
-
-namespace esphome::haier_tundra {
-
-// Number of bytes in decoded packet sans checksum
-static constexpr uint8_t HAIER_TUNDRA_FRAME_SIZE = 13;
-
-void HaierTundra::transmit_state() {
-  // Button value does not seem to matter too much except
-  // when toggling light, as it has no bit flag of its own
-  // So in the default case we can simply set it to POWER
-  this->transmit_(HAIER_BUTTON_POWER);
-}
-
-void HaierTundra::transmit_(uint8_t button) {
-  // Force Quiet and Turbo off if we're not in Cool or Heat mode
-  if (this->mode != climate::CLIMATE_MODE_COOL && this->mode != climate::CLIMATE_MODE_HEAT) {
-#ifdef USE_SWITCH
-    if (this->quiet_mode_switch_ != nullptr) {
-      this->quiet_mode_switch_->publish_state(false);
-    }
-    if (this->turbo_mode_switch_ != nullptr) {
-      this->turbo_mode_switch_->publish_state(false);
-    }
-#endif
-
-    this->quiet_mode_ = false;
-    this->turbo_mode_ = false;
-  }
-
-  const uint8_t frame[HAIER_TUNDRA_FRAME_SIZE] = {
-      this->unit_,
-      static_cast<uint8_t>(this->temperature_() << 4 | this->vertical_swing_()),
-      static_cast<uint8_t>(this->horizontal_swing_() << 5),
-      static_cast<uint8_t>(this->health_() << 1),
-      static_cast<uint8_t>(this->power_() << 6),
-      static_cast<uint8_t>(this->fan_speed_() << 5),
-      static_cast<uint8_t>(this->quiet_() << 7 | this->turbo_() << 6),
-      static_cast<uint8_t>(this->operation_mode_() << 5),
-      0x00,
-      0x00,
-      static_cast<uint8_t>((button == HAIER_BUTTON_SELF_CLEAN ? 1 : 0) << 4),
-      0x00,
-      button,
-  };
-
-  auto transmit = this->transmitter_->transmit();
-  remote_base::HaierProtocol().encode(transmit.get_data(), frame, sizeof(frame));
-  transmit.perform();
-}
-
-uint8_t HaierTundra::temperature_() {
-  return (uint8_t) roundf(clamp<float>(this->target_temperature, HAIER_TEMP_MIN, HAIER_TEMP_MAX)) - HAIER_TEMP_MIN;
-}
-
-uint8_t HaierTundra::vertical_swing_() {
-  if (this->mode == climate::CLIMATE_MODE_OFF) {
-    return HAIER_SWING_V_OFF;
-  }
-  switch (this->swing_mode) {
-    case climate::CLIMATE_SWING_VERTICAL:
-    case climate::CLIMATE_SWING_BOTH:
-      return HAIER_SWING_V_AUTO;
-    default:
-      if (this->mode == climate::CLIMATE_MODE_HEAT) {
-        return HAIER_SWING_V_1BOT;
-      }
-      return HAIER_SWING_V_1TOP;  // Cool/Dry/Auto
-  }
-}
-
-uint8_t HaierTundra::horizontal_swing_() {
-  switch (this->swing_mode) {
-    case climate::CLIMATE_SWING_HORIZONTAL:
-    case climate::CLIMATE_SWING_BOTH:
-      return HAIER_SWING_H_AUTO;
-    default:
-      return HAIER_SWING_H_MIDDLE;
-  }
-}
-
-uint8_t HaierTundra::health_() { return this->health_mode_ ? 1 : 0; }
-
-uint8_t HaierTundra::power_() { return this->mode == climate::CLIMATE_MODE_OFF ? 0 : 1; }
-
-uint8_t HaierTundra::fan_speed_() {
-  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
-    case climate::CLIMATE_FAN_LOW:
-      return HAIER_FAN_LOW;
-    case climate::CLIMATE_FAN_MEDIUM:
-      return HAIER_FAN_MED;
-    case climate::CLIMATE_FAN_HIGH:
-      return HAIER_FAN_HIGH;
-    case climate::CLIMATE_FAN_AUTO:
-    default:
-      return HAIER_FAN_AUTO;
-  }
-}
-
-uint8_t HaierTundra::quiet_() { return this->quiet_mode_ ? 1 : 0; }
-
-uint8_t HaierTundra::turbo_() { return this->turbo_mode_ ? 1 : 0; }
-
-uint8_t HaierTundra::operation_mode_() {
-  switch (this->mode) {
-    case climate::CLIMATE_MODE_COOL:
-      return HAIER_MODE_COOL;
-    case climate::CLIMATE_MODE_DRY:
-      return HAIER_MODE_DRY;
-    case climate::CLIMATE_MODE_HEAT:
-      return HAIER_MODE_HEAT;
-    case climate::CLIMATE_MODE_FAN_ONLY:
-      return HAIER_MODE_FAN;
-    case climate::CLIMATE_MODE_HEAT_COOL:
-    default:
-      return HAIER_MODE_AUTO;
-  }
-}
-
-bool HaierTundra::on_receive(remote_base::RemoteReceiveData data) {
-  auto haier = remote_base::HaierProtocol().decode(data);
-  if (haier.has_value()) {
-    return this->on_haier_(*haier);
-  }
-  return false;
-}
-
-bool HaierTundra::on_haier_(const remote_base::HaierData &haier) {
-  // Verify frame length and header
-  if (haier.data.size() != HAIER_TUNDRA_FRAME_SIZE || haier.data[0] != this->unit_) {
-    return false;
-  }
-
-  this->target_temperature = this->get_temperature_(haier.data[1] >> 4);
-  this->swing_mode = this->get_swing_mode_(haier.data[1] & 0xF, haier.data[2] >> 5);
-  this->health_mode_ = haier.data[3] & 0x2;
-  this->mode = this->get_operation_mode_(haier.data[4] & 0x40, haier.data[7] >> 5);
-  this->fan_mode = this->get_fan_speed_(haier.data[5] >> 5);
-  this->quiet_mode_ = haier.data[6] & 0x80;
-  this->turbo_mode_ = haier.data[6] & 0x40;
-
-#ifdef USE_SWITCH
-  if (this->health_mode_switch_ != nullptr) {
-    this->health_mode_switch_->publish_state(this->health_mode_);
-  }
-  if (this->quiet_mode_switch_ != nullptr) {
-    this->quiet_mode_switch_->publish_state(this->quiet_mode_);
-  }
-  if (this->turbo_mode_switch_ != nullptr) {
-    this->turbo_mode_switch_->publish_state(this->turbo_mode_);
-  }
-#endif
-
-  this->publish_state();
-
-  return true;
-}
-
-float HaierTundra::get_temperature_(uint8_t temp) { return temp + HAIER_TEMP_MIN; }
-
-climate::ClimateSwingMode HaierTundra::get_swing_mode_(uint8_t swing_v, uint8_t swing_h) {
-  if (swing_v == HAIER_SWING_V_AUTO) {
-    if (swing_h == HAIER_SWING_H_AUTO) {
-      return climate::CLIMATE_SWING_BOTH;
-    }
-
-    return climate::CLIMATE_SWING_VERTICAL;
-  } else if (swing_h == HAIER_SWING_H_AUTO) {
-    return climate::CLIMATE_SWING_HORIZONTAL;
-  }
-
-  return climate::CLIMATE_SWING_OFF;
-}
-
-climate::ClimateMode HaierTundra::get_operation_mode_(uint8_t power, uint8_t mode) {
-  if (!power) {
-    return climate::CLIMATE_MODE_OFF;
-  }
-
-  switch (mode) {
-    case HAIER_MODE_COOL:
-      return climate::CLIMATE_MODE_COOL;
-    case HAIER_MODE_DRY:
-      return climate::CLIMATE_MODE_DRY;
-    case HAIER_MODE_HEAT:
-      return climate::CLIMATE_MODE_HEAT;
-    case HAIER_MODE_FAN:
-      return climate::CLIMATE_MODE_FAN_ONLY;
-    case HAIER_MODE_AUTO:
-    default:
-      return climate::CLIMATE_MODE_HEAT_COOL;
-  }
-}
-
-climate::ClimateFanMode HaierTundra::get_fan_speed_(uint8_t fan) {
-  switch (fan) {
-    case HAIER_FAN_LOW:
-      return climate::CLIMATE_FAN_LOW;
-    case HAIER_FAN_MED:
-      return climate::CLIMATE_FAN_MEDIUM;
-    case HAIER_FAN_HIGH:
-      return climate::CLIMATE_FAN_HIGH;
-    case HAIER_FAN_AUTO:
-    default:
-      return climate::CLIMATE_FAN_AUTO;
-  }
-}
-
-void HaierTundra::set_health_mode(bool health, bool transmit) {
-  this->health_mode_ = health;
-
-  if (transmit && this->mode != climate::CLIMATE_MODE_OFF) {
-    this->transmit_(HAIER_BUTTON_HEALTH);
-  }
-}
-
-void HaierTundra::set_quiet_mode(bool quiet, bool transmit) {
-  // Quiet & Turbo cannot be enabled at the same time
-  if (quiet) {
-#ifdef USE_SWITCH
-    if (this->turbo_mode_switch_ != nullptr) {
-      this->turbo_mode_switch_->publish_state(false);
-    }
-#endif
-    this->turbo_mode_ = false;
-  }
-
-  this->quiet_mode_ = quiet;
-  if (transmit)
-    this->transmit_(HAIER_BUTTON_TURBO_QUIET);
-}
-
-void HaierTundra::set_turbo_mode(bool turbo, bool transmit) {
-  // Quiet & Turbo cannot be enabled at the same time
-  if (turbo) {
-#ifdef USE_SWITCH
-    if (this->quiet_mode_switch_ != nullptr) {
-      this->quiet_mode_switch_->publish_state(false);
-    }
-#endif
-    this->quiet_mode_ = false;
-  }
-
-  this->turbo_mode_ = turbo;
-  if (transmit)
-    this->transmit_(HAIER_BUTTON_TURBO_QUIET);
-}
-
-void HaierTundra::toggle_light() {
-  if (this->mode != climate::CLIMATE_MODE_OFF) {
-    this->transmit_(HAIER_BUTTON_LIGHT);
-  }
-}
-
-void HaierTundra::start_self_clean() {
-  // Can be started when off
-  this->transmit_(HAIER_BUTTON_SELF_CLEAN);
-}
-
-}  // namespace esphome::haier_tundra

esphome/components/haier_tundra/haier_tundra.h

@@ -1,139 +0,0 @@
-#pragma once
-
-#include "esphome/components/climate_ir/climate_ir.h"
-#include "esphome/components/remote_base/haier_protocol.h"
-
-#ifdef USE_SWITCH
-#include "esphome/components/switch/switch.h"
-#endif
-
-namespace esphome::haier_tundra {
-
-// Byte 0 - Header value (Unit ID)
-enum Unit : uint8_t {
-  HAIER_HEADER_UNIT_B = 0x59,
-  HAIER_HEADER_UNIT_A = 0xA6,
-};
-
-// Byte 1[7:4] - Temperature (˚C) 0x0..0xE
-static constexpr uint8_t HAIER_TEMP_MIN = 16;
-static constexpr uint8_t HAIER_TEMP_MAX = 30;
-
-// Byte 1[3:0] - Vertical Swing
-static constexpr uint8_t HAIER_SWING_V_OFF = 0x0;   // Power off value; from Auto, stops at current position
-static constexpr uint8_t HAIER_SWING_V_2TOP = 0x1;  // [|/   ]
-static constexpr uint8_t HAIER_SWING_V_1TOP = 0x2;  // [|    ] (Not available in Heat mode)
-static constexpr uint8_t HAIER_SWING_V_2BOT = 0x3;  // [   //]
-static constexpr uint8_t HAIER_SWING_V_1BOT = 0xA;  // [    /] (Heat mode only)
-static constexpr uint8_t HAIER_SWING_V_AUTO = 0xC;
-
-// Byte 2[7:5] - Horizontal Swing
-static constexpr uint8_t HAIER_SWING_H_MIDDLE = 0x0;        // [ || ]
-static constexpr uint8_t HAIER_SWING_H_LEFT = 0x3;          // [/   ]
-static constexpr uint8_t HAIER_SWING_H_MIDDLE_LEFT = 0x4;   // [ |  ]
-static constexpr uint8_t HAIER_SWING_H_MIDDLE_RIGHT = 0x5;  // [  | ]
-static constexpr uint8_t HAIER_SWING_H_RIGHT = 0x6;         // [   \]
-static constexpr uint8_t HAIER_SWING_H_AUTO = 0x7;          // [/||\]
-
-// Byte 3[7:5] - Timer Mode
-static constexpr uint8_t HAIER_TIMER_MODE_DISABLED = 0x0;
-static constexpr uint8_t HAIER_TIMER_MODE_OFF = 0x1;     // OFF
-static constexpr uint8_t HAIER_TIMER_MODE_ON = 0x2;      // ON
-static constexpr uint8_t HAIER_TIMER_MODE_ON_OFF = 0x4;  // ON → OFF
-static constexpr uint8_t HAIER_TIMER_MODE_OFF_ON = 0x5;  // ON ← OFF
-
-// Byte 3[1] - Health
-// Byte 4[6] - Power
-
-// Byte 5[7:5] - Fan Speed
-static constexpr uint8_t HAIER_FAN_HIGH = 0x1;
-static constexpr uint8_t HAIER_FAN_MED = 0x2;
-static constexpr uint8_t HAIER_FAN_LOW = 0x3;
-static constexpr uint8_t HAIER_FAN_AUTO = 0x5;
-
-// Byte 5[4:0] - Timer Off Hours (0-23) 0x00..0x17
-// Byte 6[7] - Quiet Mode
-// Byte 6[6] - Turbo Mode
-// Byte 6[5:0] - Timer Off Minutes (0-59) 0x00..0x3B
-
-// Byte 7[7:5] - Mode
-static constexpr uint8_t HAIER_MODE_AUTO = 0x0;
-static constexpr uint8_t HAIER_MODE_COOL = 0x1;
-static constexpr uint8_t HAIER_MODE_DRY = 0x2;
-static constexpr uint8_t HAIER_MODE_HEAT = 0x4;
-static constexpr uint8_t HAIER_MODE_FAN = 0x6;
-
-// Byte 7[4:0] - Timer On Hours (0-23) 0x00..0x17
-// Byte 8[7] - Sleep Mode
-// Byte 8[5:0] - Timer On Minutes (0-59) 0x00..0x3B
-// Byte 10[4] - Self Clean
-
-// Byte 12 - Button
-static constexpr uint8_t HAIER_BUTTON_TEMP_UP = 0x00;
-static constexpr uint8_t HAIER_BUTTON_TEMP_DOWN = 0x01;
-static constexpr uint8_t HAIER_BUTTON_SWING_V = 0x02;
-static constexpr uint8_t HAIER_BUTTON_SWING_H = 0x03;
-static constexpr uint8_t HAIER_BUTTON_FAN_SPEED = 0x04;
-static constexpr uint8_t HAIER_BUTTON_POWER = 0x05;
-static constexpr uint8_t HAIER_BUTTON_MODE = 0x06;
-static constexpr uint8_t HAIER_BUTTON_HEALTH = 0x07;
-static constexpr uint8_t HAIER_BUTTON_TURBO_QUIET = 0x08;
-static constexpr uint8_t HAIER_BUTTON_SLEEP = 0x0B;
-static constexpr uint8_t HAIER_BUTTON_TIMER = 0x10;
-static constexpr uint8_t HAIER_BUTTON_LIGHT = 0x15;
-static constexpr uint8_t HAIER_BUTTON_SELF_CLEAN = 0x19;
-
-class HaierTundra final : public climate_ir::ClimateIR {
- public:
-  explicit HaierTundra(Unit unit)
-      : climate_ir::ClimateIR(HAIER_TEMP_MIN, HAIER_TEMP_MAX, 1.0f, true, true,
-                              {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_MEDIUM,
-                               climate::CLIMATE_FAN_HIGH},
-                              {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL,
-                               climate::CLIMATE_SWING_HORIZONTAL, climate::CLIMATE_SWING_BOTH}),
-        unit_(unit) {}
-
-#ifdef USE_SWITCH
-  SUB_SWITCH(health_mode);
-  SUB_SWITCH(quiet_mode);
-  SUB_SWITCH(turbo_mode);
-#endif
-
-  void set_health_mode(bool health, bool transmit = true);
-  void set_quiet_mode(bool quiet, bool transmit = true);
-  void set_turbo_mode(bool turbo, bool transmit = true);
-
-  void toggle_light();
-  void start_self_clean();
-
- protected:
-  // Transmit via IR the state of this climate controller.
-  void transmit_state() override;
-
-  void transmit_(uint8_t button);
-  uint8_t temperature_();
-  uint8_t vertical_swing_();
-  uint8_t horizontal_swing_();
-  uint8_t health_();
-  uint8_t power_();
-  uint8_t fan_speed_();
-  uint8_t quiet_();
-  uint8_t turbo_();
-  uint8_t operation_mode_();
-
-  // Handle received IR Buffer
-  bool on_receive(remote_base::RemoteReceiveData data) override;
-  bool on_haier_(const remote_base::HaierData &haier);
-
-  float get_temperature_(uint8_t temp);
-  climate::ClimateSwingMode get_swing_mode_(uint8_t swing_v, uint8_t swing_h);
-  climate::ClimateMode get_operation_mode_(uint8_t power, uint8_t mode);
-  climate::ClimateFanMode get_fan_speed_(uint8_t fan);
-
-  Unit unit_;
-  bool health_mode_{false};
-  bool quiet_mode_{false};
-  bool turbo_mode_{false};
-};
-
-}  // namespace esphome::haier_tundra

esphome/components/haier_tundra/switch/__init__.py

@@ -1,60 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import switch
-import esphome.config_validation as cv
-from esphome.const import DEVICE_CLASS_SWITCH, ENTITY_CATEGORY_CONFIG
-from esphome.types import ConfigType
-
-from ..climate import HaierTundra, haier_tundra_ns
-
-CODEOWNERS = ["@fauxpark"]
-
-HaierTundraSwitch = haier_tundra_ns.class_(
-    "HaierTundraSwitch", switch.Switch, cg.Component
-)
-SwitchKind = haier_tundra_ns.enum("SwitchKind", is_class=True)
-
-ICON_LEAF = "mdi:leaf"
-ICON_ARROW_DOWN_RIGHT = "mdi:arrow-down-right"
-ICON_ARROW_UP_RIGHT_BOLD = "mdi:arrow-up-right-bold"
-
-CONF_HAIER_TUNDRA_ID = "haier_tundra_id"
-CONF_HEALTH_MODE = "health_mode"
-CONF_QUIET_MODE = "quiet_mode"
-CONF_TURBO_MODE = "turbo_mode"
-
-
-def _switch_schema(icon: str) -> cv.Schema:
-    return switch.switch_schema(
-        HaierTundraSwitch,
-        icon=icon,
-        default_restore_mode="RESTORE_DEFAULT_OFF",
-        device_class=DEVICE_CLASS_SWITCH,
-        entity_category=ENTITY_CATEGORY_CONFIG,
-    )
-
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.Required(CONF_HAIER_TUNDRA_ID): cv.use_id(HaierTundra),
-        cv.Optional(CONF_HEALTH_MODE): _switch_schema(ICON_LEAF),
-        cv.Optional(CONF_QUIET_MODE): _switch_schema(ICON_ARROW_DOWN_RIGHT),
-        cv.Optional(CONF_TURBO_MODE): _switch_schema(ICON_ARROW_UP_RIGHT_BOLD),
-    }
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_HAIER_TUNDRA_ID])
-    switches = switch.sub_switches(config)
-    if sw := await switches(
-        CONF_HEALTH_MODE, hub.set_health_mode_switch, hub, SwitchKind.SWITCH_KIND_HEALTH
-    ):
-        await cg.register_component(sw, config[CONF_HEALTH_MODE])
-    if sw := await switches(
-        CONF_QUIET_MODE, hub.set_quiet_mode_switch, hub, SwitchKind.SWITCH_KIND_QUIET
-    ):
-        await cg.register_component(sw, config[CONF_QUIET_MODE])
-    if sw := await switches(
-        CONF_TURBO_MODE, hub.set_turbo_mode_switch, hub, SwitchKind.SWITCH_KIND_TURBO
-    ):
-        await cg.register_component(sw, config[CONF_TURBO_MODE])

esphome/components/haier_tundra/switch/haier_tundra_switch.cpp

@@ -1,43 +0,0 @@
-#include "haier_tundra_switch.h"
-#include "esphome/core/log.h"
-
-namespace esphome::haier_tundra {
-
-ESPHOME_LOG_TAG(TAG, "haier_tundra.switch");
-
-void HaierTundraSwitch::setup() {
-  auto initial = this->get_initial_state_with_restore_mode();
-  if (initial.has_value()) {
-    const bool state = initial.value();
-    this->apply_(state, false);
-    this->publish_state(state);
-  }
-}
-
-void HaierTundraSwitch::dump_config() { LOG_SWITCH("", "Haier Tundra Switch", this); }
-
-void HaierTundraSwitch::write_state(bool state) {
-  // Quiet and Turbo can only be turned on in Cool or Heat mode
-  if (state && this->kind_ != SwitchKind::SWITCH_KIND_HEALTH && this->parent_->mode != climate::CLIMATE_MODE_COOL &&
-      this->parent_->mode != climate::CLIMATE_MODE_HEAT) {
-    return;
-  }
-  this->apply_(state, true);
-  this->publish_state(state);
-}
-
-void HaierTundraSwitch::apply_(bool state, bool transmit) {
-  switch (this->kind_) {
-    case SwitchKind::SWITCH_KIND_HEALTH:
-      this->parent_->set_health_mode(state, transmit);
-      break;
-    case SwitchKind::SWITCH_KIND_QUIET:
-      this->parent_->set_quiet_mode(state, transmit);
-      break;
-    case SwitchKind::SWITCH_KIND_TURBO:
-      this->parent_->set_turbo_mode(state, transmit);
-      break;
-  }
-}
-
-}  // namespace esphome::haier_tundra

esphome/components/haier_tundra/switch/haier_tundra_switch.h

@@ -1,28 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/components/switch/switch.h"
-#include "esphome/components/haier_tundra/haier_tundra.h"
-
-namespace esphome::haier_tundra {
-
-enum class SwitchKind : uint8_t {
-  SWITCH_KIND_HEALTH,
-  SWITCH_KIND_QUIET,
-  SWITCH_KIND_TURBO,
-};
-
-class HaierTundraSwitch final : public switch_::Switch, public Component, public Parented<HaierTundra> {
- public:
-  HaierTundraSwitch(HaierTundra *parent, SwitchKind kind) : Parented(parent), kind_(kind) {}
-  void setup() override;
-  void dump_config() override;
-
- protected:
-  void write_state(bool state) override;
-  void apply_(bool state, bool transmit);
-
-  SwitchKind kind_;
-};
-
-}  // namespace esphome::haier_tundra

esphome/components/icm20689/__init__.py

@@ -1,13 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import spi
-from esphome.components.motion import MotionComponent
-
-CODEOWNERS = ["@lboue"]
-DOMAIN = "icm20689"
-
-CONF_ICM20689_ID = "icm20689_id"
-#  C++ namespace / class
-icm20689_ns = cg.esphome_ns.namespace("icm20689")
-ICM20689Component = icm20689_ns.class_(
-    "ICM20689Component", MotionComponent, spi.SPIDevice
-)

esphome/components/icm20689/icm20689.cpp

@@ -1,126 +0,0 @@
-#include "icm20689.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-
-#include <cstddef>
-#include <cstdint>
-
-namespace esphome::icm20689 {
-
-ESPHOME_LOG_TAG(TAG, "icm20689");
-
-namespace {
-
-// Range enum values 0..3 map to full-scale settings of 2x/4x/8x/16x the base range.
-constexpr float accel_scale(uint8_t range) { return (2.0f * (1U << range)) / 32768.0f; }
-
-constexpr float gyro_scale(uint8_t range) { return (250.0f * (1U << range)) / 32768.0f; }
-
-}  // namespace
-
-void ICM20689Component::write_register_(uint8_t reg, uint8_t value) {
-  this->enable();
-  this->write_byte(reg & 0x7F);
-  this->write_byte(value);
-  this->disable();
-}
-
-void ICM20689Component::read_registers_(uint8_t reg, uint8_t *data, size_t len) {
-  this->enable();
-  this->write_byte(reg | ICM20689_READ_BIT);
-  this->read_array(data, len);
-  this->disable();
-}
-
-void ICM20689Component::setup() {
-  MotionComponent::setup();
-
-  this->spi_setup();
-
-  if (!this->spi_is_ready()) {
-    ESP_LOGE(TAG, "SPI device is not ready");
-    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
-    return;
-  }
-
-  // Datasheet 4.20: a soft reset must be the first operation after power-up,
-  // before any register initialization. WHO_AM_I is only valid afterwards.
-  this->write_register_(ICM20689_REG_PWR_MGMT_1, ICM20689_SOFT_RESET);
-  delay(100);  // NOLINT
-
-  // The chip comes out of reset in sleep mode: wake it and select the
-  // auto-selected best clock source (required for full gyro performance).
-  this->write_register_(ICM20689_REG_PWR_MGMT_1, ICM20689_CLKSEL_AUTO);
-
-  // USER_CTRL is not writable in sleep mode, so I2C_IF_DIS is set once awake.
-  // Datasheet 6.1: disable the I2C interface when using SPI.
-  this->write_register_(ICM20689_REG_USER_CTRL, ICM20689_I2C_IF_DIS);
-
-  uint8_t who_am_i = 0;
-  this->read_registers_(ICM20689_REG_WHO_AM_I, &who_am_i, 1);
-
-  if (who_am_i != ICM20689_WHO_AM_I_VALUE) {
-    ESP_LOGE(TAG, "Unexpected WHO_AM_I 0x%02X (expected 0x%02X) -- check wiring/CS", who_am_i, ICM20689_WHO_AM_I_VALUE);
-    this->mark_failed(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
-    return;
-  }
-
-  // Allow the sensor to settle after waking from sleep.
-  delay(50);  // NOLINT
-
-  // Configure the accelerometer and gyroscope full-scale ranges.
-  this->write_register_(ICM20689_REG_ACCEL_CONFIG, static_cast<uint8_t>(this->accel_range_) << 3);
-  this->write_register_(ICM20689_REG_GYRO_CONFIG, static_cast<uint8_t>(this->gyro_range_) << 3);
-}
-
-void ICM20689Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "ICM20689 IMU:");
-  LOG_PIN("  CS Pin: ", this->cs_);
-
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, "  " ESP_LOG_MSG_COMM_FAIL);
-    return;
-  }
-
-  ESP_LOGCONFIG(TAG, "  Accel range: ±%dg", 2 << static_cast<uint8_t>(this->accel_range_));
-  ESP_LOGCONFIG(TAG, "  Gyro range: ±%d°/s", 250 << static_cast<uint8_t>(this->gyro_range_));
-
-  MotionComponent::dump_config();
-}
-
-bool ICM20689Component::update_data(motion::MotionData &data) {
-  if (this->is_failed())
-    return false;
-
-  const uint8_t accel_range = static_cast<uint8_t>(this->accel_range_);
-  const uint8_t gyro_range = static_cast<uint8_t>(this->gyro_range_);
-
-  // Read one contiguous sample:
-  // 0..5   accelerometer X/Y/Z
-  // 6..7   temperature
-  // 8..13  gyroscope X/Y/Z
-  uint8_t raw_data[14] = {};
-  this->read_registers_(ICM20689_REG_ACCEL_XOUT_H, raw_data, sizeof(raw_data));
-
-  const float accel_factor = accel_scale(accel_range);
-
-  data.acceleration[motion::X_AXIS] = static_cast<int16_t>(encode_uint16(raw_data[0], raw_data[1])) * accel_factor;
-  data.acceleration[motion::Y_AXIS] = static_cast<int16_t>(encode_uint16(raw_data[2], raw_data[3])) * accel_factor;
-  data.acceleration[motion::Z_AXIS] = static_cast<int16_t>(encode_uint16(raw_data[4], raw_data[5])) * accel_factor;
-
-  const float gyro_factor = gyro_scale(gyro_range);
-
-  data.angular_rate[motion::X_AXIS] = static_cast<int16_t>(encode_uint16(raw_data[8], raw_data[9])) * gyro_factor;
-  data.angular_rate[motion::Y_AXIS] = static_cast<int16_t>(encode_uint16(raw_data[10], raw_data[11])) * gyro_factor;
-  data.angular_rate[motion::Z_AXIS] = static_cast<int16_t>(encode_uint16(raw_data[12], raw_data[13])) * gyro_factor;
-
-  if (!this->temperature_callback_.empty()) {
-    // Datasheet formula: temperature (°C) = raw / 326.8 + 25.
-    const float temperature = static_cast<int16_t>(encode_uint16(raw_data[6], raw_data[7])) / 326.8f + 25.0f;
-    this->temperature_callback_.call(temperature);
-  }
-
-  return true;
-}
-
-}  // namespace esphome::icm20689

esphome/components/icm20689/icm20689.h

@@ -1,66 +0,0 @@
-#pragma once
-
-#include "esphome/components/motion/motion_component.h"
-#include "esphome/components/spi/spi.h"
-#include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
-
-namespace esphome::icm20689 {
-
-// Register map
-static constexpr uint8_t ICM20689_REG_WHO_AM_I = 0x75;
-static constexpr uint8_t ICM20689_REG_PWR_MGMT_1 = 0x6B;
-static constexpr uint8_t ICM20689_REG_USER_CTRL = 0x6A;
-static constexpr uint8_t ICM20689_REG_GYRO_CONFIG = 0x1B;
-static constexpr uint8_t ICM20689_REG_ACCEL_CONFIG = 0x1C;
-static constexpr uint8_t ICM20689_REG_ACCEL_XOUT_H = 0x3B;
-static constexpr uint8_t ICM20689_READ_BIT = 0x80;
-static constexpr uint8_t ICM20689_WHO_AM_I_VALUE = 0x98;
-static constexpr uint8_t ICM20689_SOFT_RESET = 0x81;   // PWR_MGMT_1: DEVICE_RESET | CLKSEL=1 (datasheet 4.20)
-static constexpr uint8_t ICM20689_CLKSEL_AUTO = 0x01;  // PWR_MGMT_1: SLEEP=0, CLKSEL=1 (auto-select best clock)
-static constexpr uint8_t ICM20689_I2C_IF_DIS = 0x10;   // USER_CTRL bit 4
-
-// Accelerometer range options: FS_SEL bits [4:3] of ACCEL_CONFIG
-enum ICM20689AccelRange : uint8_t {
-  ICM20689_ACCEL_RANGE_2G = 0x00,
-  ICM20689_ACCEL_RANGE_4G = 0x01,
-  ICM20689_ACCEL_RANGE_8G = 0x02,
-  ICM20689_ACCEL_RANGE_16G = 0x03,
-};
-
-// Gyroscope range options: FS_SEL bits [4:3] of GYRO_CONFIG
-enum ICM20689GyroRange : uint8_t {
-  ICM20689_GYRO_RANGE_250 = 0x00,
-  ICM20689_GYRO_RANGE_500 = 0x01,
-  ICM20689_GYRO_RANGE_1000 = 0x02,
-  ICM20689_GYRO_RANGE_2000 = 0x03,
-};
-
-class ICM20689Component final : public motion::MotionComponent,
-                                public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_LOW,
-                                                      spi::CLOCK_PHASE_LEADING, spi::DATA_RATE_1MHZ> {
- public:
-  void setup() override;
-  void dump_config() override;
-
-  void set_accel_range(ICM20689AccelRange range) { this->accel_range_ = range; }
-  void set_gyro_range(ICM20689GyroRange range) { this->gyro_range_ = range; }
-
-  template<typename F> void add_temperature_listener(F &&callback) {
-    this->temperature_callback_.add(std::forward<F>(callback));
-  }
-
- protected:
-  bool update_data(motion::MotionData &data) override;
-
-  void write_register_(uint8_t reg, uint8_t value);
-  // Reads len bytes starting at reg in one CS-low transaction.
-  void read_registers_(uint8_t reg, uint8_t *data, size_t len);
-
-  ICM20689AccelRange accel_range_{ICM20689_ACCEL_RANGE_2G};
-  ICM20689GyroRange gyro_range_{ICM20689_GYRO_RANGE_250};
-
-  LazyCallbackManager<void(float)> temperature_callback_{};
-};
-
-}  // namespace esphome::icm20689

esphome/components/icm20689/motion.py

@@ -1,56 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import spi
-from esphome.components.const import CONF_ACCELEROMETER_RANGE, CONF_GYROSCOPE_RANGE
-from esphome.components.motion import motion_schema, new_motion_component
-import esphome.config_validation as cv
-from esphome.types import ConfigType
-
-from . import ICM20689Component, icm20689_ns
-
-DEPENDENCIES = ["spi"]
-
-#  Enum proxies (must match the C++ enum values exactly)
-ICM20689AccelRange = icm20689_ns.enum("ICM20689AccelRange")
-ACCEL_RANGE_OPTIONS = {
-    "2G": ICM20689AccelRange.ICM20689_ACCEL_RANGE_2G,
-    "4G": ICM20689AccelRange.ICM20689_ACCEL_RANGE_4G,
-    "8G": ICM20689AccelRange.ICM20689_ACCEL_RANGE_8G,
-    "16G": ICM20689AccelRange.ICM20689_ACCEL_RANGE_16G,
-}
-
-ICM20689GyroRange = icm20689_ns.enum("ICM20689GyroRange")
-GYRO_RANGE_OPTIONS = {
-    "250DPS": ICM20689GyroRange.ICM20689_GYRO_RANGE_250,
-    "500DPS": ICM20689GyroRange.ICM20689_GYRO_RANGE_500,
-    "1000DPS": ICM20689GyroRange.ICM20689_GYRO_RANGE_1000,
-    "2000DPS": ICM20689GyroRange.ICM20689_GYRO_RANGE_2000,
-}
-
-#  Top-level CONFIG_SCHEMA
-CONFIG_SCHEMA = (
-    motion_schema(ICM20689Component, has_accel=True, has_gyro=True)
-    .extend(
-        {
-            cv.Optional(CONF_ACCELEROMETER_RANGE, default="2G"): cv.enum(
-                ACCEL_RANGE_OPTIONS, upper=True
-            ),
-            cv.Optional(CONF_GYROSCOPE_RANGE, default="250DPS"): cv.enum(
-                GYRO_RANGE_OPTIONS, upper=True
-            ),
-        }
-    )
-    .extend(
-        spi.spi_device_schema(
-            cs_pin_required=True, default_mode="MODE0", default_data_rate="1MHz"
-        )
-    )
-)
-
-
-#  Code generation
-async def to_code(config: ConfigType) -> None:
-    var = await new_motion_component(config)
-    await spi.register_spi_device(var, config)
-
-    cg.add(var.set_accel_range(config[CONF_ACCELEROMETER_RANGE]))
-    cg.add(var.set_gyro_range(config[CONF_GYROSCOPE_RANGE]))

esphome/components/icm20689/sensor.py

@@ -1,42 +0,0 @@
-#  YAML config keys
-import esphome.codegen as cg
-from esphome.components import sensor
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_TEMPERATURE,
-    CONF_TYPE,
-    DEVICE_CLASS_TEMPERATURE,
-    ICON_THERMOMETER,
-    STATE_CLASS_MEASUREMENT,
-    UNIT_CELSIUS,
-)
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType
-
-from . import CONF_ICM20689_ID, ICM20689Component
-
-AUTO_LOAD = ["icm20689"]
-
-CONFIG_SCHEMA = sensor.sensor_schema(
-    unit_of_measurement=UNIT_CELSIUS,
-    icon=ICON_THERMOMETER,
-    accuracy_decimals=2,
-    state_class=STATE_CLASS_MEASUREMENT,
-    device_class=DEVICE_CLASS_TEMPERATURE,
-).extend(
-    {
-        cv.Optional(CONF_TYPE): cv.one_of(CONF_TEMPERATURE),
-        cv.GenerateID(CONF_ICM20689_ID): cv.use_id(ICM20689Component),
-    }
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    var = await sensor.new_sensor(config)
-    parent = await cg.get_variable(config[CONF_ICM20689_ID])
-    data = MockObj("data")
-    value_lambda = await cg.process_lambda(
-        var.publish_state(data),
-        [(cg.float_, str(data))],
-    )
-    cg.add(parent.add_temperature_listener(value_lambda))

esphome/components/ili9xxx/ili9xxx_display.h

@@ -2,13 +2,12 @@
 #include "esphome/components/spi/spi.h"
 #include "esphome/components/display/display_buffer.h"
 #include "esphome/components/display/display_color_utils.h"
-#include "esphome/core/log.h"
 #include "ili9xxx_defines.h"
 #include "ili9xxx_init.h"
 
 namespace esphome::ili9xxx {
 
-ESPHOME_LOG_TAG(TAG, "ili9xxx");
+static const char *const TAG = "ili9xxx";
 const size_t ILI9XXX_TRANSFER_BUFFER_SIZE = 126;  // ensure this is divisible by 6
 
 enum ILI9XXXColorMode {

esphome/components/image/__init__.py

@@ -145,42 +145,13 @@ def is_alpha_only(image: Image):
     return all(b.getextrema()[1] == 0 for b in image.split()[:-1])
 
 
-class BitPackedEncoder(ImageEncoder):
-    """Packs pixels MSB first, with every row padded to a whole byte."""
-
-    def __init__(
-        self,
-        bpp: int,
-        width: int,
-        height: int,
-        transparency: str,
-        dither: Image.Dither,
-        invert_alpha: bool,
-    ):
-        self.bpp = bpp
-        super().__init__(
-            (width * bpp + 7) // 8, height, transparency, dither, invert_alpha
-        )
-        self.bitno = 0
-
-    def add_bit(self, bit: bool) -> None:
-        if bit:
-            self.data[self.index] |= 0x80 >> self.bitno
-        self.bitno += 1
-        if self.bitno == 8:
-            self.end_row()
-
-    def end_row(self) -> None:
-        if self.bitno != 0:
-            self.bitno = 0
-            self.index += 1
-
-
-class ImageBinary(BitPackedEncoder):
+class ImageBinary(ImageEncoder):
     allow_config = {CONF_OPAQUE, CONF_INVERT_ALPHA, CONF_CHROMA_KEY}
 
     def __init__(self, width, height, transparency, dither, invert_alpha):
-        super().__init__(1, width, height, transparency, dither, invert_alpha)
+        self.width8 = (width + 7) // 8
+        super().__init__(self.width8, height, transparency, dither, invert_alpha)
+        self.bitno = 0
 
     def convert(self, image, path):
         if is_alpha_only(image):
@@ -188,46 +159,22 @@ class ImageBinary(BitPackedEncoder):
         return image.convert("1", dither=self.dither)
 
     def encode(self, pixel):
-        self.add_bit(bool(pixel) != self.invert_alpha)
-
-
-# The eight colours one bit per channel can express, for dithering.
-_RGB111_PALETTE = Image.new("P", (1, 1))
-_RGB111_PALETTE.putpalette([255 * int(x) for i in range(8) for x in f"{i:03b}"])
-
-
-class ImageRGB111(BitPackedEncoder):
-    allow_config = {CONF_OPAQUE, CONF_ALPHA_CHANNEL}
-
-    def __init__(
-        self,
-        width: int,
-        height: int,
-        transparency: str,
-        dither: Image.Dither,
-        invert_alpha: bool,
-    ):
-        bpp = 4 if transparency == CONF_ALPHA_CHANNEL else 3
-        super().__init__(bpp, width, height, transparency, dither, invert_alpha)
-
-    def convert(self, image: Image, path: str):
-        image = image.convert("RGBA")
-        if self.dither != Image.Dither.FLOYDSTEINBERG:
-            return image
-        alpha = image.getchannel("A")
-        image = image.convert("RGB").quantize(
-            palette=_RGB111_PALETTE, dither=Image.Dither.FLOYDSTEINBERG
-        )
-        image = image.convert("RGB")
-        image.putalpha(alpha)
-        return image
-
-    def encode(self, pixel: tuple[int, int, int, int]):
-        r, g, b, a = pixel
         if self.invert_alpha:
-            a ^= 0xFF
-        for channel in (r, g, b, a)[: self.bpp]:
-            self.add_bit(channel > 127)
+            pixel = not pixel
+        if pixel:
+            self.data[self.index] |= 0x80 >> (self.bitno % 8)
+        self.bitno += 1
+        if self.bitno == 8:
+            self.bitno = 0
+            self.index += 1
+
+    def end_row(self):
+        """
+        Pad rows to a byte boundary
+        """
+        if self.bitno != 0:
+            self.bitno = 0
+            self.index += 1
 
 
 class ImageGrayscale(ImageEncoder):
@@ -368,7 +315,6 @@ class ReplaceWith:
 IMAGE_TYPE = {
     "BINARY": ImageBinary,
     "GRAYSCALE": ImageGrayscale,
-    "RGB111": ImageRGB111,
     "RGB565": ImageRGB565,
     "RGB": ImageRGB,
     "TRANSPARENT_BINARY": ReplaceWith("'type: BINARY' and 'transparency: chroma_key'"),

esphome/components/image/image.cpp

@@ -3,8 +3,6 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 
-ESPHOME_LOG_TAG(TAG, "image");
-
 namespace esphome::image {
 
 void Image::draw(int x, int y, display::Display *display, Color color_on, Color color_off) {
@@ -38,17 +36,6 @@ void Image::draw(int x, int y, display::Display *display, Color color_on, Color
       }
       break;
     }
-    case IMAGE_TYPE_RGB111: {
-      for (int img_x = img_x0; img_x < w; img_x++) {
-        for (int img_y = img_y0; img_y < h; img_y++) {
-          auto color = this->get_rgb111_pixel_(img_x, img_y);
-          if (color.w >= 0x80) {
-            display->draw_pixel_at(x + img_x, y + img_y, color);
-          }
-        }
-      }
-      break;
-    }
     case IMAGE_TYPE_GRAYSCALE:
       for (int img_x = img_x0; img_x < w; img_x++) {
         for (int img_y = img_y0; img_y < h; img_y++) {
@@ -104,8 +91,6 @@ Color Image::get_pixel(int x, int y, const Color color_on, const Color color_off
       if (this->get_binary_pixel_(x, y))
         return color_on;
       return color_off;
-    case IMAGE_TYPE_RGB111:
-      return this->get_rgb111_pixel_(x, y);
     case IMAGE_TYPE_GRAYSCALE:
       return this->get_grayscale_pixel_(x, y);
     case IMAGE_TYPE_RGB565:
@@ -135,10 +120,6 @@ lv_image_dsc_t *Image::get_lv_image_dsc() {
         this->dsc_.header.cf = LV_COLOR_FORMAT_A8;
         break;
 
-      case IMAGE_TYPE_RGB111:
-        // Rejected by the lvgl config validation
-        ESP_LOGE(TAG, "RGB111 images are not supported in LVGL.");
-        break;
       case IMAGE_TYPE_RGB:
         switch (this->transparency_) {
           case TRANSPARENCY_ALPHA_CHANNEL:
@@ -171,19 +152,6 @@ bool Image::get_binary_pixel_(int x, int y) const {
   const uint32_t pos = x + y * width_8;
   return progmem_read_byte(this->data_start_ + (pos / 8u)) & (0x80 >> (pos % 8u));
 }
-Color Image::get_rgb111_pixel_(int x, int y) const {
-  const uint32_t bitpos = y * this->get_width_stride() * 8 + x * this->bpp_;
-  const uint8_t *byte = this->data_start_ + bitpos / 8;
-  const uint8_t shift = bitpos % 8;
-  // A pixel can straddle two bytes; read the second one only when it does.
-  uint16_t window = progmem_read_byte(byte) << 8;
-  if (shift + this->bpp_ > 8)
-    window |= progmem_read_byte(byte + 1);
-  const uint8_t bits = (window >> (16 - this->bpp_ - shift)) & ((1u << this->bpp_) - 1);
-  const uint8_t rgb = this->bpp_ == 4 ? bits >> 1 : bits;
-  const bool opaque = this->bpp_ == 3 || (bits & 1);
-  return Color(rgb & 4 ? 0xFF : 0x00, rgb & 2 ? 0xFF : 0x00, rgb & 1 ? 0xFF : 0x00, opaque ? 0xFF : 0x00);
-}
 Color Image::get_rgb_pixel_(int x, int y) const {
   const uint32_t pos = (x + y * this->width_) * this->bpp_ / 8;
   Color color = Color(progmem_read_byte(this->data_start_ + pos + 2), progmem_read_byte(this->data_start_ + pos + 1),
@@ -248,9 +216,6 @@ Image::Image(const uint8_t *data_start, int width, int height, ImageType type, T
     case IMAGE_TYPE_BINARY:
       this->bpp_ = 1;
       break;
-    case IMAGE_TYPE_RGB111:
-      this->bpp_ = this->transparency_ == TRANSPARENCY_ALPHA_CHANNEL ? 4 : 3;
-      break;
     case IMAGE_TYPE_GRAYSCALE:
       this->bpp_ = 8;
       break;

esphome/components/image/image.h

@@ -13,7 +13,6 @@ enum ImageType {
   IMAGE_TYPE_GRAYSCALE = 1,
   IMAGE_TYPE_RGB = 2,
   IMAGE_TYPE_RGB565 = 3,
-  IMAGE_TYPE_RGB111 = 4,  // one bit per channel plus an optional alpha bit, for colour e-paper
 };
 
 enum Transparency {
@@ -45,7 +44,6 @@ class Image : public display::BaseImage {
 #endif
  protected:
   bool get_binary_pixel_(int x, int y) const;
-  Color get_rgb111_pixel_(int x, int y) const;
   Color get_rgb_pixel_(int x, int y) const;
   Color get_rgb565_pixel_(int x, int y) const;
   Color get_grayscale_pixel_(int x, int y) const;

esphome/components/it8951/it8951.cpp

@@ -891,10 +891,12 @@ static uint8_t color_to_nibble(const Color &color) {
   if (color.raw_32 == 0xFFFFFFFF)
     return 0x0F;  // white
 
-  // Rec.601 luma is the standard for converting SDR images to grayscale and spreads saturated colours
-  // across the mid-range; Rec.709 instead crams them against white/black where the 16 panel levels are
-  // hard to tell apart.
-  return quantize_8bit_to_nibble(display::rec601_luma(color));
+  // Derive luma from RGB using Rec.601 weights (0.299/0.587/0.114, scaled by
+  // 256). Rec.601 is the standard for converting SDR images to grayscale and
+  // spreads saturated colours across the mid-range; Rec.709 instead crams them
+  // against white/black where the 16 panel levels are hard to tell apart.
+  auto luma = static_cast<uint8_t>((77u * color.r + 150u * color.g + 29u * color.b + 128u) >> 8);
+  return quantize_8bit_to_nibble(luma);
 }
 
 // 4x4 ordered (Bayer) dither threshold over the weighted-luma range (0..65535).

esphome/components/lvgl/__init__.py

@@ -25,7 +25,6 @@ from esphome.components.image import (
     ImageBinary,
     ImageGrayscale,
     ImageRGB,
-    ImageRGB111,
     ImageRGB565,
     get_image_metadata,
 )
@@ -44,7 +43,6 @@ from esphome.const import (
     CONF_ROTATION,
     CONF_TIMEOUT,
     CONF_TRIGGER_ID,
-    CONF_TYPE,
 )
 from esphome.core import CORE, ID, Lambda
 from esphome.cpp_generator import MockObj
@@ -295,21 +293,6 @@ def final_validation(config_list):
     if len(config_list) != 1:
         multi_conf_validate(config_list)
 
-    for img in get_lv_images_used():
-        path = global_config.get_path_for_id(img.id)[:-1]
-        # An image nested in another platform (sendspin's current_image) takes its type from the parent
-        while path:
-            image_conf = global_config.get_config_for_path(path)
-            if isinstance(image_conf, dict) and CONF_TYPE in image_conf:
-                break
-            path = path[:-1]
-        else:
-            continue
-        if IMAGE_TYPE.get(image_conf[CONF_TYPE]) is ImageRGB111:
-            raise cv.FinalExternalInvalid(
-                f"Image '{img}': LVGL does not support RGB111 images, use RGB565 or RGB instead",
-                path + [CONF_TYPE],
-            )
     for w in get_focused_widgets():
         path = global_config.get_path_for_id(w)
         widget_conf = global_config.get_config_for_path(path[:-1])

esphome/components/lvgl/color_picker.h

@@ -85,7 +85,7 @@ class LvColorPickerType : public LvCompound {
     if (left != nullptr) {
       lv_obj_set_style_align(left, LV_ALIGN_LEFT_MID, LV_PART_MAIN);
       // A narrow hue column may be slimmer than its label.
-      lv_obj_set_flag(left, LV_OBJ_FLAG_OVERFLOW_VISIBLE, true);
+      lv_obj_add_flag(left, LV_OBJ_FLAG_OVERFLOW_VISIBLE);
     }
 
     // The text rows keep their natural height and the bars between them take what is left,
@@ -233,7 +233,7 @@ class LvColorPickerType : public LvCompound {
   static lv_obj_t *create_box(lv_obj_t *parent) {
     auto *obj = lv_obj_create(parent);
     lv_obj_add_style(obj, &plain_box, LV_PART_MAIN);
-    lv_obj_set_flag(obj, LV_OBJ_FLAG_SCROLLABLE, false);
+    lv_obj_remove_flag(obj, LV_OBJ_FLAG_SCROLLABLE);
     return obj;
   }
 
@@ -326,7 +326,7 @@ class LvColorPickerType : public LvCompound {
     lv_obj_set_style_radius(disc, LV_RADIUS_CIRCLE, LV_PART_MAIN);
     lv_obj_set_style_bg_opa(disc, LV_OPA_COVER, LV_PART_MAIN);
     lv_obj_set_style_bg_grad(disc, grad, LV_PART_MAIN);
-    lv_obj_set_flag(disc, LV_OBJ_FLAG_SCROLLABLE, false);
+    lv_obj_remove_flag(disc, LV_OBJ_FLAG_SCROLLABLE);
     return disc;
   }
 
@@ -336,7 +336,7 @@ class LvColorPickerType : public LvCompound {
     this->wheel_ = create_disc(container, &wheel_hue_grad);
     // Not clickable, so touches fall through to the wheel underneath.
     auto *overlay = create_disc(this->wheel_, &wheel_white_grad);
-    lv_obj_set_flag(overlay, LV_OBJ_FLAG_CLICKABLE, false);
+    lv_obj_remove_flag(overlay, LV_OBJ_FLAG_CLICKABLE);
 
     this->wheel_handle_ = lv_obj_create(this->wheel_);
     lv_obj_set_size(this->wheel_handle_, WHEEL_HANDLE_SIZE, WHEEL_HANDLE_SIZE);
@@ -345,8 +345,8 @@ class LvColorPickerType : public LvCompound {
     lv_obj_set_style_bg_opa(this->wheel_handle_, LV_OPA_TRANSP, LV_PART_MAIN);
     lv_obj_set_style_border_width(this->wheel_handle_, 2, LV_PART_MAIN);
     lv_obj_set_style_border_color(this->wheel_handle_, lv_color_white(), LV_PART_MAIN);
-    lv_obj_set_flag(this->wheel_handle_, LV_OBJ_FLAG_CLICKABLE, false);
-    lv_obj_set_flag(this->wheel_handle_, LV_OBJ_FLAG_SCROLLABLE, false);
+    lv_obj_remove_flag(this->wheel_handle_, LV_OBJ_FLAG_CLICKABLE);
+    lv_obj_remove_flag(this->wheel_handle_, LV_OBJ_FLAG_SCROLLABLE);
 
     // PRESSED as well, so a tap takes effect without the finger moving.
     lv_obj_add_event_cb(this->wheel_, wheel_touch_cb, LV_EVENT_PRESSED, this);
@@ -359,7 +359,7 @@ class LvColorPickerType : public LvCompound {
 
   void add_value_label_(SliderIndex index, lv_color_t color) {
     auto *slider = this->sliders_[index];
-    lv_obj_set_flag(slider, LV_OBJ_FLAG_OVERFLOW_VISIBLE, true);
+    lv_obj_add_flag(slider, LV_OBJ_FLAG_OVERFLOW_VISIBLE);
     auto *label = lv_label_create(slider);
     this->values_[index] = label;
     lv_obj_set_style_align(label, LV_ALIGN_CENTER, LV_PART_MAIN);
@@ -509,7 +509,7 @@ class LvColorPickerType : public LvCompound {
   static void bubble_events(lv_obj_t *obj) {
     for (uint32_t i = 0; i < lv_obj_get_child_count(obj); i++) {
       auto *child = lv_obj_get_child(obj, i);
-      lv_obj_set_flag(child, LV_OBJ_FLAG_EVENT_BUBBLE, true);
+      lv_obj_add_flag(child, LV_OBJ_FLAG_EVENT_BUBBLE);
       bubble_events(child);
     }
   }

esphome/components/lvgl/lvgl_esphome.h

@@ -214,7 +214,7 @@ enum class Orientation : uint8_t {
 };
 
 class LvglComponent final : public PollingComponent {
-  constexpr static const char *const TAG = "lvgl";  // NOLINT: lvgl does not build for ESP8266
+  constexpr static const char *const TAG = "lvgl";
 
  public:
   LvglComponent(std::vector<display::Display *> displays, float buffer_frac, bool full_refresh, int draw_rounding,

esphome/components/mapping/mapping.h

@@ -19,7 +19,7 @@ using alloc_string_t = std::basic_string<char, std::char_traits<char>, RAMAlloca
  * @tparam V The type of the value in the mapping. Should be a basic type or pointer.
  */
 
-ESPHOME_LOG_TAG(TAG, "mapping");
+static const char *const TAG = "mapping";
 
 template<typename K, typename V> class Mapping {
  public:

esphome/components/mdns/mdns_component.cpp

@@ -20,10 +20,6 @@
 #ifdef USE_DASHBOARD_IMPORT
 #include "esphome/components/dashboard_import/dashboard_import.h"
 #endif
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-#include "esphome/components/ethernet/ethernet_component.h"
-#include "esphome/components/wifi/wifi_component.h"
-#endif
 
 namespace esphome::mdns {
 
@@ -43,45 +39,6 @@ MDNS_STATIC_CONST_CHAR(SERVICE_TCP, "_tcp");
 // Wrap build-time defines into flash storage
 MDNS_STATIC_CONST_CHAR(VALUE_VERSION, ESPHOME_VERSION);
 
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
-MDNS_STATIC_CONST_CHAR(NETWORK_ETHERNET, "ethernet");
-
-// Same order as the default route in NetworkComponent::loop()
-const char *MDNSComponent::connected_network_() const {
-  const bool ethernet = ethernet::global_eth_component->is_connected();
-  const bool wifi = wifi::global_wifi_component->is_connected();
-#ifdef USE_NETWORK_PRIMARY_INTERFACE_WIFI
-  if (wifi)
-    return NETWORK_WIFI;
-#endif
-  if (ethernet)
-    return NETWORK_ETHERNET;
-  if (wifi)
-    return NETWORK_WIFI;
-  return nullptr;
-}
-
-void MDNSComponent::update_network_txt_() {
-  if (this->network_txt_ == nullptr)
-    return;
-  // With no interface connected, keep the last value instead of flapping to wifi
-  const char *network = this->connected_network_();
-  if (network == nullptr || network == this->network_txt_)
-    return;
-  if (!this->publish_network_txt_(network)) {
-    // The _esphomelib service is missing, so a retry would fail too
-    this->network_txt_ = nullptr;
-    return;
-  }
-  ESP_LOGD(TAG, "Network TXT: %s", network);
-  this->network_txt_ = network;
-#ifdef USE_MDNS_STORE_SERVICES
-  this->network_record_->value = MDNS_STR(network);
-#endif
-}
-#endif
-
 void MDNSComponent::setup_buffers_and_register_(PlatformRegisterFn platform_register) {
 #ifdef USE_MDNS_STORE_SERVICES
   auto &services = this->services_;
@@ -203,15 +160,7 @@ void MDNSComponent::compile_records_(StaticVector<MDNSService, MDNS_SERVICE_COUN
 
     txt_records.push_back({MDNS_STR(TXT_BOARD), MDNS_STR(VALUE_BOARD)});
 
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-    const char *network = this->connected_network_();
-    this->network_txt_ = network != nullptr ? network : NETWORK_WIFI;
-    txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(this->network_txt_)});
-#ifdef USE_MDNS_STORE_SERVICES
-    // services is services_ here, which never reallocates
-    this->network_record_ = &txt_records.back();
-#endif
-#elif defined(USE_WIFI)
+#if defined(USE_WIFI)
     MDNS_STATIC_CONST_CHAR(NETWORK_WIFI, "wifi");
     txt_records.push_back({MDNS_STR(TXT_NETWORK), MDNS_STR(NETWORK_WIFI)});
 #elif defined(USE_ETHERNET)

esphome/components/mdns/mdns_component.h

@@ -32,12 +32,6 @@
 #define USE_MDNS_DEVICE_INFO_TXT
 #endif
 
-// With both wifi and ethernet, the _esphomelib "network" TXT value follows the connected interface.
-// OpenThread hands its services to the SRP client once, so it keeps the fixed value.
-#if defined(USE_API) && defined(USE_WIFI) && defined(USE_ETHERNET) && !defined(USE_OPENTHREAD)
-#define USE_MDNS_DYNAMIC_NETWORK_TXT
-#endif
-
 namespace esphome::mdns {
 
 // Helper struct that identifies strings that may be stored in flash storage (similar to LogString)
@@ -156,22 +150,6 @@ class MDNSComponent final : public Component
 
   void setup_buffers_and_register_(PlatformRegisterFn platform_register);
 
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-  static constexpr uint32_t NETWORK_TXT_CHECK_INTERVAL_MS = 1000;
-  /// The first connected interface in network: priority order ("ethernet" or "wifi"), else nullptr.
-  const char *connected_network_() const;
-  /// Check the connected interface and publish a changed "network" TXT value.
-  void update_network_txt_();
-  /// Platform-specific: replace the "network" TXT value of the registered _esphomelib service.
-  bool publish_network_txt_(const char *network);
-  /// Advertised value; nullptr until the _esphomelib service is registered, and after a failed publish.
-  const char *network_txt_{nullptr};
-#ifdef USE_MDNS_STORE_SERVICES
-  /// The "network" record in services_, kept in step with network_txt_.
-  MDNSTXTRecord *network_record_{nullptr};
-#endif
-#endif
-
 #ifdef USE_MDNS_DYNAMIC_TXT
   /// Storage for runtime-generated TXT values from user lambdas
   /// Pre-sized at compile time via MDNS_DYNAMIC_TXT_COUNT to avoid heap allocations.

esphome/components/mdns/mdns_esp32.cpp

@@ -89,24 +89,7 @@ bool MDNSComponent::set_service_enabled(const char *service_type, const char *pr
 }
 #endif  // USE_MDNS_SUPPORTS_ENABLE_DISABLE && !USE_OPENTHREAD
 
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-bool MDNSComponent::publish_network_txt_(const char *network) {
-  // ESP-IDF copies the value and announces the changed record
-  esp_err_t err = mdns_service_txt_item_set("_esphomelib", "_tcp", "network", network);
-  if (err != ESP_OK) {
-    ESP_LOGW(TAG, "Failed to update network TXT: %s", esp_err_to_name(err));
-    return false;
-  }
-  return true;
-}
-#endif
-
-void MDNSComponent::setup() {
-  this->setup_buffers_and_register_(register_esp32);
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS, [this]() { this->update_network_txt_(); });
-#endif
-}
+void MDNSComponent::setup() { this->setup_buffers_and_register_(register_esp32); }
 
 void MDNSComponent::on_shutdown() {
 #ifndef USE_OPENTHREAD

esphome/components/mdns/mdns_rp2.cpp

@@ -46,26 +46,7 @@ void MDNSComponent::start_polling_window_() {
 }
 #endif
 
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-ESPHOME_LOG_TAG(TAG, "mdns");
-
-bool MDNSComponent::publish_network_txt_(const char *network) {
-  // LEAmDNS replaces the value of an existing key; announce() sends the change
-  if (!MDNS.addServiceTxt("esphomelib", "tcp", "network", network)) {
-    ESP_LOGW(TAG, "Failed to update network TXT");
-    return false;
-  }
-  MDNS.announce();
-  this->start_polling_window_();
-  return true;
-}
-#endif
-
 void MDNSComponent::setup() {
-#ifdef USE_MDNS_DYNAMIC_NETWORK_TXT
-  // No-op until the first IP-up event registers the services
-  this->set_interval(NETWORK_TXT_CHECK_INTERVAL_MS, [this]() { this->update_network_txt_(); });
-#endif
   // arduino-pico stubs out LwipIntf::stateUpCB (the netif status callback LEAmDNS uses
   // on ESP8266 for auto-restart), so we must drive begin()/notifyAPChange() from our
   // own IP state listener. Both WiFi and Ethernet have the same listener signature —

esphome/components/midea/ac_adapter.cpp

@@ -5,7 +5,7 @@
 
 namespace esphome::midea::ac {
 
-const char Constants::TAG[] PROGMEM = "midea";
+const char *const Constants::TAG = "midea";
 const char *const Constants::FREEZE_PROTECTION = "Freeze Protection";
 const char *const Constants::SILENT = "Silent";
 const char *const Constants::TURBO = "Turbo";

esphome/components/midea/ac_adapter.h

@@ -17,7 +17,7 @@ using MideaPreset = dudanov::midea::ac::Preset;
 
 class Constants {
  public:
-  static const char TAG[];  // PROGMEM, like ESPHOME_LOG_TAG
+  static const char *const TAG;
   static const char *const FREEZE_PROTECTION;
   static const char *const SILENT;
   static const char *const TURBO;

esphome/components/mipi_dsi/mipi_dsi.h

@@ -18,7 +18,7 @@
 
 namespace esphome::mipi_dsi {
 
-ESPHOME_LOG_TAG(TAG, "display.mipi_dsi");
+constexpr static const char *const TAG = "display.mipi_dsi";
 const uint8_t SW_RESET_CMD = 0x01;
 const uint8_t SLEEP_OUT = 0x11;
 const uint8_t SDIR_CMD = 0xC7;

esphome/components/mipi_rgb/mipi_rgb.h

@@ -2,7 +2,6 @@
 
 #if defined(USE_ESP32_VARIANT_ESP32S3) || defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S31)
 #include "esphome/core/gpio.h"
-#include "esphome/core/log.h"
 #include "esphome/components/display/display.h"
 #include <esp_lcd_panel_rgb.h>
 #ifdef USE_SPI
@@ -11,7 +10,7 @@
 
 namespace esphome::mipi_rgb {
 
-ESPHOME_LOG_TAG(TAG, "display.mipi_rgb");
+constexpr static const char *const TAG = "display.mipi_rgb";
 const uint8_t SW_RESET_CMD = 0x01;
 const uint8_t SLEEP_OUT = 0x11;
 const uint8_t SDIR_CMD = 0xC7;

esphome/components/mipi_spi/mipi_spi.h

@@ -7,11 +7,10 @@
 #include "esphome/components/display/display_color_utils.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
 
 namespace esphome::mipi_spi {
 
-ESPHOME_LOG_TAG(TAG, "display.mipi_spi");
+constexpr static const char *const TAG = "display.mipi_spi";
 
 // Maximum bytes to log for commands (truncated if larger)
 static constexpr size_t MIPI_SPI_MAX_CMD_LOG_BYTES = 64;

esphome/components/nrf52/__init__.py

@@ -1040,13 +1040,11 @@ def run_compile(args, config: ConfigType) -> bool:
     framework_ver = CORE.data[KEY_CORE][KEY_FRAMEWORK_VERSION]
     bootloader = zephyr_data()[KEY_BOOTLOADER]
 
-    # (dev_type, sd_req) per bootloader — values from Nordic SoftDevice release notes.
-    # The bootloader resets on a package whose sd_req does not list its SoftDevice,
-    # so v7 accepts S140 7.0.1, 7.2.0 and 7.3.0 (e.g. Seeed XIAO nRF52840).
+    # (dev_type, sd_req) per bootloader — values from Nordic SoftDevice release notes
     _GENPKG_PARAMS = {
         BOOTLOADER_ADAFRUIT_NRF52_SD132: ("0x0051", "0x009D"),
         BOOTLOADER_ADAFRUIT_NRF52_SD140_V6: ("0x0052", "0x00B6"),
-        BOOTLOADER_ADAFRUIT_NRF52_SD140_V7: ("0x0052", "0x00CA,0x0100,0x0123"),
+        BOOTLOADER_ADAFRUIT_NRF52_SD140_V7: ("0x0052", "0x00CA"),
     }
     # UF2 family IDs — nRF52832 vs nRF52840 per SoftDevice variant
     _UF2_FAMILY_IDS = {

esphome/components/openthread/__init__.py

@@ -1,4 +1,3 @@
-import re
 from typing import Any
 
 from esphome import automation
@@ -45,12 +44,9 @@ from esphome.core import (
     coroutine_with_priority,
 )
 import esphome.final_validate as fv
-from esphome.helpers import write_file_if_changed
 from esphome.types import ConfigType
-from esphome.writer import clean_build
 
 from .const import (
-    CONF_CORE_OPTIONS,
     CONF_DEVICE_TYPE,
     CONF_EXT_PAN_ID,
     CONF_FORCE_DATASET,
@@ -63,7 +59,6 @@ from .const import (
     CONF_PSKC,
     CONF_SRP_ID,
     CONF_TLV,
-    OPENTHREAD_CONFIG_PREFIX,
 )
 
 CODEOWNERS = ["@mrene"]
@@ -89,10 +84,6 @@ CONF_DEVICE_TYPES = [
     "MTD",
 ]
 
-OT_HEADER_DIR = "openthread"
-OT_HEADER_FILE = "esphome_ot_config.h"
-OT_CORE_OPTION_NAME = re.compile(r"[A-Z0-9_]+")
-
 
 def _validate_txpower(value: Any) -> int | float:
     if CORE.is_esp32:
@@ -167,31 +158,6 @@ def set_sdkconfig_options(config: ConfigType) -> None:
     add_idf_sdkconfig_option(f"CONFIG_OPENTHREAD_{config.get(CONF_DEVICE_TYPE)}", True)
 
 
-def _write_custom_header(config: ConfigType) -> None:
-    """Write core_options to the OpenThread custom header."""
-    if not (options := config.get(CONF_CORE_OPTIONS)):
-        return
-
-    add_idf_sdkconfig_option("CONFIG_OPENTHREAD_HEADER_CUSTOM", True)
-    # IDF resolves the path relative to the project (build) directory.
-    add_idf_sdkconfig_option("CONFIG_OPENTHREAD_CUSTOM_HEADER_PATH", OT_HEADER_DIR)
-    add_idf_sdkconfig_option(
-        "CONFIG_OPENTHREAD_CUSTOM_HEADER_FILE_NAME", OT_HEADER_FILE
-    )
-    content = (
-        "// Auto-generated by ESPHome from openthread core_options - do not edit\n"
-        "#pragma once\n\n"
-        + "".join(
-            f"#define {name} {value}\n" for name, value in sorted(options.items())
-        )
-    )
-    # PlatformIO does not track this header as an OpenThread input; the esp-idf
-    # toolchain does.
-    header_path = CORE.relative_build_path(OT_HEADER_DIR, OT_HEADER_FILE)
-    if write_file_if_changed(header_path, content) and not CORE.using_toolchain_esp_idf:
-        clean_build(clear_pio_cache=False)
-
-
 openthread_ns = cg.esphome_ns.namespace("openthread")
 OpenThreadComponent = openthread_ns.class_("OpenThreadComponent", cg.Component)
 OpenThreadSrpComponent = openthread_ns.class_("OpenThreadSrpComponent", cg.Component)
@@ -254,34 +220,6 @@ def _validate_platform(config: ConfigType) -> ConfigType:
     )(config)
 
 
-def _validate_core_option_names(options: dict[str, str]) -> dict[str, str]:
-    for name in options:
-        if (
-            not name.startswith(OPENTHREAD_CONFIG_PREFIX)
-            or name == OPENTHREAD_CONFIG_PREFIX
-        ):
-            raise cv.Invalid(
-                f"'{name}' is not an OpenThread core option; names must be "
-                f"{OPENTHREAD_CONFIG_PREFIX} followed by the option name",
-                path=[name],
-            )
-        if not OT_CORE_OPTION_NAME.fullmatch(name):
-            raise cv.Invalid(f"'{name}' may only contain A-Z, 0-9 and _", path=[name])
-    return options
-
-
-def _validate_core_option_value(value: Any) -> str:
-    value = cv.string_strict(value)
-    if not value.strip():
-        raise cv.Invalid("OpenThread core option value must not be empty")
-    if "\n" in value or "\r" in value:
-        raise cv.Invalid("OpenThread core option value must be a single line")
-    # GCC treats a backslash followed by spaces as a line continuation too.
-    if value.rstrip().endswith("\\"):
-        raise cv.Invalid("OpenThread core option value must not end with \\")
-    return value
-
-
 def _validate_tlv_hex(value: Any) -> str:
     s = cv.string_strict(value)
     if len(s) % 2 != 0:
@@ -314,11 +252,6 @@ CONFIG_SCHEMA = cv.All(
                 _validate_txpower,
             ),
             cv.Optional(CONF_POLL_PERIOD): cv.positive_time_period_milliseconds,
-            cv.Optional(CONF_CORE_OPTIONS): cv.All(
-                cv.only_on_esp32,
-                {cv.string_strict: _validate_core_option_value},
-                _validate_core_option_names,
-            ),
         }
     ).extend(_CONNECTION_SCHEMA),
     cv.has_exactly_one_key(CONF_NETWORK_KEY, CONF_TLV),
@@ -392,7 +325,6 @@ async def to_code(config: ConfigType) -> None:
 
     if CORE.is_esp32:
         set_sdkconfig_options(config)
-        _write_custom_header(config)
     elif CORE.using_zephyr:
         # Crypto through PSA: mbedtls, plus Oberon from SDK 2.7
         include_west_project("mbedtls")

esphome/components/openthread/const.py

@@ -1,4 +1,3 @@
-CONF_CORE_OPTIONS = "core_options"
 CONF_DEVICE_TYPE = "device_type"
 CONF_EXT_PAN_ID = "ext_pan_id"
 CONF_FORCE_DATASET = "force_dataset"
@@ -11,5 +10,3 @@ CONF_POLL_PERIOD = "poll_period"
 CONF_PSKC = "pskc"
 CONF_SRP_ID = "srp_id"
 CONF_TLV = "tlv"
-
-OPENTHREAD_CONFIG_PREFIX = "OPENTHREAD_CONFIG_"

esphome/components/pca9505/__init__.py

@@ -1,79 +0,0 @@
-from esphome import pins
-import esphome.codegen as cg
-from esphome.components import i2c
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ID,
-    CONF_INPUT,
-    CONF_INTERRUPT_PIN,
-    CONF_INVERTED,
-    CONF_MODE,
-    CONF_NUMBER,
-    CONF_OUTPUT,
-)
-from esphome.cpp_generator import MockObj
-from esphome.types import ConfigType
-
-AUTO_LOAD = ["gpio_expander"]
-CODEOWNERS = ["@ssieb", "@ajfriesen"]
-DEPENDENCIES = ["i2c"]
-DOMAIN = "pca9505"
-MULTI_CONF = True
-
-pca9505_ns = cg.esphome_ns.namespace("pca9505")
-
-PCA9505Component = pca9505_ns.class_("PCA9505Component", cg.Component, i2c.I2CDevice)
-PCA9505GPIOPin = pca9505_ns.class_(
-    "PCA9505GPIOPin", cg.GPIOPin, cg.Parented.template(PCA9505Component)
-)
-
-CONF_PCA9505 = "pca9505"
-CONFIG_SCHEMA = (
-    cv.Schema(
-        {
-            cv.Required(CONF_ID): cv.declare_id(PCA9505Component),
-            cv.Optional(CONF_INTERRUPT_PIN): pins.internal_gpio_input_pin_schema,
-        }
-    )
-    .extend(cv.COMPONENT_SCHEMA)
-    .extend(i2c.i2c_device_schema(0x20))
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_component(var, config)
-    await i2c.register_i2c_device(var, config)
-    if interrupt_pin := config.get(CONF_INTERRUPT_PIN):
-        cg.add(var.set_interrupt_pin(await cg.gpio_pin_expression(interrupt_pin)))
-
-
-def validate_mode(value: ConfigType) -> ConfigType:
-    if not (value[CONF_INPUT] or value[CONF_OUTPUT]):
-        raise cv.Invalid("Mode must be either input or output")
-    if value[CONF_INPUT] and value[CONF_OUTPUT]:
-        raise cv.Invalid("Mode must be either input or output")
-    return value
-
-
-PCA9505_PIN_SCHEMA = pins.gpio_base_schema(
-    PCA9505GPIOPin,
-    cv.int_range(min=0, max=39),
-    modes=[CONF_INPUT, CONF_OUTPUT],
-    mode_validator=validate_mode,
-).extend(
-    {
-        cv.Required(CONF_PCA9505): cv.use_id(PCA9505Component),
-    }
-)
-
-
-@pins.PIN_SCHEMA_REGISTRY.register(CONF_PCA9505, PCA9505_PIN_SCHEMA)
-async def pca9505_pin_to_code(config: ConfigType) -> MockObj:
-    var = cg.new_Pvariable(config[CONF_ID])
-    await cg.register_parented(var, config[CONF_PCA9505])
-
-    cg.add(var.set_pin(config[CONF_NUMBER]))
-    cg.add(var.set_inverted(config[CONF_INVERTED]))
-    cg.add(var.set_flags(pins.gpio_flags_expr(config[CONF_MODE])))
-    return var

esphome/components/pca9505/pca9505.cpp

@@ -1,165 +0,0 @@
-#include "pca9505.h"
-#include "esphome/core/log.h"
-
-namespace esphome::pca9505 {
-
-// Each register block holds one byte per port. Add the port number to reach a single
-// port, or set the auto-increment bit to transfer the whole block in one go.
-static constexpr uint8_t INPUT_REG = 0x00;
-static constexpr uint8_t OUTPUT_REG = 0x08;
-static constexpr uint8_t INVERT_REG = 0x10;
-static constexpr uint8_t CONFIG_REG = 0x18;
-static constexpr uint8_t MASK_REG = 0x20;
-static constexpr uint8_t AUTO_INCREMENT = 0x80;
-
-ESPHOME_LOG_TAG(TAG, "pca9505");
-
-void PCA9505Component::setup() {
-  // Test to see if device exists
-  if (!this->read_bank_(0)) {
-    ESP_LOGE(TAG, "PCA9505 not detected at 0x%02X", this->address_);
-    this->mark_failed();
-    return;
-  }
-
-  // No polarity inversion
-  this->write_all_banks_(INVERT_REG, 0x00);
-  // All outputs low, before anything is switched to being an output
-  this->write_all_banks_(OUTPUT_REG, 0x00);
-  // All inputs at initialization. The part sees a 1 as an input, so this is the
-  // inverse of config_, which is all zeroes here.
-  this->write_all_banks_(CONFIG_REG, 0xFF);
-
-  // Mask every interrupt. This must be written, not assumed: the chip keeps its
-  // registers through an MCU reboot, so a previous run may have left pins unmasked.
-  for (uint8_t &bank : this->mask_) {
-    bank = 0xFF;
-  }
-  this->write_all_banks_(MASK_REG, 0xFF);
-
-  if (this->interrupt_pin_ != nullptr) {
-    this->interrupt_pin_->setup();
-    this->interrupt_pin_->attach_interrupt(&PCA9505Component::gpio_intr, this, gpio::INTERRUPT_FALLING_EDGE);
-    // Don't invalidate cache on read - only invalidate when interrupt fires
-    this->set_invalidate_on_read_(false);
-  }
-
-  // Nothing to poll until pin_mode() registers an input pin.
-  this->disable_loop();
-}
-
-void IRAM_ATTR PCA9505Component::gpio_intr(PCA9505Component *arg) { arg->enable_loop_soon_any_context(); }
-
-void PCA9505Component::loop() {
-  // Invalidate the cache so the next digital_read() triggers a fresh I2C read
-  this->reset_pin_cache_();
-  // Only disable the loop once INT has actually gone HIGH. Input transitions that straddle the
-  // I2C read leave INT asserted without re-firing a falling edge, which would strand us with
-  // stale state forever; keep looping until the line is released so we self-heal.
-  if (this->interrupt_pin_ != nullptr && this->interrupt_pin_->digital_read()) {
-    this->disable_loop();
-  }
-}
-
-void PCA9505Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "PCA9505:");
-  LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
-  LOG_I2C_DEVICE(this)
-  if (this->is_failed()) {
-    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
-  }
-}
-
-bool PCA9505Component::digital_read_hw(uint8_t pin) { return this->read_bank_(pin / 8); }
-
-bool PCA9505Component::digital_read_cache(uint8_t pin) { return this->input_[pin / 8] & (1 << (pin % 8)); }
-
-void PCA9505Component::digital_write_hw(uint8_t pin, bool value) {
-  const uint8_t bank = pin / 8;
-  const uint8_t mask = 1 << (pin % 8);
-  if (value) {
-    this->output_[bank] |= mask;
-  } else {
-    this->output_[bank] &= ~mask;
-  }
-  this->write_bank_(OUTPUT_REG, bank, this->output_[bank]);
-}
-
-void PCA9505Component::pin_mode(uint8_t pin, gpio::Flags flags) {
-  const uint8_t bank = pin / 8;
-  const uint8_t mask = 1 << (pin % 8);
-  if (flags & gpio::FLAG_INPUT) {
-    this->config_[bank] &= ~mask;
-    // An input may raise INT; the polling loop is only needed when there is no interrupt pin.
-    this->mask_[bank] &= ~mask;
-    if (this->interrupt_pin_ == nullptr) {
-      this->enable_loop();
-    }
-  } else if (flags & gpio::FLAG_OUTPUT) {
-    this->config_[bank] |= mask;
-    // An output must never raise INT.
-    this->mask_[bank] |= mask;
-  }
-  // Invert as the part sees a 1 as an input
-  this->write_bank_(CONFIG_REG, bank, ~this->config_[bank]);
-  // Without an interrupt pin INT is unconnected, so the masks written at setup can stay
-  if (this->interrupt_pin_ != nullptr) {
-    this->write_bank_(MASK_REG, bank, this->mask_[bank]);
-  }
-}
-
-bool PCA9505Component::read_bank_(uint8_t bank) {
-  if (this->is_failed())
-    return false;
-
-  if (this->read_register(INPUT_REG + bank, &this->input_[bank], 1) != i2c::ERROR_OK) {
-    this->status_set_warning(LOG_STR("Failed to read input register"));
-    return false;
-  }
-  this->status_clear_warning();
-  return true;
-}
-
-bool PCA9505Component::write_bank_(uint8_t reg, uint8_t bank, uint8_t value) {
-  if (this->is_failed())
-    return false;
-
-  if (this->write_register(reg + bank, &value, 1) != i2c::ERROR_OK) {
-    this->status_set_warning(LOG_STR("Failed to write register"));
-    return false;
-  }
-  this->status_clear_warning();
-  return true;
-}
-
-bool PCA9505Component::write_all_banks_(uint8_t reg, uint8_t value) {
-  if (this->is_failed())
-    return false;
-
-  uint8_t values[BANK_COUNT];
-  for (uint8_t &bank : values) {
-    bank = value;
-  }
-  if (this->write_register(reg | AUTO_INCREMENT, values, sizeof(values)) != i2c::ERROR_OK) {
-    this->status_set_warning(LOG_STR("Failed to write register"));
-    return false;
-  }
-  this->status_clear_warning();
-  return true;
-}
-
-float PCA9505Component::get_setup_priority() const { return setup_priority::IO; }
-
-void PCA9505GPIOPin::setup() { this->pin_mode(this->flags_); }
-
-void PCA9505GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
-
-bool PCA9505GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
-
-void PCA9505GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }
-
-size_t PCA9505GPIOPin::dump_summary(char *buffer, size_t len) const {
-  return buf_append_printf(buffer, len, 0, "%u via PCA9505", this->pin_);
-}
-
-}  // namespace esphome::pca9505

esphome/components/pca9505/pca9505.h

@@ -1,72 +0,0 @@
-#pragma once
-
-#include "esphome/core/component.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
-#include "esphome/components/gpio_expander/cached_gpio.h"
-#include "esphome/components/i2c/i2c.h"
-
-namespace esphome::pca9505 {
-
-/// Number of I/O pins on the PCA9505 and PCA9506.
-static constexpr uint8_t PIN_COUNT = 40;
-/// The pins are grouped into five ports of eight, each with its own set of registers.
-static constexpr uint8_t BANK_COUNT = PIN_COUNT / 8;
-
-class PCA9505Component final : public Component,
-                               public i2c::I2CDevice,
-                               public gpio_expander::CachedGpioExpander<uint8_t, PIN_COUNT> {
- public:
-  void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
-
-  void setup() override;
-  void loop() override;
-  void pin_mode(uint8_t pin, gpio::Flags flags);
-
-  float get_setup_priority() const override;
-
-  void dump_config() override;
-
- protected:
-  static void IRAM_ATTR gpio_intr(PCA9505Component *arg);
-
-  bool digital_read_hw(uint8_t pin) override;
-  bool digital_read_cache(uint8_t pin) override;
-  void digital_write_hw(uint8_t pin, bool value) override;
-
-  bool read_bank_(uint8_t bank);
-  bool write_bank_(uint8_t reg, uint8_t bank, uint8_t value);
-  bool write_all_banks_(uint8_t reg, uint8_t value);
-
-  /// The pin config per bank - 1 means OUTPUT, 0 means INPUT
-  uint8_t config_[BANK_COUNT]{};
-  /// The output state per bank - 1 means HIGH, 0 means LOW
-  uint8_t output_[BANK_COUNT]{};
-  /// The input pin states per bank - 1 means HIGH, 0 means LOW
-  uint8_t input_[BANK_COUNT]{};
-  /// Which pins may pull INT low - 1 means masked, matching the chip
-  uint8_t mask_[BANK_COUNT]{};
-  InternalGPIOPin *interrupt_pin_{nullptr};
-};
-
-class PCA9505GPIOPin final : public GPIOPin, public Parented<PCA9505Component> {
- public:
-  void setup() override;
-  void pin_mode(gpio::Flags flags) override;
-  bool digital_read() override;
-  void digital_write(bool value) override;
-  size_t dump_summary(char *buffer, size_t len) const override;
-
-  void set_pin(uint8_t pin) { this->pin_ = pin; }
-  void set_inverted(bool inverted) { this->inverted_ = inverted; }
-  void set_flags(gpio::Flags flags) { this->flags_ = flags; }
-
-  gpio::Flags get_flags() const override { return this->flags_; }
-
- protected:
-  uint8_t pin_{0};
-  bool inverted_{false};
-  gpio::Flags flags_{};
-};
-
-}  // namespace esphome::pca9505

esphome/components/pcf8574/__init__.py

@@ -10,7 +10,6 @@ from esphome.const import (
     CONF_MODE,
     CONF_NUMBER,
     CONF_OUTPUT,
-    CONF_RESET,
 )
 from esphome.cpp_generator import MockObj
 from esphome.types import ConfigType
@@ -27,14 +26,11 @@ PCF8574GPIOPin = pcf8574_ns.class_("PCF8574GPIOPin", cg.GPIOPin)
 
 CONF_PCF8574 = "pcf8574"
 CONF_PCF8575 = "pcf8575"
-# Keep in sync with PCF8574Component::reset_ in pcf8574.h.
-DEFAULT_RESET = True
 CONFIG_SCHEMA = (
     cv.Schema(
         {
             cv.Required(CONF_ID): cv.declare_id(PCF8574Component),
             cv.Optional(CONF_PCF8575, default=False): cv.boolean,
-            cv.Optional(CONF_RESET, default=DEFAULT_RESET): cv.boolean,
             cv.Optional(CONF_INTERRUPT_PIN): gpio_expander.validate_interrupt_pin,
         }
     )
@@ -48,8 +44,6 @@ async def to_code(config: ConfigType) -> None:
     await cg.register_component(var, config)
     await i2c.register_i2c_device(var, config)
     cg.add(var.set_pcf8575(config[CONF_PCF8575]))
-    if (reset := config[CONF_RESET]) != DEFAULT_RESET:
-        cg.add(var.set_reset(reset))
     if interrupt_pin := config.get(CONF_INTERRUPT_PIN):
         cg.add(var.set_interrupt_pin(await cg.gpio_pin_expression(interrupt_pin)))
 

esphome/components/pcf8574/pcf8574.cpp

@@ -12,13 +12,8 @@ void PCF8574Component::setup() {
     return;
   }
 
-  if (this->reset_) {
-    this->write_gpio_();
-    this->read_gpio_();
-  } else {
-    this->output_mask_ = this->input_mask_;
-    this->mode_mask_ = ~this->configured_input_pins_;
-  }
+  this->write_gpio_();
+  this->read_gpio_();
 
   if (this->interrupt_pin_ != nullptr) {
     this->interrupt_pin_->setup();
@@ -45,9 +40,8 @@ void PCF8574Component::loop() {
 void PCF8574Component::dump_config() {
   ESP_LOGCONFIG(TAG,
                 "PCF8574:\n"
-                "  Is PCF8575: %s\n"
-                "  Reset: %s",
-                YESNO(this->pcf8575_), YESNO(this->reset_));
+                "  Is PCF8575: %s",
+                YESNO(this->pcf8575_));
   LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
   LOG_I2C_DEVICE(this)
   if (this->is_failed()) {
@@ -88,12 +82,20 @@ void PCF8574Component::pin_mode(uint8_t pin, gpio::Flags flags) {
 bool PCF8574Component::read_gpio_() {
   if (this->is_failed())
     return false;
-  uint8_t data[2]{};  // Keep the bytes zero for the PCF8574's one-byte read.
-  if (!this->read_bytes_raw(data, this->pcf8575_ ? 2 : 1)) {
+  bool success;
+  uint8_t data[2];
+  if (this->pcf8575_) {
+    success = this->read_bytes_raw(data, 2);
+    this->input_mask_ = (uint16_t(data[1]) << 8) | (uint16_t(data[0]) << 0);
+  } else {
+    success = this->read_bytes_raw(data, 1);
+    this->input_mask_ = data[0];
+  }
+
+  if (!success) {
     this->status_set_warning();
     return false;
   }
-  this->input_mask_ = (uint16_t(data[1]) << 8) | data[0];
   this->status_clear_warning();
   return true;
 }
@@ -121,11 +123,6 @@ bool PCF8574Component::write_gpio_() {
 float PCF8574Component::get_setup_priority() const { return setup_priority::IO; }
 
 void PCF8574GPIOPin::setup() { pin_mode(flags_); }
-void PCF8574GPIOPin::set_flags(gpio::Flags flags) {
-  this->flags_ = flags;
-  if (flags & gpio::FLAG_INPUT)
-    this->parent_->register_input_pin(this->pin_);
-}
 void PCF8574GPIOPin::pin_mode(gpio::Flags flags) { this->parent_->pin_mode(this->pin_, flags); }
 bool PCF8574GPIOPin::digital_read() { return this->parent_->digital_read(this->pin_) != this->inverted_; }
 void PCF8574GPIOPin::digital_write(bool value) { this->parent_->digital_write(this->pin_, value != this->inverted_); }

esphome/components/pcf8574/pcf8574.h

@@ -16,9 +16,6 @@ class PCF8574Component final : public Component,
   PCF8574Component() = default;
 
   void set_pcf8575(bool pcf8575) { pcf8575_ = pcf8575; }
-  void set_reset(bool reset) { this->reset_ = reset; }
-  // Called by pin setters before any component's setup or GPIO writes.
-  void register_input_pin(uint8_t pin) { this->configured_input_pins_ |= 1 << pin; }
   void set_interrupt_pin(InternalGPIOPin *pin) { this->interrupt_pin_ = pin; }
 
   /// Check i2c availability and setup masks
@@ -47,11 +44,6 @@ class PCF8574Component final : public Component,
   uint16_t output_mask_{0x00};
   /// The state read in read_gpio_ - 1 means HIGH, 0 means LOW
   uint16_t input_mask_{0x00};
-  // Pins configured as inputs before setup; 1 means input. With reset disabled, all other pins
-  // (including undeclared pins) are treated as outputs seeded from their observed levels.
-  uint16_t configured_input_pins_{0x00};
-  // Keep in sync with DEFAULT_RESET in __init__.py; codegen omits the setter for the default.
-  bool reset_{true};
   bool pcf8575_;  ///< TRUE->16-channel PCF8575, FALSE->8-channel PCF8574
   InternalGPIOPin *interrupt_pin_{nullptr};
 };
@@ -71,8 +63,7 @@ class PCF8574GPIOPin final : public GPIOPin {
   void set_parent(PCF8574Component *parent) { parent_ = parent; }
   void set_pin(uint8_t pin) { pin_ = pin; }
   void set_inverted(bool inverted) { inverted_ = inverted; }
-  // Call after set_parent() and set_pin(): input flags register the pin with the parent.
-  void set_flags(gpio::Flags flags);
+  void set_flags(gpio::Flags flags) { flags_ = flags; }
 
   gpio::Flags get_flags() const override { return this->flags_; }
 

esphome/components/qr_code/__init__.py

@@ -35,7 +35,7 @@ CONFIG_SCHEMA = cv.ensure_list(
 
 
 async def to_code(config: list[ConfigType]) -> None:
-    cg.add_library("wjtje/qr-code-generator-library", "1.7.0")
+    cg.add_library("wjtje/qr-code-generator-library", "^1.7.0")
 
     for entry in config:
         var = cg.new_Pvariable(entry[CONF_ID])

esphome/components/qspi_dbi/qspi_dbi.h

@@ -8,13 +8,12 @@
 #include "esphome/components/display/display.h"
 #include "esphome/components/display/display_buffer.h"
 #include "esphome/components/display/display_color_utils.h"
-#include "esphome/core/log.h"
 
 #include "esp_lcd_panel_rgb.h"
 
 namespace esphome::qspi_dbi {
 
-ESPHOME_LOG_TAG(TAG, "display.qspi_dbi");
+constexpr static const char *const TAG = "display.qspi_dbi";
 static const uint8_t SW_RESET_CMD = 0x01;
 static const uint8_t SLEEP_OUT = 0x11;
 static const uint8_t NORON = 0x13;

esphome/components/rpi_dpi_rgb/rpi_dpi_rgb.h

@@ -16,7 +16,7 @@
 
 namespace esphome::rpi_dpi_rgb {
 
-ESPHOME_LOG_TAG(TAG, "rpi_dpi_rgb");
+constexpr static const char *const TAG = "rpi_dpi_rgb";
 
 class RpiDpiRgb final : public display::Display {
  public:

esphome/components/rtttl/__init__.py

@@ -14,8 +14,6 @@ _LOGGER = logging.getLogger(__name__)
 CODEOWNERS = ["@glmnet", "@ximex"]
 DOMAIN = "rtttl"
 CONF_RTTTL = "rtttl"
-# The player keeps the song length in 16 bits
-MAX_SONG_LENGTH = 65535
 CONF_ON_FINISHED_PLAYBACK = "on_finished_playback"
 
 rtttl_ns = cg.esphome_ns.namespace("rtttl")
@@ -99,23 +97,16 @@ async def to_code(config: ConfigType) -> None:
         await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
 
 
-def _static_song(config: ConfigType, value: str) -> str:
-    # A constant song plays straight from static storage, flash on ESP8266, with no copy per play
-    return f"esphome::rtttl::StaticSong{{{cg.FlashStringLiteral(value)}}}"
-
-
 automation.register_apply_action(
     "rtttl.play",
     cv.maybe_simple_value(
         {
             cv.GenerateID(CONF_ID): cv.use_id(Rtttl),
-            cv.Required(CONF_RTTTL): cv.templatable(
-                cv.All(cv.string, cv.ByteLength(max=MAX_SONG_LENGTH))
-            ),
+            cv.Required(CONF_RTTTL): cv.templatable(cv.string),
         },
         key=CONF_RTTTL,
     ),
-    automation.ApplyField(CONF_RTTTL, "play", cg.std_string, const_fn=_static_song),
+    automation.ApplyField(CONF_RTTTL, "play", cg.std_string),
 )
 
 automation.register_apply_action(

esphome/components/rtttl/rtttl.cpp

@@ -1,8 +1,5 @@
 #include "rtttl.h"
-#include <algorithm>
 #include <cmath>
-#include <cstring>
-#include <limits>
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
 #include "esphome/core/progmem.h"
@@ -150,14 +147,14 @@ void Rtttl::loop() {
 #endif  // USE_SPEAKER
 
   // Align to note: most rtttl's out there does not add any space after the ',' separator but just in case
-  while (this->position_ < this->song_len_) {
-    char c = this->song_at_(this->position_);
+  while (this->position_ < this->rtttl_.length()) {
+    char c = this->rtttl_[this->position_];
     if (c != ',' && c != ' ')
       break;
     this->position_++;
   }
 
-  if (this->position_ >= this->song_len_) {
+  if (this->position_ >= this->rtttl_.length()) {
     this->finish_();
     return;
   }
@@ -172,12 +169,12 @@ void Rtttl::loop() {
     this->note_duration_ = this->wholenote_duration_ / this->default_note_denominator_;
   }
 
-  uint8_t note_index_in_octave = note_index_from_char(this->song_at_(this->position_));
+  uint8_t note_index_in_octave = note_index_from_char(this->rtttl_[this->position_]);
 
   this->position_++;
 
   // Now, get optional '#' sharp
-  if (this->song_at_(this->position_) == '#') {
+  if (this->rtttl_[this->position_] == '#') {
     note_index_in_octave++;
     this->position_++;
   }
@@ -195,7 +192,7 @@ void Rtttl::loop() {
   }
 
   // Now, get optional '.' dotted note
-  if (this->song_at_(this->position_) == '.') {
+  if (this->rtttl_[this->position_] == '.') {
     this->note_duration_ += this->note_duration_ / 2;  // Duration +50%
     this->position_++;
   }
@@ -267,68 +264,15 @@ void Rtttl::loop() {
 }
 
 void Rtttl::play(std::string rtttl) {
-  if (this->is_busy_()) {
+  if (this->state_ != State::STOPPED && this->state_ != State::STOPPING) {
+    size_t pos = this->rtttl_.find(':');
+    size_t len = (pos != std::string::npos) ? pos : this->rtttl_.length();
+    ESP_LOGW(TAG, "Already playing: %.*s", (int) len, this->rtttl_.c_str());
     return;
   }
-  this->owned_song_ = std::move(rtttl);
-  this->set_song_(this->owned_song_.data(), this->owned_song_.size());
-  this->start_();
-}
 
-void Rtttl::play(StaticSong song) {
-  if (this->is_busy_()) {
-    return;
-  }
-  // Release a previously owned song; the static one needs no storage.
-  std::string().swap(this->owned_song_);
-  const char *data = reinterpret_cast<const char *>(song.rtttl);
-  this->set_song_(data, ESPHOME_strlen_P(data));
-  this->start_();
-}
+  this->rtttl_ = std::move(rtttl);
 
-void Rtttl::set_song_(const char *song, size_t len) {
-  this->song_ = song;
-  // Anything past what the 16 bit length holds is dropped; the validator keeps configured songs shorter.
-  this->song_len_ = static_cast<uint16_t>(std::min<size_t>(len, std::numeric_limits<uint16_t>::max()));
-}
-
-bool Rtttl::is_busy_() const {
-  if (this->state_ == State::STOPPED || this->state_ == State::STOPPING) {
-    return false;
-  }
-  char name[SONG_NAME_LENGTH_LIMIT + 1];
-  this->song_name_(name, sizeof(name), this->song_find_(':', 0, this->song_len_));
-  ESP_LOGW(TAG, "Already playing: %s", name);
-  return true;
-}
-
-size_t Rtttl::song_find_(char c, size_t from, size_t end) const {
-  for (size_t pos = from; pos < end; pos++) {
-    if (this->song_at_(pos) == c)
-      return pos;
-  }
-  return end;
-}
-
-size_t Rtttl::song_find_control_(char key, size_t from, size_t end) const {
-  size_t pos = from;
-  while ((pos = this->song_find_(key, pos, end)) < end) {
-    if (this->song_at_(pos + 1) == '=')
-      return pos;
-    pos++;
-  }
-  return end;
-}
-
-void Rtttl::song_name_(char *buf, size_t size, size_t name_len) const {
-  size_t len = std::min(name_len, size - 1);
-  for (size_t pos = 0; pos < len; pos++) {
-    buf[pos] = this->song_at_(pos);
-  }
-  buf[len] = '\0';
-}
-
-void Rtttl::start_() {
   this->default_note_denominator_ = DEFAULT_NOTE_DENOMINATOR;
   this->default_octave_ = DEFAULT_OCTAVE;
   this->note_duration_ = 0;
@@ -337,9 +281,9 @@ void Rtttl::start_() {
   uint16_t num;  // Used for: default note-denominator, default octave, BPM
 
   // Get name
-  this->position_ = this->song_find_(':', 0, this->song_len_);
+  this->position_ = this->rtttl_.find(':');
 
-  if (this->position_ == this->song_len_) {
+  if (this->position_ == std::string::npos) {
     ESP_LOGE(TAG, "Unable to determine name; missing ':'");
     return;
   }
@@ -348,20 +292,18 @@ void Rtttl::start_() {
              static_cast<unsigned>(SONG_NAME_LENGTH_LIMIT));
     return;
   }
-  char name[SONG_NAME_LENGTH_LIMIT + 1];
-  this->song_name_(name, sizeof(name), this->position_);
-  ESP_LOGD(TAG, "Playing song %s", name);
+  ESP_LOGD(TAG, "Playing song %.*s", (int) this->position_, this->rtttl_.c_str());
 
   size_t name_end_position = this->position_;
-  size_t control_end = this->song_find_(':', name_end_position + 1, this->song_len_);
-  if (control_end == this->song_len_) {
+  size_t control_end = this->rtttl_.find(':', name_end_position + 1);
+  if (control_end == std::string::npos) {
     ESP_LOGE(TAG, "Missing second ':'");
     return;
   }
 
   // Get default duration
-  size_t pos = this->song_find_control_('d', name_end_position, control_end);
-  if (pos == control_end) {
+  size_t pos = this->rtttl_.find("d=", name_end_position);
+  if (pos == std::string::npos || pos >= control_end) {
     ESP_LOGW(TAG, "Missing 'd='; use default duration %d", this->default_note_denominator_);
   } else {
     this->position_ = pos + 2;
@@ -375,8 +317,8 @@ void Rtttl::start_() {
   }
 
   // Get default octave
-  pos = this->song_find_control_('o', name_end_position, control_end);
-  if (pos == control_end) {
+  pos = this->rtttl_.find("o=", name_end_position);
+  if (pos == std::string::npos || pos >= control_end) {
     ESP_LOGW(TAG, "Missing 'o='; use default octave %d", this->default_octave_);
   } else {
     this->position_ = pos + 2;
@@ -390,8 +332,8 @@ void Rtttl::start_() {
   }
 
   // Get BPM
-  pos = this->song_find_control_('b', name_end_position, control_end);
-  if (pos == control_end) {
+  pos = this->rtttl_.find("b=", name_end_position);
+  if (pos == std::string::npos || pos >= control_end) {
     ESP_LOGW(TAG, "Missing 'b='; use default BPM %d", bpm);
   } else {
     this->position_ = pos + 2;
@@ -445,7 +387,7 @@ void Rtttl::stop() {
   }
 #endif  // USE_SPEAKER
 
-  this->position_ = this->song_len_;
+  this->position_ = this->rtttl_.length();
   this->note_duration_ = 0;
 }
 
@@ -469,7 +411,7 @@ void Rtttl::finish_() {
 #endif  // USE_SPEAKER
 
   // Ensure no more notes are played in case finish_() is called for an error.
-  this->position_ = this->song_len_;
+  this->position_ = this->rtttl_.length();
   this->note_duration_ = 0;
 }
 

esphome/components/rtttl/rtttl.h

@@ -3,7 +3,6 @@
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/progmem.h"
 
 #ifdef USE_OUTPUT
 #include "esphome/components/output/float_output.h"
@@ -15,10 +14,6 @@
 
 namespace esphome::rtttl {
 
-namespace testing {
-class RtttlParserAccess;
-}  // namespace testing
-
 inline constexpr uint8_t DEFAULT_NOTE_DENOMINATOR = 4;  // Default note-denominator (quarter note)
 inline constexpr uint8_t DEFAULT_OCTAVE =
     6;  // Default octave for a note (see: `MIN_OCTAVE`, `MAX_OCTAVE` in `rtttl.cpp`)
@@ -31,11 +26,6 @@ enum class State : uint8_t {
   STOPPING,
 };
 
-/// A song in storage that outlives playback, such as a literal from generated code; PROGMEM on ESP8266.
-struct StaticSong {
-  ProgmemStr rtttl;
-};
-
 class Rtttl final : public Component {
  public:
 #ifdef USE_OUTPUT
@@ -48,10 +38,7 @@ class Rtttl final : public Component {
 
   void dump_config() override;
   void loop() override;
-  /// Play a song; the string is copied so it may come from anywhere.
   void play(std::string rtttl);
-  /// Play a song from static storage without copying it.
-  void play(StaticSong song);
   void stop();
 
   float get_gain() { return this->gain_; }
@@ -68,29 +55,11 @@ class Rtttl final : public Component {
  protected:
   inline uint16_t get_integer_() {
     uint16_t ret = 0;
-    while (isdigit(this->song_at_(this->position_))) {
-      ret = (ret * 10) + (this->song_at_(this->position_++) - '0');
+    while (isdigit(this->rtttl_[this->position_])) {
+      ret = (ret * 10) + (this->rtttl_[this->position_++] - '0');
     }
     return ret;
   }
-  /// The byte of the song at pos, or NUL past its end; the read is flash safe for a PROGMEM song on ESP8266.
-  char song_at_(size_t pos) const {
-    if (pos >= this->song_len_)
-      return '\0';
-    return static_cast<char>(progmem_read_byte(reinterpret_cast<const uint8_t *>(this->song_) + pos));
-  }
-  /// Index of the first `c` in [from, end), or `end` when absent.
-  size_t song_find_(char c, size_t from, size_t end) const;
-  /// Index of `key` followed by '=' in [from, end), or `end` when absent.
-  size_t song_find_control_(char key, size_t from, size_t end) const;
-  /// Copies the first name_len bytes of the song, its name, into buf for logging.
-  void song_name_(char *buf, size_t size, size_t name_len) const;
-  /// Points the view at a song, clamped to what song_len_ can hold.
-  void set_song_(const char *song, size_t len);
-  /// Parses the header and starts playback of the song the view points at.
-  void start_();
-  /// Logs and returns true when a song is still playing, so a new one must wait.
-  bool is_busy_() const;
   /**
    * @brief Finalizes the playback of the RTTTL string.
    *
@@ -101,30 +70,26 @@ class Rtttl final : public Component {
   void finish_();
   void set_state_(State state);
 
-  /// The song being played; points at owned_song_ or at static storage.
-  const char *song_{nullptr};
-  /// Backing store for play(std::string).
-  std::string owned_song_;
+  /// The RTTTL string to play.
+  std::string rtttl_;
+  /// The current position in the RTTTL string.
+  size_t position_{0};
+  /// The default duration of a note (e.g. 4 for a quarter note).
+  uint8_t default_note_denominator_{DEFAULT_NOTE_DENOMINATOR};
+  /// The default octave for a note.
+  uint8_t default_octave_{DEFAULT_OCTAVE};
+  /// The duration of the current note in milliseconds.
+  uint16_t note_duration_{0};
+  /// The duration of a whole note in milliseconds.
+  uint16_t wholenote_duration_;
+  /// The current state of the RTTTL player.
+  State state_{State::STOPPED};
   /// The time in milliseconds since microcontroller boot when the last note was started.
   uint32_t last_note_start_time_;
   /// The frequency of the current note in Hz.
   uint32_t output_freq_{0};
   /// The gain of the output.
   float gain_{0.6f};
-  /// Length of the song in bytes; songs are a few hundred bytes, so 16 bits is ample.
-  uint16_t song_len_{0};
-  /// The current position in the song.
-  uint16_t position_{0};
-  /// The duration of the current note in milliseconds.
-  uint16_t note_duration_{0};
-  /// The duration of a whole note in milliseconds.
-  uint16_t wholenote_duration_;
-  /// The default duration of a note (e.g. 4 for a quarter note).
-  uint8_t default_note_denominator_{DEFAULT_NOTE_DENOMINATOR};
-  /// The default octave for a note.
-  uint8_t default_octave_{DEFAULT_OCTAVE};
-  /// The current state of the RTTTL player.
-  State state_{State::STOPPED};
 
 #ifdef USE_OUTPUT
   /// The output to write the sound to.
@@ -148,8 +113,6 @@ class Rtttl final : public Component {
   /// The callback to call when playback is finished.
   CallbackManager<void()> on_finished_playback_callback_;
 #endif
-
-  friend class testing::RtttlParserAccess;
 };
 
 }  // namespace esphome::rtttl

esphome/components/runtime_image/__init__.py

@@ -115,7 +115,7 @@ class PNGFormat(Format):
 
     def actions(self) -> None:
         cg.add_define("USE_RUNTIME_IMAGE_PNG")
-        cg.add_library("kikuchan98/pngle", "1.1.0")
+        cg.add_library("pngle", "1.1.0")
 
 
 class QOIFormat(Format):

esphome/components/runtime_image/runtime_image.cpp

@@ -99,22 +99,6 @@ void RuntimeImage::draw_pixel(int x, int y, const Color &color) {
       }
       break;
     }
-    case image::IMAGE_TYPE_RGB111: {
-      uint8_t bits = (color.r >> 7) << 2 | (color.g >> 7) << 1 | (color.b >> 7);
-      if (this->bpp_ == 4)
-        bits = bits << 1 | (color.w >> 7);
-      const uint32_t stride = (this->buffer_width_ * this->bpp_ + 7u) / 8u;
-      const uint32_t bitpos = y * stride * 8 + x * this->bpp_;
-      uint8_t *byte = this->buffer_ + bitpos / 8;
-      // Place the pixel in a 16-bit window so it may straddle two bytes.
-      const uint8_t shift = 16 - this->bpp_ - bitpos % 8;
-      const uint16_t mask = ((1u << this->bpp_) - 1) << shift;
-      const uint16_t value = bits << shift;
-      byte[0] = (byte[0] & ~(mask >> 8)) | (value >> 8);
-      if (mask & 0xFF)
-        byte[1] = (byte[1] & ~(mask & 0xFF)) | (value & 0xFF);
-      break;
-    }
     case image::IMAGE_TYPE_GRAYSCALE: {
       uint32_t pos = this->get_position_(x, y);
       auto gray = static_cast<uint8_t>(0.2125 * color.r + 0.7154 * color.g + 0.0721 * color.b);

esphome/components/runtime_stats/runtime_stats.h

@@ -15,7 +15,7 @@ class Component;  // Forward declaration
 
 namespace runtime_stats {
 
-ESPHOME_LOG_TAG(TAG, "runtime_stats");
+static const char *const TAG = "runtime_stats";
 
 class RuntimeStatsCollector final {
  public:

esphome/components/script/script.h

@@ -295,11 +295,8 @@ template<class C, typename... Ts> class ScriptWaitAction final : public Action<T
   }
 
   void loop() override {
-    if (this->num_running_ == 0) {
-      // Nothing left to wait for, e.g. once the last queued item has run
-      this->disable_loop();
+    if (this->num_running_ == 0)
       return;
-    }
 
     if (this->script_->is_running())
       return;
@@ -308,10 +305,9 @@ template<class C, typename... Ts> class ScriptWaitAction final : public Action<T
     // Processing all items in a while loop causes infinite loops because
     // play_next_() can trigger more items to be queued
     if (!this->param_queue_.empty()) {
-      // Take the item out first: the chain may call stop(), which clears the queue
-      auto params = std::move(this->param_queue_.front());
-      this->param_queue_.pop_front();
+      auto &params = this->param_queue_.front();
       std::apply([this](auto &...args) { this->play_next_(args...); }, params);
+      this->param_queue_.pop_front();
     } else {
       // Queue is now empty - disable loop until next play_complex
       this->disable_loop();

esphome/components/sdl/sdl_esphome.h

@@ -13,7 +13,7 @@
 
 namespace esphome::sdl {
 
-ESPHOME_LOG_TAG(TAG, "sdl");
+constexpr static const char *const TAG = "sdl";
 
 class Sdl final : public display::Display, public snapshot::Snapshot {
  public:

esphome/components/spi_led_strip/spi_led_strip.h

@@ -7,7 +7,7 @@
 
 namespace esphome::spi_led_strip {
 
-ESPHOME_LOG_TAG(TAG, "spi_led_strip");
+static const char *const TAG = "spi_led_strip";
 class SpiLedStrip final : public light::AddressableLight,
                           public spi::SPIDevice<spi::BIT_ORDER_MSB_FIRST, spi::CLOCK_POLARITY_HIGH,
                                                 spi::CLOCK_PHASE_TRAILING, spi::DATA_RATE_1MHZ> {

esphome/components/st7701s/st7701s.h

@@ -8,14 +8,13 @@
 #include "esphome/core/component.h"
 #include "esphome/components/spi/spi.h"
 #include "esphome/components/display/display.h"
-#include "esphome/core/log.h"
 #include "esp_lcd_panel_ops.h"
 
 #include "esp_lcd_panel_rgb.h"
 
 namespace esphome::st7701s {
 
-ESPHOME_LOG_TAG(TAG, "display.st7701s");
+constexpr static const char *const TAG = "display.st7701s";
 const uint8_t SW_RESET_CMD = 0x01;
 const uint8_t SLEEP_OUT = 0x11;
 const uint8_t SDIR_CMD = 0xC7;

esphome/components/syslog/esphome_syslog.cpp

@@ -2,13 +2,12 @@
 
 #include "esphome/components/logger/logger.h"
 #include "esphome/core/application.h"
-#include "esphome/core/hal.h"
 #include "esphome/core/time.h"
 
 namespace esphome::syslog {
 
 // Map log levels to syslog severity using an array, indexed by ESPHome log level (1-7)
-static constexpr uint8_t LOG_LEVEL_TO_SYSLOG_SEVERITY[] PROGMEM = {
+constexpr int LOG_LEVEL_TO_SYSLOG_SEVERITY[] = {
     3,  // NONE
     3,  // ERROR
     4,  // WARN
@@ -36,7 +35,7 @@ void Syslog::log_(const int level, const char *tag, const char *message, size_t
   // Syslog PRI calculation: facility * 8 + severity
   int severity = 7;
   if ((unsigned) level <= 7) {
-    severity = progmem_read_byte(&LOG_LEVEL_TO_SYSLOG_SEVERITY[level]);
+    severity = LOG_LEVEL_TO_SYSLOG_SEVERITY[level];
   }
   int pri = this->facility_ * 8 + severity;
 

esphome/components/thermostat/climate.py

@@ -240,6 +240,12 @@ def validate_thermostat(config: ConfigType) -> ConfigType:
             CONF_SUPPLEMENTAL_HEATING_ACTION,
             CONF_SUPPLEMENTAL_HEATING_DELTA,
         ],
+        CONF_MIN_COOLING_OFF_TIME: [
+            CONF_COOL_ACTION,
+        ],
+        CONF_MIN_COOLING_RUN_TIME: [
+            CONF_COOL_ACTION,
+        ],
         CONF_MIN_FANNING_OFF_TIME: [
             CONF_FAN_ONLY_ACTION,
         ],
@@ -278,17 +284,6 @@ def validate_thermostat(config: ConfigType) -> ConfigType:
                     f"{req_trigger} must be defined to use {config_trigger}"
                 )
 
-    # Dry mode runs on the cooling timers, so a dehumidifier needs no cool_action.
-    for timer in (CONF_MIN_COOLING_OFF_TIME, CONF_MIN_COOLING_RUN_TIME):
-        if (
-            timer in config
-            and CONF_COOL_ACTION not in config
-            and CONF_DRY_ACTION not in config
-        ):
-            raise cv.Invalid(
-                f"{CONF_COOL_ACTION} or {CONF_DRY_ACTION} must be defined to use {timer}"
-            )
-
     if CONF_FAN_ONLY_ACTION in config:
         # determine validation requirements based on fan_only_action_uses_fan_mode_timer setting
         if config[CONF_FAN_ONLY_ACTION_USES_FAN_MODE_TIMER] is True:

esphome/components/tmc2209/__init__.py

@@ -1,54 +1,10 @@
-from esphome import automation
 import esphome.codegen as cg
 from esphome.components import tmc22xx
-import esphome.config_validation as cv
-from esphome.const import CONF_THRESHOLD
 
 CODEOWNERS = ["@remcom"]
 DOMAIN = "tmc2209"
 
-CONF_SEDN = "sedn"
-CONF_SEIMIN = "seimin"
-CONF_SEMAX = "semax"
-CONF_SEMIN = "semin"
-CONF_SEUP = "seup"
-CONF_TCOOL_THRESHOLD = "tcool_threshold"
-
 tmc2209_ns = cg.esphome_ns.namespace("tmc2209")
 TMC2209Stepper = tmc2209_ns.class_("TMC2209Stepper", tmc22xx.TMC22XXStepper)
 
 tmc22xx.register_actions("tmc2209", TMC2209Stepper)
-
-automation.register_apply_action(
-    "tmc2209.stallguard",
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.use_id(TMC2209Stepper),
-            cv.Optional(CONF_THRESHOLD): cv.templatable(cv.uint8_t),
-            cv.Optional(CONF_TCOOL_THRESHOLD): cv.templatable(
-                cv.int_range(0, 2**20 - 1)
-            ),
-        }
-    ),
-    automation.ApplyField(CONF_THRESHOLD, "set_stallguard_threshold", cg.uint8),
-    automation.ApplyField(CONF_TCOOL_THRESHOLD, "set_tcool_threshold", cg.uint32),
-)
-
-automation.register_apply_action(
-    "tmc2209.coolconf",
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.use_id(TMC2209Stepper),
-            cv.Optional(CONF_SEMIN): cv.templatable(cv.int_range(0, 15)),
-            cv.Optional(CONF_SEMAX): cv.templatable(cv.int_range(0, 15)),
-            cv.Optional(CONF_SEUP): cv.templatable(cv.int_range(0, 3)),
-            cv.Optional(CONF_SEDN): cv.templatable(cv.int_range(0, 3)),
-            cv.Optional(CONF_SEIMIN): cv.templatable(cv.boolean),
-        }
-    ),
-    automation.ApplyField(CONF_SEMIN, "set_semin", cg.uint8),
-    automation.ApplyField(CONF_SEMAX, "set_semax", cg.uint8),
-    automation.ApplyField(CONF_SEUP, "set_seup", cg.uint8),
-    automation.ApplyField(CONF_SEDN, "set_sedn", cg.uint8),
-    automation.ApplyField(CONF_SEIMIN, "set_seimin", cg.bool_),
-)

esphome/components/tmc2209/sensor/__init__.py

@@ -1,87 +0,0 @@
-import esphome.codegen as cg
-from esphome.components import sensor
-from esphome.components.tmc22xx import CONF_ANALOG_CURRENT_SCALE
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ID,
-    DEVICE_CLASS_CURRENT,
-    ENTITY_CATEGORY_DIAGNOSTIC,
-    STATE_CLASS_MEASUREMENT,
-    UNIT_AMPERE,
-    UNIT_PERCENT,
-)
-import esphome.final_validate as fv
-from esphome.types import ConfigType
-
-from .. import TMC2209Stepper, tmc2209_ns
-
-CONF_ACTUAL_CURRENT = "actual_current"
-CONF_MOTOR_LOAD = "motor_load"
-CONF_PWM_GRAD_AUTO = "pwm_grad_auto"
-CONF_PWM_OFS_AUTO = "pwm_ofs_auto"
-CONF_PWM_SCALE_AUTO = "pwm_scale_auto"
-CONF_PWM_SCALE_SUM = "pwm_scale_sum"
-CONF_STALLGUARD_RESULT = "stallguard_result"
-CONF_TMC2209_ID = "tmc2209_id"
-
-TMC2209Sensor = tmc2209_ns.class_("TMC2209Sensor", cg.PollingComponent)
-
-_diagnostic_schema = sensor.sensor_schema(
-    accuracy_decimals=0,
-    state_class=STATE_CLASS_MEASUREMENT,
-    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-)
-
-CONFIG_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(): cv.declare_id(TMC2209Sensor),
-        cv.GenerateID(CONF_TMC2209_ID): cv.use_id(TMC2209Stepper),
-        cv.Optional(CONF_ACTUAL_CURRENT): sensor.sensor_schema(
-            unit_of_measurement=UNIT_AMPERE,
-            accuracy_decimals=2,
-            device_class=DEVICE_CLASS_CURRENT,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(CONF_MOTOR_LOAD): sensor.sensor_schema(
-            unit_of_measurement=UNIT_PERCENT,
-            accuracy_decimals=0,
-            state_class=STATE_CLASS_MEASUREMENT,
-        ),
-        cv.Optional(CONF_STALLGUARD_RESULT): _diagnostic_schema,
-        cv.Optional(CONF_PWM_SCALE_SUM): _diagnostic_schema,
-        cv.Optional(CONF_PWM_SCALE_AUTO): _diagnostic_schema,
-        cv.Optional(CONF_PWM_OFS_AUTO): _diagnostic_schema,
-        cv.Optional(CONF_PWM_GRAD_AUTO): _diagnostic_schema,
-    }
-).extend(cv.polling_component_schema("60s"))
-
-
-def _final_validate(config: ConfigType) -> ConfigType:
-    if CONF_ACTUAL_CURRENT not in config:
-        return config
-    full_config = fv.full_config.get()
-    path = full_config.get_path_for_id(config[CONF_TMC2209_ID])[:-1]
-    if full_config.get_config_for_path(path).get(CONF_ANALOG_CURRENT_SCALE):
-        raise cv.Invalid(
-            f"'{CONF_ACTUAL_CURRENT}' can't be used with '{CONF_ANALOG_CURRENT_SCALE}', "
-            "the current then depends on VREF",
-            path=[CONF_ACTUAL_CURRENT],
-        )
-    return config
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
-async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_TMC2209_ID])
-    var = cg.new_Pvariable(config[CONF_ID], hub)
-    await cg.register_component(var, config)
-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_ACTUAL_CURRENT, var.set_actual_current_sensor)
-    await sensors(CONF_STALLGUARD_RESULT, var.set_stallguard_result_sensor)
-    await sensors(CONF_MOTOR_LOAD, var.set_motor_load_sensor)
-    await sensors(CONF_PWM_SCALE_SUM, var.set_pwm_scale_sum_sensor)
-    await sensors(CONF_PWM_SCALE_AUTO, var.set_pwm_scale_auto_sensor)
-    await sensors(CONF_PWM_OFS_AUTO, var.set_pwm_ofs_auto_sensor)
-    await sensors(CONF_PWM_GRAD_AUTO, var.set_pwm_grad_auto_sensor)

esphome/components/tmc2209/sensor/tmc2209_sensor.cpp

@@ -1,95 +0,0 @@
-#include "tmc2209_sensor.h"
-#include "esphome/core/log.h"
-
-#include <cmath>
-
-namespace esphome::tmc2209 {
-
-ESPHOME_LOG_TAG(TAG, "tmc2209.sensor");
-
-using tmc22xx::TMC22XXStepper;
-
-// Highest StallGuard result, reached with no load
-static constexpr float STALLGUARD_RESULT_MAX = 510.0f;
-
-static void publish_field(sensor::Sensor *sensor, const optional<uint32_t> &data, const RegisterField &field) {
-  if (sensor == nullptr)
-    return;
-  if (!data.has_value()) {
-    sensor->publish_state(NAN);
-    return;
-  }
-  uint32_t value = TMC22XXStepper::extract_field(*data, field);
-  sensor->publish_state(field.is_signed ? static_cast<float>(static_cast<int32_t>(value)) : static_cast<float>(value));
-}
-
-void TMC2209Sensor::update() {
-  if (this->parent_->is_failed())
-    return;
-
-  // Each failed read blocks the loop for the UART timeout. Leave the bus alone while the driver is known to be
-  // unreachable or after the first failed read; the remaining sensors then publish NaN.
-  bool reachable = !this->parent_->is_unreachable();
-  auto read = [this, &reachable](uint8_t reg) -> optional<uint32_t> {
-    if (!reachable)
-      return {};
-    auto data = this->parent_->read_register(reg);
-    reachable = data.has_value();
-    return data;
-  };
-
-  if (this->actual_current_sensor_ != nullptr) {
-    auto drv_status = read(tmc22xx::REG_DRV_STATUS);
-    float current = NAN;
-    if (drv_status.has_value()) {
-      auto scale = static_cast<uint8_t>(TMC22XXStepper::extract_field(*drv_status, tmc22xx::CS_ACTUAL));
-      current = this->parent_->scale_to_current(scale);
-    }
-    this->actual_current_sensor_->publish_state(current);
-  }
-
-  // StallGuard only measures the load while the motor turns
-  bool moving = !this->parent_->has_reached_target();
-  if (this->stallguard_result_sensor_ != nullptr || (this->motor_load_sensor_ != nullptr && moving)) {
-    auto sg_result = read(REG_SG_RESULT);
-    publish_field(this->stallguard_result_sensor_, sg_result, SG_RESULT);
-    if (this->motor_load_sensor_ != nullptr) {
-      // 100% is the load at which a stall is reported, where the result drops below twice the threshold
-      float stall_result = 2.0f * this->parent_->get_stallguard_threshold();
-      float load = NAN;
-      if (moving && sg_result.has_value() && stall_result < STALLGUARD_RESULT_MAX) {
-        float result = TMC22XXStepper::extract_field(*sg_result, SG_RESULT);
-        load = (STALLGUARD_RESULT_MAX - result) / (STALLGUARD_RESULT_MAX - stall_result) * 100.0f;
-      }
-      this->motor_load_sensor_->publish_state(load);
-    }
-  } else if (this->motor_load_sensor_ != nullptr) {
-    this->motor_load_sensor_->publish_state(NAN);
-  }
-
-  if (this->pwm_scale_sum_sensor_ != nullptr || this->pwm_scale_auto_sensor_ != nullptr) {
-    auto pwm_scale = read(tmc22xx::REG_PWM_SCALE);
-    publish_field(this->pwm_scale_sum_sensor_, pwm_scale, tmc22xx::PWM_SCALE_SUM);
-    publish_field(this->pwm_scale_auto_sensor_, pwm_scale, tmc22xx::PWM_SCALE_AUTO);
-  }
-
-  if (this->pwm_ofs_auto_sensor_ != nullptr || this->pwm_grad_auto_sensor_ != nullptr) {
-    auto pwm_auto = read(tmc22xx::REG_PWM_AUTO);
-    publish_field(this->pwm_ofs_auto_sensor_, pwm_auto, tmc22xx::PWM_OFS_AUTO);
-    publish_field(this->pwm_grad_auto_sensor_, pwm_auto, tmc22xx::PWM_GRAD_AUTO);
-  }
-}
-
-void TMC2209Sensor::dump_config() {
-  ESP_LOGCONFIG(TAG, "TMC2209 Sensor:");
-  LOG_UPDATE_INTERVAL(this);
-  LOG_SENSOR("  ", "Actual Current", this->actual_current_sensor_);
-  LOG_SENSOR("  ", "StallGuard Result", this->stallguard_result_sensor_);
-  LOG_SENSOR("  ", "Motor Load", this->motor_load_sensor_);
-  LOG_SENSOR("  ", "PWM Scale Sum", this->pwm_scale_sum_sensor_);
-  LOG_SENSOR("  ", "PWM Scale Auto", this->pwm_scale_auto_sensor_);
-  LOG_SENSOR("  ", "PWM Offset Auto", this->pwm_ofs_auto_sensor_);
-  LOG_SENSOR("  ", "PWM Gradient Auto", this->pwm_grad_auto_sensor_);
-}
-
-}  // namespace esphome::tmc2209

esphome/components/tmc2209/sensor/tmc2209_sensor.h

@@ -1,35 +0,0 @@
-#pragma once
-
-#include "esphome/components/sensor/sensor.h"
-#include "esphome/components/tmc2209/tmc2209.h"
-#include "esphome/core/component.h"
-
-namespace esphome::tmc2209 {
-
-class TMC2209Sensor : public PollingComponent {
- public:
-  explicit TMC2209Sensor(TMC2209Stepper *parent) : parent_(parent) {}
-
-  void update() override;
-  void dump_config() override;
-
-  void set_actual_current_sensor(sensor::Sensor *sensor) { this->actual_current_sensor_ = sensor; }
-  void set_stallguard_result_sensor(sensor::Sensor *sensor) { this->stallguard_result_sensor_ = sensor; }
-  void set_motor_load_sensor(sensor::Sensor *sensor) { this->motor_load_sensor_ = sensor; }
-  void set_pwm_scale_sum_sensor(sensor::Sensor *sensor) { this->pwm_scale_sum_sensor_ = sensor; }
-  void set_pwm_scale_auto_sensor(sensor::Sensor *sensor) { this->pwm_scale_auto_sensor_ = sensor; }
-  void set_pwm_ofs_auto_sensor(sensor::Sensor *sensor) { this->pwm_ofs_auto_sensor_ = sensor; }
-  void set_pwm_grad_auto_sensor(sensor::Sensor *sensor) { this->pwm_grad_auto_sensor_ = sensor; }
-
- protected:
-  TMC2209Stepper *parent_;
-  sensor::Sensor *actual_current_sensor_{nullptr};
-  sensor::Sensor *stallguard_result_sensor_{nullptr};
-  sensor::Sensor *motor_load_sensor_{nullptr};
-  sensor::Sensor *pwm_scale_sum_sensor_{nullptr};
-  sensor::Sensor *pwm_scale_auto_sensor_{nullptr};
-  sensor::Sensor *pwm_ofs_auto_sensor_{nullptr};
-  sensor::Sensor *pwm_grad_auto_sensor_{nullptr};
-};
-
-}  // namespace esphome::tmc2209

esphome/components/tmc2209/stepper.py

@@ -1,6 +1,4 @@
-from esphome import automation
 from esphome.components import tmc22xx
-import esphome.config_validation as cv
 from esphome.types import ConfigType
 
 from . import TMC2209Stepper
@@ -8,31 +6,9 @@ from . import TMC2209Stepper
 AUTO_LOAD = ["tmc22xx"]
 DEPENDENCIES = ["uart"]
 
-CONF_ON_STALL = "on_stall"
-
-
-def _validate_stall_needs_diag(config: ConfigType) -> ConfigType:
-    if CONF_ON_STALL in config and tmc22xx.CONF_DIAG_PIN not in config:
-        raise cv.Invalid(
-            f"'{CONF_ON_STALL}' requires '{tmc22xx.CONF_DIAG_PIN}', stalls are only reported on DIAG"
-        )
-    return config
-
-
-CONFIG_SCHEMA = cv.All(
-    tmc22xx.tmc22xx_schema(
-        TMC2209Stepper,
-        max_address=3,
-        extra={cv.Optional(CONF_ON_STALL): automation.validate_automation({})},
-    ),
-    _validate_stall_needs_diag,
-)
+CONFIG_SCHEMA = tmc22xx.tmc22xx_schema(TMC2209Stepper, max_address=3)
 FINAL_VALIDATE_SCHEMA = tmc22xx.final_validate
 
 
 async def to_code(config: ConfigType) -> None:
-    var = await tmc22xx.new_tmc22xx(config)
-    for conf in config.get(CONF_ON_STALL, []):
-        await automation.build_callback_automation(
-            var, "add_on_stall_callback", [], conf
-        )
+    await tmc22xx.new_tmc22xx(config)