Keep the ESP8266 short string encode on the shared progmem copy

Keep the RAM short string encode on memcpy and drop unused ProgmemStringRef helpers
Fold dev's ProgmemStringRef struct into the class
2026-10-14 18:22:48 +00:00 · 2026-10-12 16:53:23 -10:00 · 2026-10-12 16:47:08 -10:00 · 2026-10-12 16:28:37 -10:00 · 2026-10-12 16:02:23 -10:00 · 2026-10-11 15:26:13 -10:00
350 changed files with 1062 additions and 14055 deletions
@@ -32,7 +32,7 @@ runs:
      # detects the activated venv via ``VIRTUAL_ENV`` so the venv layout
      # downstream jobs rely on is preserved.
      if: steps.cache-venv.outputs.cache-hit != 'true'
-      uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+      uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
      with:
        enable-cache: true
        # Pull request saves land in per-PR scopes nothing else can
@@ -29,7 +29,7 @@ jobs:
      - name: Set up uv
        # ``--system`` (below) installs into the setup-python interpreter;
        # no venv is created or restored by this workflow.
-        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
        with:
          enable-cache: true
          # Pull-request-only workflow: a save could never be shared and
@@ -97,7 +97,7 @@ jobs:
        run: git diff
      - if: failure()
        name: Archive artifacts
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: generated-proto-files
          path: |
@@ -128,7 +128,7 @@ jobs:

      - name: Upload compile-test image artifact
        if: matrix.os == 'ubuntu-24.04' && matrix.build_type == 'docker'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          # The tar is already compressed, so upload it as-is. archive: false
          # skips the redundant zip and makes the file name the artifact name
@@ -210,7 +210,7 @@ jobs:
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
      - name: Download image artifact
-        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
        with:
          name: compile-test-image.tar.zst
      - name: Load image
@@ -49,7 +49,7 @@ jobs:
        # detects the activated venv via ``VIRTUAL_ENV`` so downstream jobs
        # that ``. venv/bin/activate`` see an identical layout.
        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -438,7 +438,7 @@ jobs:
      - name: Set up uv
        # Only needed on cache miss to populate the venv.
        if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -477,7 +477,7 @@ jobs:
        # Tests that compare rendered output write the image they actually got here, so a
        # failure can be looked at without reproducing the whole build locally.
        if: failure()
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: integration-test-artifacts-${{ matrix.bucket.name }}
          path: test_artifacts/
@@ -488,7 +488,7 @@ jobs:
        # script/update_integration_test_durations.py; only full matrix dev
        # runs produce usable data.
        if: github.ref == 'refs/heads/dev' && needs.determine-jobs.outputs.integration-run-all == 'true'
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: junit-integration-${{ strategy.job-index }}
          path: junit-integration.xml
@@ -528,7 +528,7 @@ jobs:
          script/check_import_time.py --check --har importtime.har
      - name: Upload waterfall HAR
        if: always()
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: import-time-waterfall
          path: importtime.har
@@ -626,7 +626,7 @@ jobs:
            apt-get install -y libc6-dbg

      - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@f842b9a3ffe213dbb81768fd7f7eeb4dfcf1c369 # v5.4.2
+        uses: CodSpeedHQ/action@c4fd08a3a159bd0cc208da1e0edf32b8c47d75e5 # v5.4.0
        with:
          run: |
            . venv/bin/activate
@@ -1448,7 +1448,7 @@ jobs:
        # install step (order-of-magnitude faster on cold boots,
        # with its own wheel cache). actions/setup-python still
        # provides the interpreter.
-        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
        with:
          enable-cache: true
          # Pull request saves land in per-PR scopes nothing else can
@@ -1647,7 +1647,7 @@ jobs:
          fi

      - name: Upload memory analysis JSON
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: memory-analysis-target
          path: memory-analysis-target.json
@@ -1710,7 +1710,7 @@ jobs:
            --platform "$platform"

      - name: Upload memory analysis JSON
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: memory-analysis-pr
          path: memory-analysis-pr.json
@@ -1740,13 +1740,13 @@ jobs:
          python-version: ${{ env.DEFAULT_PYTHON }}
          cache-key: ${{ needs.common.outputs.cache-key }}
      - name: Download target analysis JSON
-        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
        with:
          name: memory-analysis-target
          path: ./memory-analysis
        continue-on-error: true
      - name: Download PR analysis JSON
-        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
        with:
          name: memory-analysis-pr
          path: ./memory-analysis
@@ -56,7 +56,7 @@ jobs:

      # Initializes the CodeQL tools for scanning.
      - name: Initialize CodeQL
-        uses: github/codeql-action/init@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
+        uses: github/codeql-action/init@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
        with:
          languages: ${{ matrix.language }}
          build-mode: ${{ matrix.build-mode }}
@@ -84,6 +84,6 @@ jobs:
          exit 1

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@24c54180a607b1449ed407dd24f251e4e9147c8d # v4.38.3
+        uses: github/codeql-action/analyze@2892aa5e19bbd11bc0cff5427e3b750a04d9e3c2 # v4.38.2
        with:
          category: "/language:${{matrix.language}}"
@@ -162,7 +162,7 @@ jobs:
      #     version: ${{ needs.init.outputs.tag }}

      - name: Upload digests
-        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
        with:
          name: digests-${{ matrix.platform.arch }}
          path: /tmp/digests
@@ -195,7 +195,7 @@ jobs:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1

      - name: Download digests
-        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
        with:
          pattern: digests-*
          path: /tmp/digests
@@ -47,7 +47,7 @@ jobs:
        # setup-python interpreter so subsequent ``prek`` /
        # ``script/run-in-env.py`` steps find the deps without a
        # ``uv run`` prefix.
-        uses: astral-sh/setup-uv@1c37ad07a6a961277cf70c0d37d6f313000f5884 # v10.3.0
+        uses: astral-sh/setup-uv@c18668ad3cf93ea998bef934396af7bb5c839dc7 # v10.2.0
        with:
          enable-cache: true
          # Pin uv version so the action does not have to fetch the
@@ -10,7 +10,7 @@ ci:
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    # Ruff version.
-    rev: v0.17.0
+    rev: v0.16.10
    hooks:
      # Run the linter.
      - id: ruff
@@ -36,7 +36,7 @@ repos:
      - id: end-of-file-fixer
      - id: trailing-whitespace
  - repo: https://github.com/asottile/pyupgrade
-    rev: v3.22.0
+    rev: v3.21.2
    hooks:
      - id: pyupgrade
        args: [--py312-plus]
@@ -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/
@@ -106,7 +106,6 @@ esphome/components/bp1658cj/* @Cossid
 esphome/components/bp5758d/* @Cossid
 esphome/components/bq25186/* @Rapsssito
 esphome/components/bq27220/* @rggammon
-esphome/components/bq76972/* @limpkin
 esphome/components/bridge/* @kbx81
 esphome/components/bthome_mithermometer/* @nagyrobi
 esphome/components/button/* @esphome/core
@@ -212,10 +211,8 @@ 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
 esphome/components/fs3000/* @kahrendt
 esphome/components/ft5x06/* @clydebarrow
 esphome/components/ft63x6/* @gpambrozio
@@ -243,9 +240,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 +284,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 +432,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
@@ -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 "
@@ -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))
@@ -251,9 +251,6 @@ def _validate_supports_response(value: Any) -> str:
    return cv.enum(SUPPORTS_RESPONSE_OPTIONS, lower=True)(value)


-# ESP8266 copies every string of an action into a stack buffer sized by codegen; keep it small
-ESP8266_ACTION_STRINGS_MAX_TOTAL = 384
-
 VARIABLE_SCHEMA = cv.Schema(
    {
        cv.Required(CONF_TYPE): cv.one_of(*SERVICE_ARG_NATIVE_TYPES, lower=True),
@@ -484,29 +481,6 @@ def _action_strings(conf: ConfigType, has_metadata: bool) -> list[str | None]:
    return strings


-def _action_strings_size(strings: list[str | None]) -> int:
-    """Bytes needed to copy every string out of flash, each with its terminator."""
-    return sum(
-        len(string.encode("utf-8")) + 1 for string in strings if string is not None
-    )
-
-
-def _validate_esp8266_action_strings(config: ConfigType) -> ConfigType:
-    if not CORE.is_esp8266:
-        return config
-    actions = config.get(CONF_ACTIONS, [])
-    has_metadata = _has_action_metadata(actions)
-    for conf in actions:
-        size = _action_strings_size(_action_strings(conf, has_metadata))
-        if size > ESP8266_ACTION_STRINGS_MAX_TOTAL:
-            raise cv.Invalid(
-                f"Action '{conf[CONF_ACTION]}' has {size} bytes of name, variable name, "
-                f"description and example text; ESP8266 allows at most "
-                f"{ESP8266_ACTION_STRINGS_MAX_TOTAL} bytes per action"
-            )
-    return config
-
-
 def _validate_outgoing_host_ipv6(config: ConfigType) -> ConfigType:
    """An IPv6 host can never be parsed, so never dialed, without IPv6."""
    if (
@@ -531,7 +505,6 @@ def _validate_wizard(config: ConfigType) -> ConfigType:


 FINAL_VALIDATE_SCHEMA = cv.All(
-    _validate_esp8266_action_strings,
    _validate_outgoing_host_ipv6,
    _validate_wizard,
 )
@@ -587,7 +560,6 @@ async def to_code(config: ConfigType) -> None:
    if config[CONF_HOMEASSISTANT_STATES]:
        cg.add_define("USE_API_HOMEASSISTANT_STATES")

-    scratch_size = 0
    if actions:
        # Metadata is compiled in for every action once any action declares it, because the
        # string table layout is fixed by the define rather than per action
@@ -639,8 +611,6 @@ async def to_code(config: ConfigType) -> None:
                func_args.append((native, name))
            strings = _action_strings(conf, has_metadata)
            table = _add_action_strings(index, strings)
-            if CORE.is_esp8266:
-                scratch_size = max(scratch_size, _action_strings_size(strings))
            # Template args: supports_response mode, then user service arg types
            templ = cg.TemplateArguments(supports_response, *service_template_args)
            # Key is hashed here because the name is not readable at runtime on ESP8266
@@ -667,9 +637,6 @@ async def to_code(config: ConfigType) -> None:
                cg.add(auto.add_action(unregister_action))
        # Register all services at once - single allocation, no reallocations
        cg.add(var.initialize_user_services(triggers))
-    if CORE.is_esp8266 and has_user_actions:
-        # Stack buffer that list-entities copies PROGMEM strings into, sized for the largest action
-        cg.add_define("API_USER_ACTION_STRINGS_SCRATCH_SIZE", max(scratch_size, 1))

    if (wizard_config := config.get(wizard.CONF_WIZARD)) is not None:
        await wizard.to_code(wizard_config)
@@ -1157,21 +1157,21 @@ enum SupportsResponseType {
 }
 message ListEntitiesServicesArgument {
  option (ifdef) = "USE_API_USER_DEFINED_ACTIONS";
-  string name = 1;
+  string name = 1 [(progmem) = true];
  ServiceArgType type = 2;
-  string description = 3 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA"];
-  string example = 4 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA"];
+  string description = 3 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA", (progmem) = true];
+  string example = 4 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA", (progmem) = true];
 }
 message ListEntitiesServicesResponse {
  option (id) = 41;
  option (source) = SOURCE_SERVER;
  option (ifdef) = "USE_API_USER_DEFINED_ACTIONS";

-  string name = 1;
+  string name = 1 [(progmem) = true];
  fixed32 key = 2 [(force) = true];
  repeated ListEntitiesServicesArgument args = 3 [(fixed_vector) = true];
  SupportsResponseType supports_response = 4;
-  string description = 5 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA"];
+  string description = 5 [(field_ifdef) = "USE_API_USER_DEFINED_ACTION_METADATA", (progmem) = true];
 }
 message ExecuteServiceArgument {
  option (ifdef) = "USE_API_USER_DEFINED_ACTIONS";
@@ -123,7 +123,7 @@ extend google.protobuf.FieldOptions {
    // from an absent one (e.g. a UTC ParsedTimezone, which is all zeros).
    optional bool track_presence = 50020 [default=false];

-    // progmem: The pointer_to_buffer bytes field points into flash (PROGMEM).
+    // progmem: The string field, or pointer_to_buffer bytes field, points into flash (PROGMEM).
    // The generated encode and dump copy it with progmem_memcpy, as ESP8266
    // cannot read flash with ordinary loads.
    optional bool progmem = 50021 [default=false];
@@ -1324,13 +1324,13 @@ void GetTimeResponse::decode_field(void *self, uint32_t tag, const uint8_t *data
 uint8_t *ListEntitiesServicesArgument::encode_msg(const void *self,
                                                  uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
  const auto &msg = *static_cast<const ListEntitiesServicesArgument *>(self);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.name);
+  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.name);
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 2, static_cast<uint32_t>(msg.type));
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.description);
+  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 3, msg.description);
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.example);
+  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 4, msg.example);
 #endif
  return pos;
 }
@@ -1350,14 +1350,14 @@ uint32_t ListEntitiesServicesArgument::calc_size_msg(const void *self) {
 uint8_t *ListEntitiesServicesResponse::encode_msg(const void *self,
                                                  uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM) {
  const auto &msg = *static_cast<const ListEntitiesServicesResponse *>(self);
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.name);
+  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 1, msg.name);
  pos = ProtoEncode::write_tag_and_fixed32(pos PROTO_ENCODE_DEBUG_ARG, 21, msg.key);
  for (auto &it : msg.args) {
    pos = ProtoEncode::encode_sub_message(pos PROTO_ENCODE_DEBUG_ARG, 3, it);
  }
  pos = ProtoEncode::encode_uint32(pos PROTO_ENCODE_DEBUG_ARG, 4, static_cast<uint32_t>(msg.supports_response));
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  pos = ProtoEncode::encode_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.description);
+  pos = ProtoEncode::encode_progmem_string(pos PROTO_ENCODE_DEBUG_ARG, 5, msg.description);
 #endif
  return pos;
 }
@@ -1576,13 +1576,13 @@ class GetTimeResponse final : public ProtoDecodableMessage {
 #ifdef USE_API_USER_DEFINED_ACTIONS
 class ListEntitiesServicesArgument final : public ProtoMessage {
 public:
-  StringRef name{nullptr, 0};  // null until set, encode only
+  ProgmemStringRef name{};
  enums::ServiceArgType type{};
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  StringRef description{nullptr, 0};  // null until set, encode only
+  ProgmemStringRef description{};
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  StringRef example{nullptr, 0};  // null until set, encode only
+  ProgmemStringRef example{};
 #endif
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -1603,12 +1603,12 @@ class ListEntitiesServicesResponse final : public ProtoMessage {
 #ifdef HAS_PROTO_MESSAGE_DUMP
  const LogString *message_name() const override { return LOG_STR("list_entities_services_response"); }
 #endif
-  StringRef name{nullptr, 0};  // null until set, encode only
+  ProgmemStringRef name{};
  uint32_t key{0};
  FixedVector<ListEntitiesServicesArgument> args{};
  enums::SupportsResponseType supports_response{};
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  StringRef description{nullptr, 0};  // null until set, encode only
+  ProgmemStringRef description{};
 #endif
  static uint8_t *encode_msg(const void *self, uint8_t *pos PROTO_ENCODE_DEBUG_PARAM);
  uint8_t *encode(ProtoWriteBuffer &buffer PROTO_ENCODE_DEBUG_PARAM) const {
@@ -12,8 +12,9 @@ namespace esphome::api {

 #ifdef USE_ESP8266
 // Out-of-line to avoid inlining strlen_P/memcpy_P at every call site
-void DumpBuffer::append_p_esp8266(const char *str) {
-  size_t len = strlen_P(str);
+void DumpBuffer::append_p_esp8266(const char *str) { this->append_p_esp8266(str, strlen_P(str)); }
+
+void DumpBuffer::append_p_esp8266(const char *str, size_t len) {
  size_t space = CAPACITY - 1 - pos_;
  if (len > space)
    len = space;
@@ -134,6 +135,13 @@ static void dump_progmem_bytes_field(DumpBuffer &out, const char *field_name, co
  progmem_memcpy(data_buf, data, len);
  dump_bytes_field(out, field_name, data_buf, len, indent);
 }
+
+// Helper for string fields in flash
+static void dump_progmem_string_field(DumpBuffer &out, const char *field_name, const ProgmemStringRef &value,
+                                      int indent = 2) {
+  append_field_prefix(out, field_name, indent);
+  out.append("'").append_p(value.progmem_ptr(), value.size()).append("'\n");
+}
 #pragma GCC diagnostic pop

 template<> const char *proto_enum_to_string<enums::DisconnectReason>(enums::DisconnectReason value) {
@@ -1612,19 +1620,19 @@ const char *GetTimeResponse::dump_to(DumpBuffer &out) const {
 #ifdef USE_API_USER_DEFINED_ACTIONS
 const char *ListEntitiesServicesArgument::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesServicesArgument"));
-  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
  dump_field(out, ESPHOME_PSTR("type"), static_cast<enums::ServiceArgType>(this->type));
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  dump_field(out, ESPHOME_PSTR("description"), this->description);
+  dump_progmem_string_field(out, ESPHOME_PSTR("description"), this->description);
 #endif
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  dump_field(out, ESPHOME_PSTR("example"), this->example);
+  dump_progmem_string_field(out, ESPHOME_PSTR("example"), this->example);
 #endif
  return out.c_str();
 }
 const char *ListEntitiesServicesResponse::dump_to(DumpBuffer &out) const {
  MessageDumpHelper helper(out, ESPHOME_PSTR("ListEntitiesServicesResponse"));
-  dump_field(out, ESPHOME_PSTR("name"), this->name);
+  dump_progmem_string_field(out, ESPHOME_PSTR("name"), this->name);
  dump_field(out, ESPHOME_PSTR("key"), this->key);
  for (const auto &it : this->args) {
    out.append(4, ' ').append_p(ESPHOME_PSTR("args")).append(": ");
@@ -1633,7 +1641,7 @@ const char *ListEntitiesServicesResponse::dump_to(DumpBuffer &out) const {
  }
  dump_field(out, ESPHOME_PSTR("supports_response"), static_cast<enums::SupportsResponseType>(this->supports_response));
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  dump_field(out, ESPHOME_PSTR("description"), this->description);
+  dump_progmem_string_field(out, ESPHOME_PSTR("description"), this->description);
 #endif
  return out.c_str();
 }
@@ -99,8 +99,7 @@ ListEntitiesIterator::ListEntitiesIterator(APIConnection *client) : client_(clie
 static constexpr uint8_t SERVICE_YIELD_INTERVAL = 3;

 bool ListEntitiesIterator::on_service(UserServiceDescriptor *service) {
-  UserActionScratch scratch;
-  auto resp = service->encode_list_service_response(scratch);
+  auto resp = service->encode_list_service_response();
  if (!this->client_->send_message(resp))
    return false;
  // at_ is this service's index
@@ -409,6 +409,10 @@ class ProtoEncode {
  /// Tag must be a single-byte varint (< 128). Always encodes (no zero check).
  [[nodiscard]] static inline uint8_t *encode_short_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
                                                                 uint8_t tag, const StringRef &ref) {
+#ifdef USE_ESP8266
+    // memcpy_P reads RAM too, and sharing the progmem copy is smaller than an inline memcpy
+    return encode_short_progmem_string_force(pos PROTO_ENCODE_DEBUG_ARG, tag, ProgmemStringRef(ref));
+#else
 #ifdef ESPHOME_DEBUG_API
    assert(ref.size() < 128 && "encode_short_string_force: string exceeds max_data_length < 128");
 #endif
@@ -417,6 +421,19 @@ class ProtoEncode {
    pos[1] = static_cast<uint8_t>(ref.size());
    std::memcpy(pos + 2, ref.c_str(), ref.size());
    return pos + 2 + ref.size();
+#endif
+  }
+  /// encode_short_string_force for a string that may be in flash (PROGMEM).
+  [[nodiscard]] static inline uint8_t *encode_short_progmem_string_force(
+      uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM, uint8_t tag, const ProgmemStringRef &ref) {
+#ifdef ESPHOME_DEBUG_API
+    assert(ref.size() < 128 && "encode_short_progmem_string_force: string exceeds max_data_length < 128");
+#endif
+    PROTO_ENCODE_CHECK_BOUNDS(pos, 2 + ref.size());
+    pos[0] = tag;
+    pos[1] = static_cast<uint8_t>(ref.size());
+    progmem_memcpy(pos + 2, ref.progmem_ptr(), ref.size());
+    return pos + 2 + ref.size();
  }
  /// Write a precomputed tag byte + 32-bit value. Outlined on embedded: one copy beats inline stores per field.
  [[nodiscard]] static PROTO_OUTLINE_FOR_SIZE uint8_t *write_tag_and_fixed32(
@@ -481,6 +498,17 @@ class ProtoEncode {
    progmem_memcpy(pos, data, len);
    return pos + len;
  }
+  /// encode_progmem_bytes for a string field that may be in flash.
+  [[nodiscard]] static inline uint8_t *encode_progmem_string(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                             uint32_t field_id, const ProgmemStringRef &ref) {
+    return encode_progmem_bytes(pos PROTO_ENCODE_DEBUG_ARG, field_id,
+                                reinterpret_cast<const uint8_t *>(ref.progmem_ptr()), ref.size());
+  }
+  [[nodiscard]] static inline uint8_t *encode_progmem_string_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
+                                                                   uint32_t field_id, const ProgmemStringRef &ref) {
+    return encode_progmem_bytes_force(pos PROTO_ENCODE_DEBUG_ARG, field_id,
+                                      reinterpret_cast<const uint8_t *>(ref.progmem_ptr()), ref.size());
+  }
  [[nodiscard]] static inline uint8_t *encode_uint32_force(uint8_t *__restrict__ pos PROTO_ENCODE_DEBUG_PARAM,
                                                           uint32_t field_id, uint32_t value) {
    pos = encode_field_raw(pos PROTO_ENCODE_DEBUG_ARG, field_id, 0);
@@ -680,9 +708,20 @@ class DumpBuffer {
    return *this;
  }

+  /// Append len bytes of a PROGMEM string
+  DumpBuffer &append_p(const char *str, size_t len) {
+#ifdef USE_ESP8266
+    append_p_esp8266(str, len);
+#else
+    append_impl_(str, len);
+#endif
+    return *this;
+  }
+
 #ifdef USE_ESP8266
  /// Out-of-line ESP8266 PROGMEM append to avoid inlining strlen_P/memcpy_P at every call site
  void append_p_esp8266(const char *str);
+  void append_p_esp8266(const char *str, size_t len);
 #endif

  const char *c_str() const { return buf_; }
@@ -1,47 +1,36 @@
 #include "user_services.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
+#include "esphome/core/progmem.h"
 #include "esphome/core/string_ref.h"

 namespace esphome::api {

-StringRef UserServiceStatic::str_(size_t idx, std::span<char> &scratch) const {
+ProgmemStringRef UserServiceStatic::str_(size_t idx) const {
  const char *s = progmem_read_ptr(&this->strings_[idx]);
  if (s == nullptr)
    return {};
-#ifdef USE_ESP8266
-  // Codegen sizes the scratch buffer for the largest service; the bound only guards other callers
-  if (scratch.empty())
-    return {};
-  size_t len = strnlen_P(s, scratch.size() - 1);
-  progmem_memcpy(scratch.data(), s, len);
-  scratch[len] = '\0';
-  StringRef ref(scratch.data(), len);
-  scratch = scratch.subspan(len + 1);
-  return ref;
-#else
-  return StringRef(s);
-#endif
+  return ProgmemStringRef(s, ESPHOME_strlen_P(s));
 }

 ListEntitiesServicesResponse UserServiceStatic::encode_list_service_response_(
-    std::span<const enums::ServiceArgType> arg_types, std::span<char> scratch) const {
+    std::span<const enums::ServiceArgType> arg_types) const {
  ListEntitiesServicesResponse msg;
-  msg.name = this->str_(0, scratch);
+  msg.name = this->str_(0);
  msg.key = this->key_;
  msg.supports_response = this->supports_response_;
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-  msg.description = this->str_(1, scratch);
+  msg.description = this->str_(1);
 #endif
  msg.args.init(arg_types.size());
  for (size_t i = 0; i < arg_types.size(); i++) {
    size_t base = USER_ACTION_HEADER_STRINGS + i * USER_ACTION_ARG_STRINGS;
    auto &arg = msg.args.emplace_back();
    arg.type = arg_types[i];
-    arg.name = this->str_(base, scratch);
+    arg.name = this->str_(base);
 #ifdef USE_API_USER_DEFINED_ACTION_METADATA
-    arg.description = this->str_(base + 1, scratch);
-    arg.example = this->str_(base + 2, scratch);
+    arg.description = this->str_(base + 1);
+    arg.example = this->str_(base + 2);
 #endif
  }
  return msg;
@@ -20,9 +20,8 @@ class APIServer;

 class UserServiceDescriptor {
 public:
-  /// Build the list-entities message. On ESP8266 the strings live in PROGMEM and are copied into
-  /// `scratch`, so the returned message is only valid while `scratch` is; other platforms ignore it.
-  virtual ListEntitiesServicesResponse encode_list_service_response(std::span<char> scratch) = 0;
+  /// Build the list-entities message; its strings may point into flash (PROGMEM).
+  virtual ListEntitiesServicesResponse encode_list_service_response() = 0;

  virtual bool execute_service(const ExecuteServiceRequest &req) = 0;
 #ifdef USE_API_USER_DEFINED_ACTION_RESPONSES
@@ -37,13 +36,6 @@ template<typename T> T get_execute_arg_value(const ExecuteServiceArgument &arg);

 template<typename T> enums::ServiceArgType to_service_arg_type();

-// Scratch buffer list-entities hands to encode_list_service_response(); only ESP8266 copies into it
-#ifdef USE_ESP8266
-using UserActionScratch = std::array<char, API_USER_ACTION_STRINGS_SCRATCH_SIZE>;
-#else
-using UserActionScratch = std::array<char, 0>;
-#endif
-
 // Non-template base for YAML-defined services so the list-entities encoder is compiled once.
 // All strings live in one PROGMEM pointer table emitted by codegen (see _action_strings in
 // __init__.py), so each service costs a single pointer of RAM. Layout: the action name, then
@@ -63,12 +55,9 @@ class UserServiceStatic : public UserServiceDescriptor {
      : strings_(strings), key_(key), supports_response_(supports_response) {}

 protected:
-  ListEntitiesServicesResponse encode_list_service_response_(std::span<const enums::ServiceArgType> arg_types,
-                                                             std::span<char> scratch) const;
-  /// Reference table entry `idx`; nullptr gives an empty StringRef.
-  /// On ESP8266 the bytes are copied out of PROGMEM into `scratch` with a terminator, and the span
-  /// is advanced past the copy.
-  StringRef str_(size_t idx, std::span<char> &scratch) const;
+  ListEntitiesServicesResponse encode_list_service_response_(std::span<const enums::ServiceArgType> arg_types) const;
+  /// Table entry `idx` as it sits in flash; nullptr gives an empty string.
+  ProgmemStringRef str_(size_t idx) const;

  const char *const *strings_;  // PROGMEM pointer table, read with progmem_read_ptr()
  uint32_t key_;
@@ -79,9 +68,9 @@ template<typename... Ts> class UserServiceBase : public UserServiceStatic {
 public:
  using UserServiceStatic::UserServiceStatic;

-  ListEntitiesServicesResponse encode_list_service_response(std::span<char> scratch) override {
+  ListEntitiesServicesResponse encode_list_service_response() override {
    std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
-    return this->encode_list_service_response_(arg_types, scratch);
+    return this->encode_list_service_response_(arg_types);
  }

  bool execute_service(const ExecuteServiceRequest &req) override {
@@ -125,9 +114,9 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
    this->key_ = fnv1_hash(this->name_.c_str());
  }

-  ListEntitiesServicesResponse encode_list_service_response(std::span<char> /*scratch*/) override {
+  ListEntitiesServicesResponse encode_list_service_response() override {
    ListEntitiesServicesResponse msg;
-    msg.name = StringRef(this->name_);
+    msg.name = ProgmemStringRef(StringRef(this->name_));
    msg.key = this->key_;
    msg.supports_response = enums::SUPPORTS_RESPONSE_NONE;  // Dynamic services don't support responses yet
    std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
@@ -135,7 +124,7 @@ template<typename... Ts> class UserServiceDynamic : public UserServiceDescriptor
    for (size_t i = 0; i < sizeof...(Ts); i++) {
      auto &arg = msg.args.emplace_back();
      arg.type = arg_types[i];
-      arg.name = StringRef(this->arg_names_[i]);
+      arg.name = ProgmemStringRef(StringRef(this->arg_names_[i]));
    }
    return msg;
  }
@@ -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) {
@@ -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

@@ -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;
@@ -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 {
@@ -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 {
@@ -1,111 +0,0 @@
-from esphome import automation
-import esphome.codegen as cg
-from esphome.components import i2c, sensor
-import esphome.config_validation as cv
-from esphome.const import (
-    CONF_ADDRESS,
-    CONF_ID,
-    DEVICE_CLASS_TEMPERATURE,
-    DEVICE_CLASS_VOLTAGE,
-    STATE_CLASS_MEASUREMENT,
-    UNIT_CELSIUS,
-    UNIT_VOLT,
-)
-from esphome.types import ConfigType
-
-AUTO_LOAD = ["sensor"]
-CODEOWNERS = ["@limpkin"]
-DEPENDENCIES = ["i2c"]
-DOMAIN = "bq76972"
-MULTI_CONF = True
-
-bq76972_ns = cg.esphome_ns.namespace("bq76972")
-BQ76972Component = bq76972_ns.class_(
-    "BQ76972Component", cg.PollingComponent, i2c.I2CDevice
-)
-
-CONF_REG_DISABLED = "reg_disabled"
-CONF_CRC_ENABLED = "crc_enabled"
-CONF_STACK_VOLTAGE = "stack_voltage"
-
-# Ordered as the chip reports them, starting at command 0x68
-CONF_TEMPERATURES = [
-    "internal_temperature",
-    "cfetoff_temperature",
-    "dfetoff_temperature",
-    "alert_temperature",
-    "ts1_temperature",
-    "ts2_temperature",
-    "ts3_temperature",
-    "hdq_temperature",
-    "dchg_temperature",
-    "ddsg_temperature",
-]
-
-CONF_CELL_VOLTAGES = [f"cell_{i}_voltage" for i in range(1, 17)]
-
-voltage_sensor_schema = sensor.sensor_schema(
-    unit_of_measurement=UNIT_VOLT,
-    accuracy_decimals=3,
-    device_class=DEVICE_CLASS_VOLTAGE,
-    state_class=STATE_CLASS_MEASUREMENT,
-)
-
-temp_sensor_schema = sensor.sensor_schema(
-    unit_of_measurement=UNIT_CELSIUS,
-    accuracy_decimals=1,
-    device_class=DEVICE_CLASS_TEMPERATURE,
-    state_class=STATE_CLASS_MEASUREMENT,
-)
-
-CONFIG_SCHEMA = (
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(BQ76972Component),
-            cv.Optional(CONF_CRC_ENABLED, default=False): cv.boolean,
-            cv.Optional(CONF_REG_DISABLED, default=False): cv.boolean,
-            cv.Optional(CONF_STACK_VOLTAGE): voltage_sensor_schema,
-            **{cv.Optional(key): voltage_sensor_schema for key in CONF_CELL_VOLTAGES},
-            **{cv.Optional(key): temp_sensor_schema for key in CONF_TEMPERATURES},
-        }
-    )
-    .extend(i2c.i2c_device_schema(0x08))
-    .extend(cv.polling_component_schema("10s"))
-)
-
-
-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)
-
-    cg.add(var.set_crc_mode(config[CONF_CRC_ENABLED]))
-    cg.add(var.set_reg_disable(config[CONF_REG_DISABLED]))
-
-    sensors = sensor.sub_sensors(config)
-    await sensors(CONF_STACK_VOLTAGE, var.set_stack_voltage_sensor)
-
-    for idx, key in enumerate(CONF_TEMPERATURES):
-        if (conf := config.get(key)) is not None:
-            sens = await sensor.new_sensor(conf)
-            cg.add(var.set_temperature_sensor(sens, idx))
-
-    for idx, key in enumerate(CONF_CELL_VOLTAGES):
-        if (conf := config.get(key)) is not None:
-            sens = await sensor.new_sensor(conf)
-            cg.add(var.set_cell_sensor(sens, idx))
-
-
-BQ76972_PROGRAM_I2C_ADDRESS_SCHEMA = cv.maybe_simple_value(
-    {
-        cv.GenerateID(): cv.use_id(BQ76972Component),
-        cv.Required(CONF_ADDRESS): cv.templatable(cv.i2c_address),
-    },
-    key=CONF_ADDRESS,
-)
-
-automation.register_apply_action(
-    "bq76972.program_i2c_address",
-    BQ76972_PROGRAM_I2C_ADDRESS_SCHEMA,
-    automation.ApplyField(CONF_ADDRESS, "program_i2c_address", cg.uint8),
-)
@@ -1,298 +0,0 @@
-#include "bq76972.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::bq76972 {
-
-ESPHOME_LOG_TAG(TAG, "bq76972");
-
-static constexpr uint8_t BQ76972_REG_SUBCOMMAND = 0x3E;  // 0x3E low byte, 0x3F high byte
-static constexpr uint8_t BQ76972_REG_TRANSFER_BUFFER = 0x40;
-static constexpr uint8_t BQ76972_REG_CHECKSUM = 0x60;  // 0x60 checksum, 0x61 length
-static constexpr uint8_t BQ76972_CMD_BAT_STATUS = 0x12;
-static constexpr uint8_t BQ76972_CMD_CELL_START = 0x14;
-static constexpr uint8_t BQ76972_CMD_STACK_VOLTAGE = 0x34;
-static constexpr uint8_t BQ76972_CMD_TEMP_START = 0x68;
-static constexpr uint16_t BQ76972_SUBCMD_ENTER_CFG_UPDATE = 0x0090;
-static constexpr uint16_t BQ76972_SUBCMD_EXIT_CFG_UPDATE = 0x0092;
-static constexpr uint16_t BQ76972_MEM_REG12_CONFIG = 0x9236;
-static constexpr uint16_t BQ76972_MEM_REG0_CONFIG = 0x9237;
-static constexpr uint16_t BQ76972_MEM_I2C_ADDRESS = 0x923A;
-static constexpr uint16_t BQ76972_MEM_SWAP_COMM_MODE = 0x29BC;
-// Pin config of temperature reading N (1 = CFETOFF ... 9 = DDSG) is at this base + N
-static constexpr uint16_t BQ76972_MEM_TEMP_PIN_CONFIG_BASE = 0x92F9;
-static constexpr size_t BQ76972_TS1_INDEX = 4;  // a thermistor input by default
-static constexpr uint8_t BQ76972_PIN_CONFIG_THERMISTOR = 0x07;
-
-// 16 words with a CRC byte after every data byte
-static constexpr size_t BQ76972_MAX_TRANSFER = 64;
-static constexpr uint8_t BQ76972_MAX_POLLS = 50;
-
-static float raw_to_celsius(uint16_t raw) { return static_cast<int16_t>(raw) * 0.1f - 273.15f; }
-
-bool BQ76972Component::read_block_(uint8_t start_register, uint8_t *data, size_t len) {
-  if (!this->crc_mode_)
-    return this->read_bytes(start_register, data, len);
-
-  // With CRC enabled, every data byte is followed by a CRC byte
-  std::array<uint8_t, BQ76972_MAX_TRANSFER> buffer;
-  if (len == 0 || len * 2 > buffer.size())
-    return false;
-  if (!this->read_bytes(start_register, buffer.data(), len * 2))
-    return false;
-
-  // The first CRC also covers the write address, register and read address
-  const uint8_t crc0_input[4] = {static_cast<uint8_t>(this->address_ << 1), start_register,
-                                 static_cast<uint8_t>((this->address_ << 1) | 1), buffer[0]};
-  if (crc8(crc0_input, 4, 0x00, 0x07, true) != buffer[1]) {
-    ESP_LOGD(TAG, "CRC mismatch at register 0x%02X byte 0", start_register);
-    return false;
-  }
-  data[0] = buffer[0];
-  for (size_t i = 1; i < len; ++i) {
-    if (crc8(&buffer[i * 2], 1, 0x00, 0x07, true) != buffer[i * 2 + 1]) {
-      ESP_LOGD(TAG, "CRC mismatch at register 0x%02X byte %u", start_register, static_cast<unsigned>(i));
-      return false;
-    }
-    data[i] = buffer[i * 2];
-  }
-  return true;
-}
-
-bool BQ76972Component::write_block_(uint8_t start_register, const uint8_t *data, size_t len) {
-  if (!this->crc_mode_)
-    return this->write_bytes(start_register, data, len);
-
-  std::array<uint8_t, BQ76972_MAX_TRANSFER> buffer;
-  if (len == 0 || len * 2 > buffer.size())
-    return false;
-
-  // The first CRC also covers the write address and register
-  const uint8_t crc0_input[3] = {static_cast<uint8_t>(this->address_ << 1), start_register, data[0]};
-  buffer[0] = data[0];
-  buffer[1] = crc8(crc0_input, 3, 0x00, 0x07, true);
-  for (size_t i = 1; i < len; ++i) {
-    buffer[i * 2] = data[i];
-    buffer[i * 2 + 1] = crc8(&data[i], 1, 0x00, 0x07, true);
-  }
-  return this->write_bytes(start_register, buffer.data(), len * 2);
-}
-
-bool BQ76972Component::read_words_(uint8_t start_register, uint16_t *data, size_t num_words) {
-  std::array<uint8_t, BQ76972_MAX_TRANSFER / 2> bytes;
-  if (num_words * 2 > bytes.size() || !this->read_block_(start_register, bytes.data(), num_words * 2))
-    return false;
-  for (size_t i = 0; i < num_words; i++)
-    data[i] = encode_uint16(bytes[2 * i + 1], bytes[2 * i]);
-  return true;
-}
-
-bool BQ76972Component::send_subcommand_(uint16_t subcommand) {
-  const uint8_t bytes[2] = {static_cast<uint8_t>(subcommand & 0xFF), static_cast<uint8_t>(subcommand >> 8)};
-  return this->write_block_(BQ76972_REG_SUBCOMMAND, bytes, 2);
-}
-
-bool BQ76972Component::wait_for_subcommand_() {
-  uint8_t bytes[2];
-  for (uint8_t i = 0; i < BQ76972_MAX_POLLS; i++) {
-    if (!this->read_block_(BQ76972_REG_SUBCOMMAND, bytes, 2))
-      return false;
-    if (bytes[0] != 0xFF && bytes[1] != 0xFF)
-      return true;
-    delay(1);
-  }
-  return false;
-}
-
-bool BQ76972Component::wait_for_cfgupdate_() {
-  uint16_t status;
-  for (uint8_t i = 0; i < BQ76972_MAX_POLLS; i++) {
-    if (!this->read_words_(BQ76972_CMD_BAT_STATUS, &status, 1))
-      return false;
-    if (status & 0x0001)
-      return true;
-    delay(1);
-  }
-  return false;
-}
-
-bool BQ76972Component::read_subcommand_(uint16_t subcommand, uint8_t *data, size_t len) {
-  return this->send_subcommand_(subcommand) && this->wait_for_subcommand_() &&
-         this->read_block_(BQ76972_REG_TRANSFER_BUFFER, data, len);
-}
-
-bool BQ76972Component::write_subcommand_(uint16_t subcommand, const uint8_t *data, size_t len) {
-  if (!this->send_subcommand_(subcommand))
-    return false;
-  if (len == 0)
-    return true;
-  if (!this->write_block_(BQ76972_REG_TRANSFER_BUFFER, data, len))
-    return false;
-
-  // Inverted 8-bit sum of 0x3E, 0x3F and the data; length counts 0x3E, 0x3F, 0x60, 0x61 and the data
-  uint8_t sum = static_cast<uint8_t>(subcommand & 0xFF) + static_cast<uint8_t>(subcommand >> 8);
-  for (size_t i = 0; i < len; ++i)
-    sum += data[i];
-  const uint8_t tail[2] = {static_cast<uint8_t>(~sum), static_cast<uint8_t>(4 + len)};
-  return this->write_block_(BQ76972_REG_CHECKSUM, tail, 2);
-}
-
-bool BQ76972Component::enter_cfg_update_() {
-  if (!this->write_subcommand_(BQ76972_SUBCMD_ENTER_CFG_UPDATE, nullptr, 0))
-    return false;
-  delay(10);
-  return this->wait_for_cfgupdate_();
-}
-
-bool BQ76972Component::exit_cfg_update_() {
-  return this->write_subcommand_(BQ76972_SUBCMD_EXIT_CFG_UPDATE, nullptr, 0);
-}
-
-bool BQ76972Component::regs_disabled_(bool &out) {
-  uint8_t reg12;
-  uint8_t reg0;
-  if (!this->read_subcommand_(BQ76972_MEM_REG12_CONFIG, &reg12, 1) ||
-      !this->read_subcommand_(BQ76972_MEM_REG0_CONFIG, &reg0, 1))
-    return false;
-  out = reg12 == 0 && (reg0 & 0x01) == 0;
-  return true;
-}
-
-const LogString *BQ76972Component::configure_() {
-  uint16_t internal_temp;
-  if (!this->read_words_(BQ76972_CMD_TEMP_START, &internal_temp, 1))
-    return LOG_STR(ESP_LOG_MSG_COMM_FAIL);
-
-  // Only write the regulator config when it differs, see
-  // https://e2e.ti.com/support/power-management-group/power-management/f/power-management-forum/1583718/bq76972-undocumented-4-minute-config_update-auto-exit-timeout
-  bool regs_disabled = true;
-  if (this->reg_disable_ && !this->regs_disabled_(regs_disabled))
-    return LOG_STR("Reading regulator config failed");
-  const bool write_regs = !regs_disabled;
-
-  bool write_thermistors = false;
-  for (size_t i = 1; i < BQ76972_NUM_TEMPERATURES; i++) {
-    if (i != BQ76972_TS1_INDEX && this->temperature_sensors_[i] != nullptr)
-      write_thermistors = true;
-  }
-
-  if (write_regs || write_thermistors) {
-    if (!this->enter_cfg_update_())
-      return LOG_STR("Entering config update mode failed");
-    const LogString *error = this->write_config_(write_regs);
-    // The chip stops measuring in config update mode, so leave it even after a failed write
-    if (!this->exit_cfg_update_() && error == nullptr)
-      error = LOG_STR("Exiting config update mode failed");
-    if (error != nullptr)
-      return error;
-    if (write_regs && (!this->regs_disabled_(regs_disabled) || !regs_disabled))
-      return LOG_STR("Disabling regulators failed");
-  }
-
-  ESP_LOGD(TAG, "Internal temperature: %.1f°C", raw_to_celsius(internal_temp));
-  return nullptr;
-}
-
-const LogString *BQ76972Component::write_config_(bool write_regs) {
-  if (write_regs) {
-    const uint8_t zero = 0;
-    if (!this->write_subcommand_(BQ76972_MEM_REG12_CONFIG, &zero, 1) ||
-        !this->write_subcommand_(BQ76972_MEM_REG0_CONFIG, &zero, 1))
-      return LOG_STR("Writing regulator config failed");
-  }
-  for (size_t i = 1; i < BQ76972_NUM_TEMPERATURES; i++) {
-    if (i == BQ76972_TS1_INDEX || this->temperature_sensors_[i] == nullptr)
-      continue;
-    if (!this->write_subcommand_(BQ76972_MEM_TEMP_PIN_CONFIG_BASE + i, &BQ76972_PIN_CONFIG_THERMISTOR, 1))
-      return LOG_STR("Writing thermistor pin config failed");
-  }
-  return nullptr;
-}
-
-void BQ76972Component::setup() {
-  if (const LogString *error = this->configure_(); error != nullptr)
-    this->mark_failed(error);
-}
-
-void BQ76972Component::dump_config() {
-  ESP_LOGCONFIG(TAG, "BQ76972:");
-  LOG_I2C_DEVICE(this);
-  LOG_UPDATE_INTERVAL(this);
-  ESP_LOGCONFIG(TAG,
-                "  CRC Mode: %s\n"
-                "  Regulators disabled: %s",
-                this->crc_mode_ ? LOG_STR_LITERAL("Enabled") : LOG_STR_LITERAL("Disabled"), YESNO(this->reg_disable_));
-}
-
-void BQ76972Component::program_i2c_address(uint8_t address) {
-  if (this->is_failed())
-    return;
-  const uint8_t shifted = address << 1;
-  if (!this->enter_cfg_update_()) {
-    this->status_set_warning(LOG_STR("Programming I2C address failed"));
-    return;
-  }
-  // The new address only takes effect with the swap, so after a failed write the chip still answers at the
-  // old one and must still be taken out of config update mode
-  const bool written = this->write_subcommand_(BQ76972_MEM_I2C_ADDRESS, &shifted, 1) &&
-                       this->write_subcommand_(BQ76972_MEM_SWAP_COMM_MODE, nullptr, 0);
-  if (written) {
-    delay(10);
-    this->set_i2c_address(address);
-  }
-  if (!this->exit_cfg_update_() || !written) {
-    this->status_set_warning(LOG_STR("Programming I2C address failed"));
-    return;
-  }
-  ESP_LOGI(TAG, "I2C address set to 0x%02X", address);
-}
-
-template<size_t N> static bool any_set(const std::array<sensor::Sensor *, N> &sensors) {
-  for (auto *sensor : sensors) {
-    if (sensor != nullptr)
-      return true;
-  }
-  return false;
-}
-
-void BQ76972Component::update() {
-  // Each group publishes as soon as its read succeeds, so one failed read does not hold back the others
-  bool ok = true;
-  uint16_t words[BQ76972_NUM_CELLS];
-  if (this->stack_voltage_sensor_ != nullptr) {
-    if (this->read_words_(BQ76972_CMD_STACK_VOLTAGE, words, 1)) {
-      if (words[0] != 0)
-        this->stack_voltage_sensor_->publish_state(words[0] * 0.01f);  // 10 mV units
-    } else {
-      ok = false;
-    }
-  }
-  if (any_set(this->cell_sensors_)) {
-    if (this->read_words_(BQ76972_CMD_CELL_START, words, BQ76972_NUM_CELLS)) {
-      for (size_t i = 0; i < BQ76972_NUM_CELLS; i++) {
-        if (this->cell_sensors_[i] != nullptr && words[i] != 0)
-          this->cell_sensors_[i]->publish_state(words[i] * 0.001f);  // mV
-      }
-    } else {
-      ok = false;
-    }
-  }
-  if (any_set(this->temperature_sensors_)) {
-    if (this->read_words_(BQ76972_CMD_TEMP_START, words, BQ76972_NUM_TEMPERATURES)) {
-      for (size_t i = 0; i < BQ76972_NUM_TEMPERATURES; i++) {
-        if (this->temperature_sensors_[i] != nullptr)
-          this->temperature_sensors_[i]->publish_state(raw_to_celsius(words[i]));
-      }
-    } else {
-      ok = false;
-    }
-  }
-  if (ok) {
-    this->status_clear_warning();
-  } else {
-    this->status_set_warning(LOG_STR(ESP_LOG_MSG_COMM_FAIL));
-  }
-}
-
-}  // namespace esphome::bq76972
@@ -1,51 +0,0 @@
-#pragma once
-
-#include "esphome/components/sensor/sensor.h"
-#include "esphome/components/i2c/i2c.h"
-#include "esphome/core/component.h"
-
-#include <array>
-
-namespace esphome::bq76972 {
-
-static constexpr size_t BQ76972_NUM_CELLS = 16;
-static constexpr size_t BQ76972_NUM_TEMPERATURES = 10;
-
-class BQ76972Component final : public PollingComponent, public i2c::I2CDevice {
- public:
-  void setup() override;
-  void update() override;
-  void dump_config() override;
-
-  void set_crc_mode(bool crc_mode) { this->crc_mode_ = crc_mode; }
-  void set_reg_disable(bool reg_disable) { this->reg_disable_ = reg_disable; }
-  void set_stack_voltage_sensor(sensor::Sensor *s) { this->stack_voltage_sensor_ = s; }
-  void set_cell_sensor(sensor::Sensor *s, size_t index) { this->cell_sensors_[index] = s; }
-  void set_temperature_sensor(sensor::Sensor *s, size_t index) { this->temperature_sensors_[index] = s; }
-
-  void program_i2c_address(uint8_t address);
-
- protected:
-  bool read_block_(uint8_t start_register, uint8_t *data, size_t len);
-  bool write_block_(uint8_t start_register, const uint8_t *data, size_t len);
-  bool read_words_(uint8_t start_register, uint16_t *data, size_t num_words);
-  bool send_subcommand_(uint16_t subcommand);
-  bool read_subcommand_(uint16_t subcommand, uint8_t *data, size_t len);
-  bool write_subcommand_(uint16_t subcommand, const uint8_t *data, size_t len);
-  bool wait_for_subcommand_();
-  bool wait_for_cfgupdate_();
-  bool enter_cfg_update_();
-  bool exit_cfg_update_();
-  bool regs_disabled_(bool &out);
-  const LogString *configure_();
-  const LogString *write_config_(bool write_regs);
-
-  bool reg_disable_{false};
-  bool crc_mode_{false};
-
-  sensor::Sensor *stack_voltage_sensor_{nullptr};
-  std::array<sensor::Sensor *, BQ76972_NUM_CELLS> cell_sensors_{};
-  std::array<sensor::Sensor *, BQ76972_NUM_TEMPERATURES> temperature_sensors_{};
-};
-
-}  // namespace esphome::bq76972
@@ -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;
@@ -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;
@@ -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
@@ -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]))
@@ -5,7 +5,6 @@
 #include "display_color_utils.h"
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"

 namespace esphome::display {
@@ -53,62 +52,37 @@ void Display::line_at_angle(int x, int y, int angle, int start_radius, int stop_
  this->line(x1, y1, x2, y2, color);
 }

-// flatten keeps to_color() inlined in the pixel loop; in PSRAM builds GCC at
-// -Os stops inlining it once there are two call sites, which costs a call and
-// spills per pixel. Without PSRAM there is one call site and it changes
-// nothing, and draw_pixel_at() stays a virtual call either way.
-template<ColorBitness BITNESS>
-static void __attribute__((flatten))
-draw_packed_pixels(Display *display, 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 size_t line_stride = x_offset + w + x_pad;  // length of each source line in pixels
-  // BITNESS is a constant here, so to_color()'s three per pixel divisions
-  // become a multiply and shift and its bitness switch folds.
-  const auto draw_source_pixel = [&](int x, int y, size_t source_idx) ESPHOME_ALWAYS_INLINE {
-    display->draw_pixel_at(
-        x + x_start, y + y_start,
-        ColorUtil::to_color(ColorUtil::read_packed<BITNESS>(ptr, source_idx, big_endian), order, BITNESS));
-  };
-  // The source and frame buffers are row-major, so walking rows keeps the read
-  // and the write sequential. When the display swaps the axes before writing,
-  // walking columns keeps the write sequential instead; with the frame buffer
-  // in PSRAM a strided write costs more than a strided read.
-#ifdef USE_PSRAM
-  if (display->pixel_axes_swapped()) {
-    size_t column_idx = y_offset * line_stride + x_offset;
-    for (int x = 0; x != w; x++, column_idx++) {
-      size_t source_idx = column_idx;
-      for (int y = 0; y != h; y++, source_idx += line_stride) {
-        draw_source_pixel(x, y, source_idx);
-      }
-    }
-    return;
-  }
-#endif
-  // Row walk: builds without PSRAM, and PSRAM builds whose axes are not swapped.
-  for (int y = 0; y != h; y++) {
-    size_t source_idx = (y_offset + y) * line_stride + x_offset;
-    for (int x = 0; x != w; x++, source_idx++) {
-      draw_source_pixel(x, y, source_idx);
-    }
-  }
-}
-
 void Display::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) {
-  switch (bitness) {
-    case COLOR_BITNESS_565:
-      draw_packed_pixels<COLOR_BITNESS_565>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
-                                            x_pad);
-      break;
-    case COLOR_BITNESS_888:
-      draw_packed_pixels<COLOR_BITNESS_888>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
-                                            x_pad);
-      break;
-    default:
-      draw_packed_pixels<COLOR_BITNESS_332>(this, x_start, y_start, w, h, ptr, order, big_endian, x_offset, y_offset,
-                                            x_pad);
-      break;
+  size_t line_stride = x_offset + w + x_pad;  // length of each source line in pixels
+  uint32_t color_value;
+  for (int y = 0; y != h; y++) {
+    size_t source_idx = (y_offset + y) * line_stride + x_offset;
+    size_t source_idx_mod;
+    for (int x = 0; x != w; x++, source_idx++) {
+      switch (bitness) {
+        default:
+          color_value = ptr[source_idx];
+          break;
+        case COLOR_BITNESS_565:
+          source_idx_mod = source_idx * 2;
+          if (big_endian) {
+            color_value = (ptr[source_idx_mod] << 8) + ptr[source_idx_mod + 1];
+          } else {
+            color_value = ptr[source_idx_mod] + (ptr[source_idx_mod + 1] << 8);
+          }
+          break;
+        case COLOR_BITNESS_888:
+          source_idx_mod = source_idx * 3;
+          if (big_endian) {
+            color_value = (ptr[source_idx_mod + 0] << 16) + (ptr[source_idx_mod + 1] << 8) + ptr[source_idx_mod + 2];
+          } else {
+            color_value = ptr[source_idx_mod + 0] + (ptr[source_idx_mod + 1] << 8) + (ptr[source_idx_mod + 2] << 16);
+          }
+          break;
+      }
+      this->draw_pixel_at(x + x_start, y + y_start, ColorUtil::to_color(color_value, order, bitness));
+    }
  }
 }

@@ -139,11 +139,6 @@ enum DisplayRotation {
  DISPLAY_ROTATION_270_DEGREES = 270,
 };

-/// Whether a rotation swaps the x and y axes.
-constexpr bool rotation_swaps_axes(DisplayRotation rotation) {
-  return rotation == DISPLAY_ROTATION_90_DEGREES || rotation == DISPLAY_ROTATION_270_DEGREES;
-}
-
 const int EDGES_TRIGON = 3;
 const int EDGES_TRIANGLE = 3;
 const int EDGES_TETRAGON = 4;
@@ -363,9 +358,6 @@ class Display : public PollingComponent {
   * \param x_pad How many pixels are in each line after the end of the pixels to be copied.
   *
   * The length of each source buffer line (stride) will be x_offset + w + x_pad.
-   *
-   * An override that copies the block as is must send any other format, byte order or software
-   * rotation through this base version, which draws per pixel. Callers keep the block on screen.
   */
  virtual 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);
@@ -725,12 +717,6 @@ class Display : public PollingComponent {

  virtual DisplayRotation get_rotation() const { return this->rotation_; }

-  /// True when draw_pixel_at() swaps x and y before writing, so pixels that are
-  /// neighbours along x land a row apart in the frame buffer. Not the same as
-  /// get_width()/get_height() swapping: a display that rotates in hardware
-  /// reports swapped dimensions but writes unswapped pixels.
-  virtual bool pixel_axes_swapped() const { return rotation_swaps_axes(this->rotation_); }
-
  /** Get the type of display that the buffer corresponds to. In case of dynamically configurable displays,
   * returns the type the display is currently configured to.
   */
@@ -1,8 +1,5 @@
 #pragma once
-#include <array>
-#include <cstdint>
 #include "esphome/core/color.h"
-#include "esphome/core/helpers.h"

 namespace esphome::display {
 enum ColorOrder : uint8_t { COLOR_ORDER_RGB = 0, COLOR_ORDER_BGR = 1, COLOR_ORDER_GRB = 2 };
@@ -11,27 +8,6 @@ inline static uint8_t esp_scale(uint8_t i, uint8_t scale, uint8_t max_value = 25

 class ColorUtil {
 public:
-  /// Reads one packed pixel of the given bitness from a source buffer into the
-  /// value to_color() takes. BITNESS is a template argument so the byte layout
-  /// folds; pass it on to to_color() as a constant too, and its channel scaling
-  /// divides by a constant, which the compiler turns into a multiply and shift.
-  template<ColorBitness BITNESS>
-  static ESPHOME_ALWAYS_INLINE uint32_t read_packed(const uint8_t *ptr, size_t index, bool big_endian) {
-    if constexpr (BITNESS == COLOR_BITNESS_565) {
-      const size_t idx = index * 2;
-      if (big_endian)
-        return (ptr[idx] << 8) + ptr[idx + 1];
-      return ptr[idx] + (ptr[idx + 1] << 8);
-    } else if constexpr (BITNESS == COLOR_BITNESS_888) {
-      const size_t idx = index * 3;
-      if (big_endian)
-        return (ptr[idx + 0] << 16) + (ptr[idx + 1] << 8) + ptr[idx + 2];
-      return ptr[idx + 0] + (ptr[idx + 1] << 8) + (ptr[idx + 2] << 16);
-    } else {
-      return ptr[index];
-    }
-  }
-
  static Color to_color(uint32_t colorcode, ColorOrder color_order,
                        ColorBitness color_bitness = ColorBitness::COLOR_BITNESS_888, bool right_bit_aligned = true) {
    uint8_t first_color, second_color, third_color;
@@ -178,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
@@ -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
@@ -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
 }

 /**
@@ -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_{};
 };

@@ -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")
@@ -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
@@ -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,
@@ -106,10 +106,7 @@ 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_; }
-  bool pixel_axes_swapped() const override { return this->effective_transform_ & SWAP_XY; }
  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.
@@ -128,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
@@ -145,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
   */
@@ -197,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
@@ -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{};
@@ -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_;
@@ -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;
@@ -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;
@@ -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_);
@@ -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.
@@ -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;
@@ -87,38 +87,6 @@ jd79660.extend(
    ),
 )

-# Waveshare 2.13-G (V2 hardware/init revision, PCB marked "rev 2.1" or later)
-#
-# Vendor init derived from vendor sample code
-# <https://github.com/waveshareteam/e-Paper/blob/master/E-paper_Separate_Program/2in13_e-Paper_G/ESP32/EPD_2in13g_V2.cpp>
-# Compatible MIT license, see esphome/LICENSE file.
-#
-# Note: busy pin uses LOW=busy, HIGH=idle. Configure with inverted: true in YAML.
-# Note: panel is 122px wide, but vendor code declares the TRES register as a fixed
-# 124 on this revision. width=124 is declared here (rather than 122) purely so the
-# transferred bytes-per-row matches what the vendor init tells the IC to expect; the
-# extra 2 columns fall outside the visible glass. The model width must equal the
-# TRES value in initsequence, so overriding dimensions: in YAML brings the shear back.
-#
-# fmt: off
-jd79660.extend(
-    "Waveshare-2.13in-G",
-    width=124,
-    height=250,
-
-    initsequence=(
-        (0x61, 0x00, 0x7C, 0x00, 0xFA,),  # TRES: 124x250 fixed (124 = TRES stride value)
-        (0xE9, 0x01,),
-        # Power On (0x04): Must be early part of init seq = Disabled later!
-        (0x04,),
-    ),
-    fast_update=(
-        (0xE0, 0x02,),
-        (0xE6, 0x5A,),
-        (0xA5,),
-    ),
-)
-
 # Waveshare 7.5-H
 #
 # Vendor init derived from vendor sample code
@@ -162,7 +130,7 @@ jd79660.extend(
 # Note: busy pin uses LOW=busy, HIGH=idle.
 #
 # fmt: off
-gdey0213f51 = jd79660.extend(
+jd79660.extend(
    "goodisplay-gdey0213f51-2.13",
    width=128,
    height=250,
@@ -186,13 +154,3 @@ gdey0213f51 = jd79660.extend(
        (0x04,),
    ),
 )
-
-# Waveshare 2.13-G (V1 hardware/init revision, older stock): the same panel and init as the Good
-# Display entry above, byte for byte, so it only adds the name. Vendor sample:
-# <https://github.com/waveshareteam/e-Paper/blob/master/E-paper_Separate_Program/2in13_e-Paper_G/ESP32/EPD_2in13g.cpp>
-# Compatible MIT license, see esphome/LICENSE file.
-#
-# Note: busy pin uses LOW=busy, HIGH=idle. Configure with inverted: true in YAML.
-# Note: width=128 is the TRES value the init sequence programs, not the 122 visible columns; overriding
-# dimensions: in YAML shears the image. Not tested on V1 hardware.
-gdey0213f51.extend("Waveshare-2.13in-G-V1")
@@ -24,11 +24,3 @@ WaveshareB(
    data_rate="10MHz",
    minimum_update_interval="1s",
 )
-
-WaveshareB(
-    "waveshare-2.66in-b",
-    width=152,
-    height=296,
-    data_rate="10MHz",
-    minimum_update_interval="15s",
-)
@@ -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
@@ -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
@@ -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))
@@ -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;
  }
@@ -6,8 +6,6 @@ import esphome.codegen as cg
 from esphome.components import canbus
 from esphome.components.canbus import CONF_BIT_RATE, CanbusComponent, CanSpeed
 from esphome.components.esp32 import (
-    CONF_MINIMUM_CHIP_REVISION,
-    KEY_ESP32,
    VARIANT_ESP32,
    VARIANT_ESP32C3,
    VARIANT_ESP32C5,
@@ -22,8 +20,6 @@ from esphome.components.esp32 import (
 )
 import esphome.config_validation as cv
 from esphome.const import (
-    CONF_ADVANCED,
-    CONF_FRAMEWORK,
    CONF_ID,
    CONF_MODE,
    CONF_RX_PIN,
@@ -31,7 +27,6 @@ from esphome.const import (
    CONF_TX_PIN,
    CONF_TX_QUEUE_LEN,
 )
-import esphome.final_validate as fv
 from esphome.types import ConfigType

 CODEOWNERS = ["@Sympatron"]
@@ -54,7 +49,6 @@ CAN_MODES = {
 # See ESP-IDF Programming Guide --> API Reference --> Two-Wire Automotive Interface (TWAI)

 CAN_SPEEDS_ESP32 = {
-    "20KBPS": CanSpeed.CAN_20KBPS,
    "25KBPS": CanSpeed.CAN_25KBPS,
    "50KBPS": CanSpeed.CAN_50KBPS,
    "100KBPS": CanSpeed.CAN_100KBPS,
@@ -120,22 +114,6 @@ CONFIG_SCHEMA = canbus.CANBUS_SCHEMA.extend(
 )


-def _final_validate(config: ConfigType) -> None:
-    if get_esp32_variant() == VARIANT_ESP32 and config[CONF_BIT_RATE] == "20KBPS":
-        esp32_config = fv.full_config.get()[KEY_ESP32]
-        min_revision = esp32_config[CONF_FRAMEWORK][CONF_ADVANCED].get(
-            CONF_MINIMUM_CHIP_REVISION
-        )
-        if min_revision is None or min_revision < "2.0":
-            raise cv.Invalid(
-                "20KBPS on ESP32 requires esp32.framework.advanced.minimum_chip_revision: '2.0' or higher",
-                path=[CONF_BIT_RATE],
-            )
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
 def get_default_tx_enqueue_timeout(bit_rate: str) -> int:
    bit_rate_numeric = canbus.get_rate(bit_rate)
    bits_per_packet = 140  # ~max CAN message length
@@ -33,10 +33,6 @@ static bool get_bitrate(canbus::CanSpeed bitrate, twai_timing_config_t *t_config
    case canbus::CAN_16KBPS:
      *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_16KBITS();
      return true;
-#endif
-#if defined(USE_ESP32_VARIANT_ESP32C3) || defined(USE_ESP32_VARIANT_ESP32C6) || defined(USE_ESP32_VARIANT_ESP32C61) || \
-    defined(USE_ESP32_VARIANT_ESP32H2) || defined(USE_ESP32_VARIANT_ESP32P4) || defined(USE_ESP32_VARIANT_ESP32S2) || \
-    defined(USE_ESP32_VARIANT_ESP32S3) || (defined(USE_ESP32_VARIANT_ESP32) && CONFIG_ESP32_REV_MIN_FULL >= 200)
    case canbus::CAN_20KBPS:
      *t_config = (twai_timing_config_t) TWAI_TIMING_CONFIG_20KBITS();
      return true;
@@ -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,
@@ -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])
@@ -1,2 +0,0 @@
-CODEOWNERS = ["@tuct"]
-DOMAIN = "filter_lifetime"
@@ -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
@@ -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
@@ -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()"),
-)
@@ -1 +0,0 @@
-DOMAIN = "friedrich"
@@ -1,32 +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_MODEL, CONF_SENSOR
-from esphome.types import ConfigType
-
-AUTO_LOAD = ["climate_ir"]
-CODEOWNERS = ["@rwrozelle"]
-
-friedrich_ns = cg.esphome_ns.namespace("friedrich")
-FriedrichClimate = friedrich_ns.class_("FriedrichClimate", climate_ir.ClimateIR)
-
-Model = friedrich_ns.enum("Model", is_class=True)
-MODELS = {
-    "MW12Y3H": Model.MODEL_MW12Y3H,
-}
-
-CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(FriedrichClimate).extend(
-    {
-        cv.Optional(CONF_MODEL, default="MW12Y3H"): cv.enum(MODELS, upper=True),
-        # The unit works in Fahrenheit, so a Celsius temperature sensor cannot feed it
-        cv.Optional(CONF_SENSOR): cv.invalid(
-            "'sensor' is not supported by the Friedrich climate component"
-        ),
-    }
-)
-
-
-async def to_code(config: ConfigType) -> None:
-    remote_base.request_protocol("aeha")  # used from C++
-    var = await climate_ir.new_climate_ir(config)
-    cg.add(var.set_model(config[CONF_MODEL]))
@@ -1,234 +0,0 @@
-#include "friedrich.h"
-
-#include <cmath>
-
-#include "esphome/components/remote_base/aeha_protocol.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-namespace esphome::friedrich {
-// clang-format off
-/*
-* MW12Y3H - Currently the only supported model. Model field is retained to allow future per-model code differentiation.
-* AEHA
-* Byte0  Fixed = 0x00
-* Byte1  Fixed = 0x08
-* Byte2  Fixed = 0x08
-* Byte3  Command: Move Louver = 0x36 Off = 0x40, else Fixed = 0x7F
-* Byte4  Checksum when command, else Fixed = 0x90
-* Byte5  N/A when command, else Fixed = 0x0C
-* Byte6  N/A when command, else Temp(F), add 0x80 for On
-* Byte7  N/A when command, else Mode (Min Heat = 0xD0 and Coil Dry = 0x10 are not exposed)
-* Byte8  N/A when command, else Fan, add 0x08 for Vertical Swing
-* Byte9 N/A when command, else Fixed = 0x00 // not interested
-* Byte10 N/A when command, else Fixed = 0x00 // not interested
-* Byte11 N/A when command, else Fixed = 0x00 // not interested
-* Byte12 N/A when command, else Economy (On = 0x00, Off = 0x04)
-* Byte13 N/A when command, else CheckSum
-*/
-// clang-format on
-ESPHOME_LOG_TAG(TAG, "friedrich");
-
-static constexpr uint8_t TEMP_MIN_NOT_HEAT = 64;
-static constexpr uint8_t TEMP_DEFAULT = 72;
-static constexpr uint8_t STATE_MESSAGE_LENGTH = FriedrichClimate::STATE_MESSAGE_LENGTH;
-static constexpr uint8_t STATE_MESSAGE_LENGTH_UTIL = 5;
-static constexpr uint16_t CARRIER_ADDRESS = 0x28C6;
-static constexpr uint32_t CARRIER_FREQUENCY = 38000;
-
-static constexpr uint8_t BYTE3_POWER_OFF = 0x40;
-static constexpr uint8_t BYTE6_POWER_ON = 0x80;
-static constexpr uint8_t BYTE7_MODE_AUTO = 0x00;
-static constexpr uint8_t BYTE8_FAN_AUTO = 0x00;
-static constexpr uint8_t BYTE8_FAN_SWING = 0x08;
-
-// Every state frame: power on, economy off; bytes 6, 7, 8 and 13 are patched per state
-static constexpr uint8_t STATE_TEMPLATE[STATE_MESSAGE_LENGTH] PROGMEM = {
-    0x00, 0x08, 0x08, 0x7F, 0x90, 0x0C, BYTE6_POWER_ON, BYTE7_MODE_AUTO, BYTE8_FAN_AUTO, 0x00, 0x00, 0x00, 0x04, 0x00};
-// The off command, including its checksum (255 - byte 3)
-static constexpr uint8_t OFF_FRAME[STATE_MESSAGE_LENGTH_UTIL] PROGMEM = {0x00, 0x08, 0x08, BYTE3_POWER_OFF,
-                                                                         255 - BYTE3_POWER_OFF};
-
-struct Code {
-  uint8_t value;  // a climate enum, all of which are uint8_t
-  uint8_t code;
-};
-static constexpr Code MODES[] PROGMEM = {
-    {climate::CLIMATE_MODE_HEAT_COOL, BYTE7_MODE_AUTO},
-    {climate::CLIMATE_MODE_COOL, 0x80},
-    {climate::CLIMATE_MODE_DRY, 0x40},
-    {climate::CLIMATE_MODE_FAN_ONLY, 0xC0},
-    {climate::CLIMATE_MODE_HEAT, 0x20},
-};
-static constexpr Code FANS[] PROGMEM = {
-    {climate::CLIMATE_FAN_AUTO, BYTE8_FAN_AUTO}, {climate::CLIMATE_FAN_HIGH, 0x80},
-    {climate::CLIMATE_FAN_MEDIUM, 0x40},         {climate::CLIMATE_FAN_LOW, 0xC0},
-    {climate::CLIMATE_FAN_QUIET, 0x20},
-};
-
-// The entry whose value (or code) matches key. Entries are copied out of PROGMEM.
-template<size_t N> static optional<Code> find_entry(const Code (&table)[N], uint8_t key, bool match_code) {
-  for (const Code &slot : table) {
-    Code entry;
-    progmem_memcpy(&entry, &slot, sizeof(entry));
-    if ((match_code ? entry.code : entry.value) == key)
-      return entry;
-  }
-  return {};
-}
-
-// The temperature code is the 4-bit reversal of (F - TEMP_MIN) / TEMP_STEP; the mapping is its own inverse.
-static uint8_t reverse_nibble(uint8_t value) { return reverse_bits(value) >> 4; }
-
-static bool matches_template(const uint8_t *data, uint8_t from, uint8_t to) {
-  for (uint8_t i = from; i <= to; i++) {
-    if (data[i] != progmem_read_byte(&STATE_TEMPLATE[i]))
-      return false;
-  }
-  return true;
-}
-
-/*
- * https://gist.github.com/GeorgeDewar/11171561
- * 1. Reverse (flip) bytes 6 - 13)
- * 2. Sum those bytes
- * 3. (208 - sum) % 256
- * 4. Reverse (flip) bytes of result
- */
-static uint8_t checksum_state(const uint8_t *data) {
-  uint8_t sum = 0;
-  for (uint8_t i = 6; i < STATE_MESSAGE_LENGTH - 1; ++i) {
-    sum += reverse_bits(data[i]);
-  }
-  return reverse_bits(static_cast<uint8_t>(208 - sum));
-}
-
-static const LogString *model_to_string(Model model) {
-  switch (model) {
-    case Model::MODEL_MW12Y3H:
-    default:
-      return LOG_STR("MW12Y3H");
-  }
-}
-
-climate::ClimateTraits FriedrichClimate::traits() {
-  auto traits = ClimateIR::traits();
-  traits.set_temperature_unit(TemperatureUnit::FAHRENHEIT);
-  return traits;
-}
-
-void FriedrichClimate::setup() {
-  ClimateIR::setup();
-  // The base class defaults assume Celsius. This also discards a value saved in Celsius by an earlier version.
-  if (std::isnan(this->target_temperature) || this->target_temperature < TEMP_MIN) {
-    this->target_temperature = TEMP_DEFAULT;
-  }
-  this->target_temperature = std::min<float>(this->target_temperature, TEMP_MAX);
-}
-
-void FriedrichClimate::dump_config() {
-  // ClimateIR::dump_config() is not called: it prints the temperature range in Celsius
-  LOG_CLIMATE("", "Friedrich Climate", this);
-  ESP_LOGCONFIG(TAG,
-                "  Temperature range: %u to %u °F\n"
-                "  Model: %s",
-                TEMP_MIN, TEMP_MAX, LOG_STR_ARG(model_to_string(this->model_)));
-}
-
-void FriedrichClimate::transmit_state() {
-  if (this->mode == climate::CLIMATE_MODE_OFF) {
-    this->transmit_off_();
-    return;
-  }
-
-  ESP_LOGV(TAG, "Transmit state");
-
-  // Snap to what the unit accepts (even values, 64°F minimum unless heating) and store it,
-  // so the state published after this call matches the frame sent.
-  const uint8_t effective_min = this->mode == climate::CLIMATE_MODE_HEAT ? TEMP_MIN : TEMP_MIN_NOT_HEAT;
-  uint8_t temperature = (uint8_t) roundf(clamp<float>(this->target_temperature, effective_min, TEMP_MAX));
-  temperature += temperature % 2;
-  this->target_temperature = temperature;
-
-  const auto mode = find_entry(MODES, this->mode, false);
-  const auto fan = find_entry(FANS, this->fan_mode.value_or(climate::CLIMATE_FAN_AUTO), false);
-
-  uint8_t frame[STATE_MESSAGE_LENGTH];
-  progmem_memcpy(frame, STATE_TEMPLATE, sizeof(frame));
-  frame[6] |= reverse_nibble((temperature - TEMP_MIN) / TEMP_STEP);
-  frame[7] = mode.has_value() ? mode->code : BYTE7_MODE_AUTO;
-  frame[8] = fan.has_value() ? fan->code : BYTE8_FAN_AUTO;
-  if (this->swing_mode != climate::CLIMATE_SWING_OFF)
-    frame[8] |= BYTE8_FAN_SWING;
-  frame[STATE_MESSAGE_LENGTH - 1] = checksum_state(frame);
-
-  this->transmit_(frame, sizeof(frame));
-}
-
-void FriedrichClimate::transmit_off_() {
-  ESP_LOGV(TAG, "Transmit off");
-
-  uint8_t frame[STATE_MESSAGE_LENGTH_UTIL];
-  progmem_memcpy(frame, OFF_FRAME, sizeof(frame));
-  this->transmit_(frame, sizeof(frame));
-}
-
-void FriedrichClimate::transmit_(const uint8_t *data, uint8_t len) {
-  ESP_LOGV(TAG, "Transmit message");
-
-  auto transmit = this->transmitter_->transmit();
-  auto *dst = transmit.get_data();
-  dst->set_carrier_frequency(CARRIER_FREQUENCY);
-  remote_base::AEHAProtocol().encode(dst, CARRIER_ADDRESS, data, len);
-  transmit.perform();
-}
-
-bool FriedrichClimate::on_receive(remote_base::RemoteReceiveData src) {
-  ESP_LOGV(TAG, "Received message");
-  const auto odata = remote_base::AEHAProtocol().decode(src);
-  if (!odata.has_value())
-    return false;
-  const auto &d = odata->data;
-  // Other vendors also use AEHA; only accept frames with our address and fixed header bytes.
-  if (odata->address != CARRIER_ADDRESS || d.size() < STATE_MESSAGE_LENGTH_UTIL || !matches_template(d.data(), 0, 2))
-    return false;
-
-  if (d.size() == STATE_MESSAGE_LENGTH_UTIL) {
-    // Not looking for other types of messages
-    if (d[3] != BYTE3_POWER_OFF || d[4] != 255 - d[3])
-      return false;
-    ESP_LOGV(TAG, "Received off message");
-    this->mode = climate::CLIMATE_MODE_OFF;
-    this->publish_state();
-    return true;
-  }
-
-  if (d.size() != STATE_MESSAGE_LENGTH || d[STATE_MESSAGE_LENGTH - 1] != checksum_state(d.data()) ||
-      !matches_template(d.data(), 3, 5))
-    return false;
-
-  // Ignore frames with a mode this component does not expose (e.g. MIN_HEAT, COIL_DRY)
-  const auto mode = find_entry(MODES, d[7], true);
-  if (!mode.has_value()) {
-    ESP_LOGV(TAG, "Ignoring unknown mode 0x%02X", d[7]);
-    return false;
-  }
-  this->mode = static_cast<climate::ClimateMode>(mode->value);
-
-  // State frames always carry the power-on flag in bit 7 (power off is the separate 5-byte frame), so it is
-  // stripped rather than acted on
-  const uint8_t temp_code = d[6] & ~BYTE6_POWER_ON;
-  const uint8_t temp_index = reverse_nibble(temp_code);
-  if (temp_code <= 0x0F && temp_index <= (TEMP_MAX - TEMP_MIN) / TEMP_STEP)
-    this->target_temperature = TEMP_MIN + temp_index * TEMP_STEP;
-
-  this->swing_mode = (d[8] & BYTE8_FAN_SWING) ? climate::CLIMATE_SWING_VERTICAL : climate::CLIMATE_SWING_OFF;
-  const auto fan = find_entry(FANS, d[8] & ~BYTE8_FAN_SWING, true);
-  this->fan_mode = fan.has_value() ? static_cast<climate::ClimateFanMode>(fan->value) : climate::CLIMATE_FAN_AUTO;
-
-  this->publish_state();
-  return true;
-}
-
-}  // namespace esphome::friedrich
@@ -1,47 +0,0 @@
-#pragma once
-
-#include "esphome/components/climate_ir/climate_ir.h"
-
-namespace esphome::friedrich {
-
-// Extension point for other units: add new models here and branch on model_ where they differ.
-// The default must stay MW12Y3H so existing configurations do not change.
-enum class Model : uint8_t {
-  MODEL_MW12Y3H,  // MW12Y3H built from a remote that only provided Fahrenheit
-};
-
-class FriedrichClimate : public climate_ir::ClimateIR {
- public:
-  // The unit reports temperatures in Fahrenheit (see traits()); the unit only accepts even values.
-  static constexpr uint8_t TEMP_MIN = 60;  // actually 64 for anything but heating
-  static constexpr uint8_t TEMP_MAX = 88;
-  static constexpr uint8_t TEMP_STEP = 2;
-  static constexpr uint8_t STATE_MESSAGE_LENGTH = 14;
-
-  FriedrichClimate()
-      : ClimateIR(TEMP_MIN, TEMP_MAX, TEMP_STEP, true, true,
-                  {climate::CLIMATE_FAN_AUTO, climate::CLIMATE_FAN_HIGH, climate::CLIMATE_FAN_MEDIUM,
-                   climate::CLIMATE_FAN_LOW, climate::CLIMATE_FAN_QUIET},
-                  {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL}) {}
-
-  void set_model(Model model) { this->model_ = model; }
-
- protected:
-  void setup() override;
-  void dump_config() override;
-  climate::ClimateTraits traits() override;
-  /// Transmit via IR the state of this climate controller.
-  void transmit_state() override;
-  /// Transmit via IR power off command.
-  void transmit_off_();
-
-  /// Parse incoming message
-  bool on_receive(remote_base::RemoteReceiveData src) override;
-
-  /// Transmit message as IR pulses
-  void transmit_(const uint8_t *data, uint8_t len);
-
-  Model model_{Model::MODEL_MW12Y3H};
-};
-
-}  // namespace esphome::friedrich
@@ -3,7 +3,6 @@
 #include "esphome/components/climate/climate.h"
 #include "esphome/components/uart/uart.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/progmem.h"
 #include "hon_climate.h"
 #include "hon_packet.h"

@@ -21,27 +20,6 @@ constexpr size_t ALARM_STATUS_REQUEST_INTERVAL_MS = 600000;
 const uint8_t ONE_BUF[] = {0x00, 0x01};
 const uint8_t ZERO_BUF[] = {0x00, 0x00};

-// Alarm texts indexed by alarm code; the last entry is the fallback for unknown codes
-PROGMEM_STRING_TABLE(
-    HonAlarmMessages, "Outdoor module failure", "Outdoor defrost sensor failure",
-    "Outdoor compressor exhaust sensor failure", "Outdoor EEPROM abnormality", "Indoor coil sensor failure",
-    "Indoor-outdoor communication failure", "Power supply overvoltage protection",
-    "Communication failure between panel and indoor unit", "Outdoor compressor overheat protection",
-    "Outdoor environmental sensor abnormality", "Full water protection", "Indoor EEPROM failure",
-    "Outdoor out air sensor failure", "CBD and module communication failure", "Indoor DC fan failure",
-    "Outdoor DC fan failure", "Door switch failure", "Dust filter needs cleaning reminder", "Water shortage protection",
-    "Humidity sensor failure", "Indoor temperature sensor failure", "Manipulator limit failure",
-    "Indoor PM2.5 sensor failure", "Outdoor PM2.5 sensor failure", "Indoor heating overload/high load alarm",
-    "Outdoor AC current protection", "Outdoor compressor operation abnormality", "Outdoor DC current protection",
-    "Outdoor no-load failure", "CT current abnormality", "Indoor cooling freeze protection",
-    "High and low pressure protection", "Compressor out air temperature is too high",
-    "Outdoor evaporator sensor failure", "Outdoor cooling overload", "Water pump drainage failure",
-    "Three-phase power supply failure", "Four-way valve failure", "External alarm/scraper flow switch failure",
-    "Temperature cutoff protection alarm", "Different mode operation failure", "Electronic expansion valve failure",
-    "Dual heat source sensor Tw failure", "Communication failure with the wired controller",
-    "Indoor unit address duplication failure", "50Hz zero crossing failure", "Outdoor unit failure",
-    "Formaldehyde sensor failure", "VOC sensor failure", "CO2 sensor failure", "Firewall failure", "Unknown");
-
 HonClimate::HonClimate()
    : cleaning_status_(CleaningState::NO_CLEANING), got_valid_outdoor_temp_(false), active_alarms_{0x00, 0x00, 0x00,
                                                                                                   0x00, 0x00, 0x00,
@@ -709,17 +687,9 @@ void HonClimate::process_alarm_message_(const uint8_t *packet, uint8_t size, boo
            if ((packet[2 + i] & alarm_bit) != (this->active_alarms_[i] & alarm_bit)) {
              bool alarm_status = (packet[2 + i] & alarm_bit) != 0;
              int log_level = alarm_status ? ESPHOME_LOG_LEVEL_WARN : ESPHOME_LOG_LEVEL_INFO;
-#ifdef USE_ESP8266
-              // Static so a delayed on_alarm automation can still read it, but only until the next
-              // alarm change, including a later one in this packet; `code` stays correct
-              static char alarm_message[HonAlarmMessages::MAX_LENGTH + 1];
-              ESPHOME_strncpy_P(alarm_message,
-                                reinterpret_cast<const char *>(
-                                    HonAlarmMessages::get_progmem_str(alarm_code, HonAlarmMessages::LAST_INDEX)),
-                                sizeof(alarm_message));
-#else
-              const char *alarm_message = HonAlarmMessages::get_progmem_str(alarm_code, HonAlarmMessages::LAST_INDEX);
-#endif
+              const char *alarm_message = alarm_code < esphome::haier::hon_protocol::HON_ALARM_COUNT
+                                              ? esphome::haier::hon_protocol::HON_ALARM_MESSAGES[alarm_code].c_str()
+                                              : "Unknown";
              esp_log_printf_(log_level, TAG, __LINE__, "Alarm %s (%d): %s", alarm_status ? "activated" : "deactivated",
                              alarm_code, alarm_message);
              if (alarm_status) {
@@ -197,4 +197,60 @@ enum class SubcommandsControl : uint16_t {
                                  // content: all values like in status packet)
 };

+const std::string HON_ALARM_MESSAGES[] = {
+    "Outdoor module failure",
+    "Outdoor defrost sensor failure",
+    "Outdoor compressor exhaust sensor failure",
+    "Outdoor EEPROM abnormality",
+    "Indoor coil sensor failure",
+    "Indoor-outdoor communication failure",
+    "Power supply overvoltage protection",
+    "Communication failure between panel and indoor unit",
+    "Outdoor compressor overheat protection",
+    "Outdoor environmental sensor abnormality",
+    "Full water protection",
+    "Indoor EEPROM failure",
+    "Outdoor out air sensor failure",
+    "CBD and module communication failure",
+    "Indoor DC fan failure",
+    "Outdoor DC fan failure",
+    "Door switch failure",
+    "Dust filter needs cleaning reminder",
+    "Water shortage protection",
+    "Humidity sensor failure",
+    "Indoor temperature sensor failure",
+    "Manipulator limit failure",
+    "Indoor PM2.5 sensor failure",
+    "Outdoor PM2.5 sensor failure",
+    "Indoor heating overload/high load alarm",
+    "Outdoor AC current protection",
+    "Outdoor compressor operation abnormality",
+    "Outdoor DC current protection",
+    "Outdoor no-load failure",
+    "CT current abnormality",
+    "Indoor cooling freeze protection",
+    "High and low pressure protection",
+    "Compressor out air temperature is too high",
+    "Outdoor evaporator sensor failure",
+    "Outdoor cooling overload",
+    "Water pump drainage failure",
+    "Three-phase power supply failure",
+    "Four-way valve failure",
+    "External alarm/scraper flow switch failure",
+    "Temperature cutoff protection alarm",
+    "Different mode operation failure",
+    "Electronic expansion valve failure",
+    "Dual heat source sensor Tw failure",
+    "Communication failure with the wired controller",
+    "Indoor unit address duplication failure",
+    "50Hz zero crossing failure",
+    "Outdoor unit failure",
+    "Formaldehyde sensor failure",
+    "VOC sensor failure",
+    "CO2 sensor failure",
+    "Firewall failure",
+};
+
+constexpr size_t HON_ALARM_COUNT = sizeof(HON_ALARM_MESSAGES) / sizeof(HON_ALARM_MESSAGES[0]);
+
 }  // namespace esphome::haier::hon_protocol
@@ -1,2 +0,0 @@
-DOMAIN = "haier_tundra"
-CODEOWNERS = ["@fauxpark"]
@@ -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)
@@ -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
@@ -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
@@ -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])
@@ -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
@@ -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
@@ -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])
@@ -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
@@ -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
@@ -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
-)
@@ -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
@@ -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
@@ -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]))
@@ -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))
@@ -3,5 +3,4 @@ DOMAIN = "ili9xxx"
 DEPRECATED_COMPONENT = """
 The 'ili9xxx' component is deprecated and no new models will be added to it.
 New model PRs should target the newer and more performant 'mipi_spi' component.
-It will be removed in ESPHome 2027.5.0.
 """
@@ -220,10 +220,8 @@ FINAL_VALIDATE_SCHEMA = final_validate


 async def to_code(config: ConfigType) -> None:
-    # Remove before 2027.5.0
    LOGGER.warning(
-        "The 'ili9xxx' component is deprecated and will be removed in ESPHome 2027.5.0, "
-        "migrate to 'mipi_spi' instead."
+        "The 'ili9xxx' component is deprecated, it is recommended to use 'mipi_spi' instead."
    )
    rhs = MODELS[config[CONF_MODEL]].new()
    var = cg.Pvariable(config[CONF_ID], rhs)
@@ -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 {
@@ -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'"),
@@ -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;
@@ -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;
@@ -13,24 +13,6 @@ static const uint8_t INA3221_REGISTER_CHANNEL2_SHUNT_VOLTAGE = 0x03;
 static const uint8_t INA3221_REGISTER_CHANNEL2_BUS_VOLTAGE = 0x04;
 static const uint8_t INA3221_REGISTER_CHANNEL3_SHUNT_VOLTAGE = 0x05;
 static const uint8_t INA3221_REGISTER_CHANNEL3_BUS_VOLTAGE = 0x06;
-#ifdef USE_INA3221_ALERT_LIMITS
-static constexpr uint8_t INA3221_REGISTER_CHANNEL1_CRITICAL_ALERT = 0x07;
-static constexpr uint8_t INA3221_REGISTER_CHANNEL1_WARNING_ALERT = 0x0A;
-#endif
-#ifdef USE_INA3221_SUMMATION
-static constexpr uint8_t INA3221_REGISTER_SHUNT_VOLTAGE_SUM = 0x0D;
-static constexpr uint8_t INA3221_REGISTER_MASK_ENABLE = 0x0F;
-#endif
-
-// Configuration register: bit 15 resets the chip, bits 14..12 enable channels 1..3 (the same bit
-// positions select channels for summation in the mask/enable register) and bits 2..0 set the mode.
-// Code generation fills in the averaging and conversion time fields.
-static constexpr uint16_t INA3221_CONFIG_RESET = 0x8000;
-static constexpr uint16_t INA3221_CONFIG_CHANNEL1_ENABLE = 0x4000;
-static constexpr uint16_t INA3221_CONFIG_CHANNEL_MASK = 0x7000;
-static constexpr uint16_t INA3221_CONFIG_MODE_MASK = 0x0007;
-
-static constexpr uint32_t READ_TIMEOUT_ID = 0;

 // Addresses:
 // A0 = GND -> 0x40
@@ -39,38 +21,37 @@ static constexpr uint32_t READ_TIMEOUT_ID = 0;
 // A0 = SCL -> 0x43

 void INA3221Component::setup() {
-  if (!this->write_byte_16(INA3221_REGISTER_CONFIG, INA3221_CONFIG_RESET)) {
+  // Config Register
+  // 0bx000000000000000 << 15 RESET Bit (1 -> trigger reset)
+  if (!this->write_byte_16(INA3221_REGISTER_CONFIG, 0x8000)) {
    this->mark_failed();
    return;
  }
  delay(1);

-  if (!this->write_byte_16(INA3221_REGISTER_CONFIG, this->config_)) {
+  uint16_t config = 0;
+  // 0b0xxx000000000000 << 12 Channel Enables (1 -> ON)
+  if (this->channels_[0].exists()) {
+    config |= 0b0100000000000000;
+  }
+  if (this->channels_[1].exists()) {
+    config |= 0b0010000000000000;
+  }
+  if (this->channels_[2].exists()) {
+    config |= 0b0001000000000000;
+  }
+  // 0b0000xxx000000000 << 9 Averaging Mode (0 -> 1 sample, 111 -> 1024 samples)
+  config |= 0b0000000000000000;
+  // 0b0000000xxx000000 << 6 Bus Voltage Conversion time (100 -> 1.1ms, 111 -> 8.244 ms)
+  config |= 0b0000000111000000;
+  // 0b0000000000xxx000 << 3 Shunt Voltage Conversion time (same as above)
+  config |= 0b0000000000111000;
+  // 0b0000000000000xxx << 0 Operating mode (111 -> Shunt and bus, continuous)
+  config |= 0b0000000000000111;
+  if (!this->write_byte_16(INA3221_REGISTER_CONFIG, config)) {
    this->mark_failed();
    return;
  }
-
-#ifdef USE_INA3221_ALERT_LIMITS
-  for (uint8_t i = 0; i < 3; i++) {
-    const INA3221Channel &channel = this->channels_[i];
-    if ((channel.critical_limit_ != 0 &&
-         !this->write_byte_16(INA3221_REGISTER_CHANNEL1_CRITICAL_ALERT + i, channel.critical_limit_)) ||
-        (channel.warning_limit_ != 0 &&
-         !this->write_byte_16(INA3221_REGISTER_CHANNEL1_WARNING_ALERT + i, channel.warning_limit_))) {
-      this->mark_failed();
-      return;
-    }
-  }
-#endif
-
-#ifdef USE_INA3221_SUMMATION
-  // Sum the shunt voltages of every enabled channel
-  if (this->sum_shunt_voltage_sensor_ != nullptr &&
-      !this->write_byte_16(INA3221_REGISTER_MASK_ENABLE, this->config_ & INA3221_CONFIG_CHANNEL_MASK)) {
-    this->mark_failed();
-    return;
-  }
-#endif
 }

 void INA3221Component::dump_config() {
@@ -80,10 +61,6 @@ void INA3221Component::dump_config() {
    ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
  }
  LOG_UPDATE_INTERVAL(this);
-  ESP_LOGCONFIG(TAG, "  Config register: 0x%04X", this->config_);
-  if (this->single_shot_wait_ms_ != 0) {
-    ESP_LOGCONFIG(TAG, "  Single-shot conversion: %u ms", this->single_shot_wait_ms_);
-  }

  LOG_SENSOR("  ", "Bus Voltage #1", this->channels_[0].bus_voltage_sensor_);
  LOG_SENSOR("  ", "Shunt Voltage #1", this->channels_[0].shunt_voltage_sensor_);
@@ -97,11 +74,6 @@ void INA3221Component::dump_config() {
  LOG_SENSOR("  ", "Shunt Voltage #3", this->channels_[2].shunt_voltage_sensor_);
  LOG_SENSOR("  ", "Current #3", this->channels_[2].current_sensor_);
  LOG_SENSOR("  ", "Power #3", this->channels_[2].power_sensor_);
-#ifdef USE_INA3221_SUMMATION
-  LOG_SENSOR("  ", "Sum Shunt Voltage", this->sum_shunt_voltage_sensor_);
-  LOG_SENSOR("  ", "Sum Current", this->sum_current_sensor_);
-  LOG_SENSOR("  ", "Sum Power", this->sum_power_sensor_);
-#endif
 }

 inline uint8_t ina3221_bus_voltage_register(int channel) { return 0x02 + channel * 2; }
@@ -109,36 +81,11 @@ inline uint8_t ina3221_bus_voltage_register(int channel) { return 0x02 + channel
 inline uint8_t ina3221_shunt_voltage_register(int channel) { return 0x01 + channel * 2; }

 void INA3221Component::update() {
-  if (this->single_shot_wait_ms_ == 0) {
-    this->read_data_();
-    return;
-  }
-  // In single-shot mode, writing the configuration register starts one conversion of every channel
-  if (!this->write_byte_16(INA3221_REGISTER_CONFIG, this->config_)) {
-    this->status_set_warning();
-    return;
-  }
-  this->set_timeout(READ_TIMEOUT_ID, this->single_shot_wait_ms_, [this]() { this->read_data_(); });
-}
-
-void INA3221Component::read_data_() {
-#ifdef USE_INA3221_SUMMATION
-  // The software sums need every enabled channel's readings, not only the ones with their own sensors
-  const bool sum_all = this->sum_current_sensor_ != nullptr || this->sum_power_sensor_ != nullptr;
-  float total_current_a = 0.0f;
-  float total_power_w = 0.0f;
-#else
-  constexpr bool sum_all = false;
-#endif
-
  for (int i = 0; i < 3; i++) {
-    if ((this->config_ & (INA3221_CONFIG_CHANNEL1_ENABLE >> i)) == 0) {
-      continue;
-    }
    INA3221Channel &channel = this->channels_[i];
    float bus_voltage_v = NAN, current_a = NAN;
    uint16_t raw;
-    if (sum_all || channel.should_measure_bus_voltage()) {
+    if (channel.should_measure_bus_voltage()) {
      if (!this->read_byte_16(ina3221_bus_voltage_register(i), &raw)) {
        this->status_set_warning();
        return;
@@ -147,7 +94,7 @@ void INA3221Component::read_data_() {
      if (channel.bus_voltage_sensor_ != nullptr)
        channel.bus_voltage_sensor_->publish_state(bus_voltage_v);
    }
-    if (sum_all || channel.should_measure_shunt_voltage()) {
+    if (channel.should_measure_shunt_voltage()) {
      if (!this->read_byte_16(ina3221_shunt_voltage_register(i), &raw)) {
        this->status_set_warning();
        return;
@@ -162,42 +109,17 @@ void INA3221Component::read_data_() {
    if (channel.power_sensor_ != nullptr) {
      channel.power_sensor_->publish_state(bus_voltage_v * current_a);
    }
-#ifdef USE_INA3221_SUMMATION
-    if (sum_all) {
-      total_current_a += current_a;
-      total_power_w += bus_voltage_v * current_a;
-    }
-#endif
  }
-
-#ifdef USE_INA3221_SUMMATION
-  if (this->sum_shunt_voltage_sensor_ != nullptr) {
-    uint16_t raw;
-    if (!this->read_byte_16(INA3221_REGISTER_SHUNT_VOLTAGE_SUM, &raw)) {
-      this->status_set_warning();
-      return;
-    }
-    // 40 uV per step, held in bits 15..1
-    this->sum_shunt_voltage_sensor_->publish_state(int16_t(raw) * 40.0f / 2.0f / 1000000.0f);
-  }
-  if (this->sum_current_sensor_ != nullptr) {
-    this->sum_current_sensor_->publish_state(total_current_a);
-  }
-  if (this->sum_power_sensor_ != nullptr) {
-    this->sum_power_sensor_->publish_state(total_power_w);
-  }
-#endif
-}
-
-void INA3221Component::on_powerdown() {
-  // Mode 0 powers the chip down; setup() resets it on the next boot
-  this->write_byte_16(INA3221_REGISTER_CONFIG, static_cast<uint16_t>(this->config_ & ~INA3221_CONFIG_MODE_MASK));
 }

 void INA3221Component::set_shunt_resistance(int channel, float resistance_ohm) {
  this->channels_[channel].shunt_resistance_ = resistance_ohm;
 }

+bool INA3221Component::INA3221Channel::exists() {
+  return this->bus_voltage_sensor_ != nullptr || this->shunt_voltage_sensor_ != nullptr ||
+         this->current_sensor_ != nullptr || this->power_sensor_ != nullptr;
+}
 bool INA3221Component::INA3221Channel::should_measure_shunt_voltage() {
  return this->shunt_voltage_sensor_ != nullptr || this->current_sensor_ != nullptr || this->power_sensor_ != nullptr;
 }
@@ -7,17 +7,10 @@
 namespace esphome::ina3221 {

 class INA3221Component final : public PollingComponent, public i2c::I2CDevice {
-#ifdef USE_INA3221_SUMMATION
-  SUB_SENSOR(sum_shunt_voltage)
-  SUB_SENSOR(sum_current)
-  SUB_SENSOR(sum_power)
-#endif
-
 public:
  void setup() override;
  void dump_config() override;
  void update() override;
-  void on_powerdown() override;

  void set_bus_voltage_sensor(int channel, sensor::Sensor *obj) { this->channels_[channel].bus_voltage_sensor_ = obj; }
  void set_shunt_voltage_sensor(int channel, sensor::Sensor *obj) {
@@ -26,35 +19,19 @@ class INA3221Component final : public PollingComponent, public i2c::I2CDevice {
  void set_current_sensor(int channel, sensor::Sensor *obj) { this->channels_[channel].current_sensor_ = obj; }
  void set_power_sensor(int channel, sensor::Sensor *obj) { this->channels_[channel].power_sensor_ = obj; }
  void set_shunt_resistance(int channel, float resistance_ohm);
-  /// Configuration register value built by code generation: channel enables, averaging, conversion times, mode
-  void set_config_register(uint16_t config) { this->config_ = config; }
-  /// Time one single-shot conversion of every enabled channel takes; zero means continuous mode
-  void set_single_shot_wait_ms(uint16_t wait_ms) { this->single_shot_wait_ms_ = wait_ms; }
-#ifdef USE_INA3221_ALERT_LIMITS
-  void set_warning_limit(int channel, uint16_t reg) { this->channels_[channel].warning_limit_ = reg; }
-  void set_critical_limit(int channel, uint16_t reg) { this->channels_[channel].critical_limit_ = reg; }
-#endif

 protected:
-  void read_data_();
-
  struct INA3221Channel {
    float shunt_resistance_{0.1f};
    sensor::Sensor *bus_voltage_sensor_{nullptr};
    sensor::Sensor *shunt_voltage_sensor_{nullptr};
    sensor::Sensor *current_sensor_{nullptr};
    sensor::Sensor *power_sensor_{nullptr};
-#ifdef USE_INA3221_ALERT_LIMITS
-    // Alert limit register values; zero keeps the chip default, which never trips
-    uint16_t warning_limit_{0};
-    uint16_t critical_limit_{0};
-#endif

+    bool exists();
    bool should_measure_shunt_voltage();
    bool should_measure_bus_voltage();
  } channels_[3];
-  uint16_t config_{0};
-  uint16_t single_shot_wait_ms_{0};
 };

 }  // namespace esphome::ina3221
@@ -1,8 +1,5 @@
-from typing import Any
-
 import esphome.codegen as cg
 from esphome.components import i2c, sensor
-from esphome.components.const import CONF_ADC_AVERAGING, CONF_ADC_TIME
 import esphome.config_validation as cv
 from esphome.const import (
    CONF_BUS_VOLTAGE,
@@ -11,7 +8,6 @@ from esphome.const import (
    CONF_POWER,
    CONF_SHUNT_RESISTANCE,
    CONF_SHUNT_VOLTAGE,
-    CONF_UPDATE_INTERVAL,
    DEVICE_CLASS_CURRENT,
    DEVICE_CLASS_POWER,
    DEVICE_CLASS_VOLTAGE,
@@ -27,195 +23,69 @@ DEPENDENCIES = ["i2c"]
 CONF_CHANNEL_1 = "channel_1"
 CONF_CHANNEL_2 = "channel_2"
 CONF_CHANNEL_3 = "channel_3"
-CONF_CONTINUOUS_MODE = "continuous_mode"
-CONF_WARNING_CURRENT_LIMIT = "warning_current_limit"
-CONF_CRITICAL_CURRENT_LIMIT = "critical_current_limit"
-CONF_SUM_SHUNT_VOLTAGE = "sum_shunt_voltage"
-CONF_SUM_CURRENT = "sum_current"
-CONF_SUM_POWER = "sum_power"
-
-CHANNELS = (CONF_CHANNEL_1, CONF_CHANNEL_2, CONF_CHANNEL_3)
-
-# Configuration register layout: channel enables in bits 14..12, averaging in 11..9,
-# bus conversion time in 8..6, shunt conversion time in 5..3, operating mode in 2..0
-CHANNEL_ENABLE_BITS = (1 << 14, 1 << 13, 1 << 12)
-ADC_AVERAGING_SHIFT = 9
-ADC_TIME_BUS_SHIFT = 6
-ADC_TIME_SHUNT_SHIFT = 3
-MODE_SINGLE_SHOT = 0b011
-MODE_CONTINUOUS = 0b111
-
-# Register field value by sample count and by conversion time in microseconds
-ADC_AVERAGING = {1: 0, 4: 1, 16: 2, 64: 3, 128: 4, 256: 5, 512: 6, 1024: 7}
-ADC_TIMES_US = {140: 0, 204: 1, 332: 2, 588: 3, 1100: 4, 2116: 5, 4156: 6, 8244: 7}
-
-# Alert limits are shunt voltages in 40 uV steps, held in bits 15..3
-ALERT_LIMIT_LSB_V = 40e-6
-ALERT_LIMIT_MAX_V = 0x0FFF * ALERT_LIMIT_LSB_V
-# Headroom on top of the computed conversion time before the results are read
-SINGLE_SHOT_MARGIN_MS = 5

 ina3221_ns = cg.esphome_ns.namespace("ina3221")
 INA3221Component = ina3221_ns.class_(
    "INA3221Component", cg.PollingComponent, i2c.I2CDevice
 )

-VOLTAGE_SCHEMA = sensor.sensor_schema(
-    unit_of_measurement=UNIT_VOLT,
-    accuracy_decimals=2,
-    device_class=DEVICE_CLASS_VOLTAGE,
-    state_class=STATE_CLASS_MEASUREMENT,
-)
-CURRENT_SCHEMA = sensor.sensor_schema(
-    unit_of_measurement=UNIT_AMPERE,
-    accuracy_decimals=2,
-    device_class=DEVICE_CLASS_CURRENT,
-    state_class=STATE_CLASS_MEASUREMENT,
-)
-POWER_SCHEMA = sensor.sensor_schema(
-    unit_of_measurement=UNIT_WATT,
-    accuracy_decimals=2,
-    device_class=DEVICE_CLASS_POWER,
-    state_class=STATE_CLASS_MEASUREMENT,
-)
-CURRENT_LIMIT_SCHEMA = cv.All(cv.current, cv.Range(min=0.0, min_included=False))
-
-
-def validate_adc_time(value: Any) -> int:
-    value = cv.positive_time_period_microseconds(value).total_microseconds
-    return cv.one_of(*ADC_TIMES_US, int=True)(value)
-
-
-def validate_alert_limits(config: ConfigType) -> ConfigType:
-    shunt = config[CONF_SHUNT_RESISTANCE]
-    for key in (CONF_WARNING_CURRENT_LIMIT, CONF_CRITICAL_CURRENT_LIMIT):
-        if (limit := config.get(key)) is None:
-            continue
-        if limit * shunt > ALERT_LIMIT_MAX_V:
-            raise cv.Invalid(
-                f"{key} times shunt_resistance exceeds the "
-                f"{ALERT_LIMIT_MAX_V * 1000:.1f} mV alert range",
-                path=[key],
-            )
-        if alert_limit_register(limit, shunt) == 0:
-            raise cv.Invalid(
-                f"{key} times shunt_resistance is below the "
-                f"{ALERT_LIMIT_LSB_V * 1e6:.0f} µV alert resolution",
-                path=[key],
-            )
-    return config
-
-
-INA3221_CHANNEL_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.Optional(CONF_BUS_VOLTAGE): VOLTAGE_SCHEMA,
-            cv.Optional(CONF_SHUNT_VOLTAGE): VOLTAGE_SCHEMA,
-            cv.Optional(CONF_CURRENT): CURRENT_SCHEMA,
-            cv.Optional(CONF_POWER): POWER_SCHEMA,
-            cv.Optional(CONF_SHUNT_RESISTANCE, default=0.1): cv.All(
-                cv.resistance, cv.Range(min=0.0, max=32.0)
-            ),
-            cv.Optional(CONF_WARNING_CURRENT_LIMIT): CURRENT_LIMIT_SCHEMA,
-            cv.Optional(CONF_CRITICAL_CURRENT_LIMIT): CURRENT_LIMIT_SCHEMA,
-        }
-    ),
-    cv.has_at_least_one_key(
-        CONF_BUS_VOLTAGE,
-        CONF_SHUNT_VOLTAGE,
-        CONF_CURRENT,
-        CONF_POWER,
-        CONF_WARNING_CURRENT_LIMIT,
-        CONF_CRITICAL_CURRENT_LIMIT,
-    ),
-    validate_alert_limits,
+INA3221_CHANNEL_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_BUS_VOLTAGE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_SHUNT_VOLTAGE): sensor.sensor_schema(
+            unit_of_measurement=UNIT_VOLT,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_VOLTAGE,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_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_POWER): sensor.sensor_schema(
+            unit_of_measurement=UNIT_WATT,
+            accuracy_decimals=2,
+            device_class=DEVICE_CLASS_POWER,
+            state_class=STATE_CLASS_MEASUREMENT,
+        ),
+        cv.Optional(CONF_SHUNT_RESISTANCE, default=0.1): cv.All(
+            cv.resistance, cv.Range(min=0.0, max=32.0)
+        ),
+    }
 )

-
-def adc_times_us(config: ConfigType) -> tuple[int, int]:
-    """Return the bus and shunt conversion times in microseconds."""
-    adc_time = config[CONF_ADC_TIME]
-    if isinstance(adc_time, dict):
-        return adc_time[CONF_BUS_VOLTAGE], adc_time[CONF_SHUNT_VOLTAGE]
-    return adc_time, adc_time
-
-
-def single_shot_wait_ms(config: ConfigType) -> int:
-    """Time one conversion of every enabled channel takes, plus headroom."""
-    bus_us, shunt_us = adc_times_us(config)
-    channels = sum(1 for channel in CHANNELS if channel in config)
-    total_us = (bus_us + shunt_us) * config[CONF_ADC_AVERAGING] * channels
-    return -(-total_us // 1000) + SINGLE_SHOT_MARGIN_MS
-
-
-def validate_single_shot_interval(config: ConfigType) -> ConfigType:
-    if config[CONF_CONTINUOUS_MODE]:
-        return config
-    wait_ms = single_shot_wait_ms(config)
-    if config[CONF_UPDATE_INTERVAL].total_milliseconds <= wait_ms:
-        raise cv.Invalid(
-            f"A single-shot conversion of all channels takes {wait_ms} ms, which does "
-            f"not fit in the update_interval; lower {CONF_ADC_AVERAGING} or "
-            f"{CONF_ADC_TIME}, or raise the interval",
-            path=[CONF_UPDATE_INTERVAL],
-        )
-    return config
-
-
-CONFIG_SCHEMA = cv.All(
+CONFIG_SCHEMA = (
    cv.Schema(
        {
            cv.GenerateID(): cv.declare_id(INA3221Component),
            cv.Optional(CONF_CHANNEL_1): INA3221_CHANNEL_SCHEMA,
            cv.Optional(CONF_CHANNEL_2): INA3221_CHANNEL_SCHEMA,
            cv.Optional(CONF_CHANNEL_3): INA3221_CHANNEL_SCHEMA,
-            cv.Optional(CONF_CONTINUOUS_MODE, default=True): cv.boolean,
-            cv.Optional(CONF_ADC_AVERAGING, default=1): cv.one_of(
-                *ADC_AVERAGING, int=True
-            ),
-            cv.Optional(CONF_ADC_TIME, default="8244us"): cv.Any(
-                validate_adc_time,
-                cv.Schema(
-                    {
-                        cv.Required(CONF_BUS_VOLTAGE): validate_adc_time,
-                        cv.Required(CONF_SHUNT_VOLTAGE): validate_adc_time,
-                    }
-                ),
-            ),
-            cv.Optional(CONF_SUM_SHUNT_VOLTAGE): VOLTAGE_SCHEMA,
-            cv.Optional(CONF_SUM_CURRENT): CURRENT_SCHEMA,
-            cv.Optional(CONF_SUM_POWER): POWER_SCHEMA,
        }
    )
    .extend(cv.polling_component_schema("60s"))
-    .extend(i2c.i2c_device_schema(0x40)),
-    cv.has_at_least_one_key(*CHANNELS),
-    validate_single_shot_interval,
+    .extend(i2c.i2c_device_schema(0x40))
 )


-def alert_limit_register(current_a: float, shunt_ohm: float) -> int:
-    return round(current_a * shunt_ohm / ALERT_LIMIT_LSB_V) << 3
-
-
 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)

-    bus_us, shunt_us = adc_times_us(config)
-    register = (
-        ADC_AVERAGING[config[CONF_ADC_AVERAGING]] << ADC_AVERAGING_SHIFT
-        | ADC_TIMES_US[bus_us] << ADC_TIME_BUS_SHIFT
-        | ADC_TIMES_US[shunt_us] << ADC_TIME_SHUNT_SHIFT
-        | (MODE_CONTINUOUS if config[CONF_CONTINUOUS_MODE] else MODE_SINGLE_SHOT)
-    )
-    for i, channel in enumerate(CHANNELS):
-        if (conf := config.get(channel)) is None:
+    for i, channel in enumerate([CONF_CHANNEL_1, CONF_CHANNEL_2, CONF_CHANNEL_3]):
+        if channel not in config:
            continue
-        register |= CHANNEL_ENABLE_BITS[i]
-        shunt = conf[CONF_SHUNT_RESISTANCE]
-        cg.add(var.set_shunt_resistance(i, shunt))
+        conf = config[channel]
+        if CONF_SHUNT_RESISTANCE in conf:
+            cg.add(var.set_shunt_resistance(i, conf[CONF_SHUNT_RESISTANCE]))
        if CONF_BUS_VOLTAGE in conf:
            sens = await sensor.new_sensor(conf[CONF_BUS_VOLTAGE])
            cg.add(var.set_bus_voltage_sensor(i, sens))
@@ -228,23 +98,3 @@ async def to_code(config: ConfigType) -> None:
        if CONF_POWER in conf:
            sens = await sensor.new_sensor(conf[CONF_POWER])
            cg.add(var.set_power_sensor(i, sens))
-        for key, setter in (
-            (CONF_WARNING_CURRENT_LIMIT, var.set_warning_limit),
-            (CONF_CRITICAL_CURRENT_LIMIT, var.set_critical_limit),
-        ):
-            if (limit := conf.get(key)) is not None:
-                cg.add_define("USE_INA3221_ALERT_LIMITS")
-                cg.add(setter(i, alert_limit_register(limit, shunt)))
-    cg.add(var.set_config_register(register))
-    if not config[CONF_CONTINUOUS_MODE]:
-        cg.add(var.set_single_shot_wait_ms(single_shot_wait_ms(config)))
-
-    if any(
-        key in config
-        for key in (CONF_SUM_SHUNT_VOLTAGE, CONF_SUM_CURRENT, CONF_SUM_POWER)
-    ):
-        cg.add_define("USE_INA3221_SUMMATION")
-        sensors = sensor.sub_sensors(config)
-        await sensors(CONF_SUM_SHUNT_VOLTAGE, var.set_sum_shunt_voltage_sensor)
-        await sensors(CONF_SUM_CURRENT, var.set_sum_current_sensor)
-        await sensors(CONF_SUM_POWER, var.set_sum_power_sensor)
@@ -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).
@@ -204,7 +204,6 @@ class IT8951Display : public Display,
                      ColorBitness bitness, bool big_endian, int x_offset, int y_offset, int x_pad) override;
  int get_width() override { return (this->effective_transform_ & TRANSFORM_SWAP_XY) ? this->height_ : this->width_; }
  int get_height() override { return (this->effective_transform_ & TRANSFORM_SWAP_XY) ? this->width_ : this->height_; }
-  bool pixel_axes_swapped() const override { return this->effective_transform_ & TRANSFORM_SWAP_XY; }

 protected:
  int get_height_internal() override { return this->height_; }
@@ -4,7 +4,6 @@ import esphome.config_validation as cv
 from esphome.const import CONF_ID
 from esphome.types import ConfigType

-AUTO_LOAD = ["ld24xx"]
 CODEOWNERS = ["@NovakIrs"]
 DEPENDENCIES = ["uart"]
 DOMAIN = "ld2410s"
@@ -14,7 +13,6 @@ CONF_LD2410S_ID = "ld2410s_id"

 ld2410s_ns = cg.esphome_ns.namespace(DOMAIN)
 LD2410SComponent = ld2410s_ns.class_("LD2410SComponent", cg.Component, uart.UARTDevice)
-Parameter = ld2410s_ns.enum("Parameter", is_class=True)

 CONFIG_SCHEMA = (
    cv.Schema(
@@ -1,5 +1,4 @@
 #include "ld2410s.h"
-#include "ld2410s_number.h"
 #include <algorithm>
 #include <cstring>
 #include "esphome/core/application.h"
@@ -26,46 +25,18 @@ static constexpr uint16_t CMD_CONFIRMATION = 0x0100;  // set in the command word
 static constexpr uint16_t CONFIG_MODE_START_CMD = 0x00FF;
 static constexpr uint16_t CONFIG_MODE_START_VALUE = 0x0001;
 static constexpr uint16_t CONFIG_MODE_END_CMD = 0x00FE;
-static constexpr uint16_t VERSION_READ_CMD = 0x0000;
-static constexpr uint16_t PARAMETERS_WRITE_CMD = 0x0070;
-static constexpr uint16_t PARAMETERS_READ_CMD = 0x0071;
 static constexpr uint16_t OUTPUT_MODE_SWITCH_CMD = 0x007A;
 // Minimal output mode (short frames carrying presence and distance only) is selected by six zero bytes
 static constexpr uint8_t OUTPUT_MODE_MINIMAL_SIZE = 6;
-// The parameter write carries a 16-bit key and a 32-bit value per parameter, the read only the keys
-static constexpr uint8_t PARAMETER_KEY_SIZE = 2;
-static constexpr uint8_t PARAMETER_VALUE_SIZE = 4;
-static constexpr uint8_t PARAMETERS_WRITE_SIZE = PARAMETER_COUNT * (PARAMETER_KEY_SIZE + PARAMETER_VALUE_SIZE);
-static constexpr uint8_t CMD_FRAME_MAX_SIZE = LONG_PAYLOAD_POS + 2 + PARAMETERS_WRITE_SIZE + sizeof(CMD_FRAME_FOOTER);
-// Keys of the parameters, in Parameter order
-#ifdef USE_LD2410S_PARAMETERS
-static constexpr uint16_t PARAMETER_KEYS[] PROGMEM = {0x0005, 0x000A, 0x0006, 0x0002, 0x000C, 0x000B};
-static_assert(sizeof(PARAMETER_KEYS) / sizeof(PARAMETER_KEYS[0]) == PARAMETER_COUNT, "one key per parameter");
-#endif
-// The version answer: 4 bytes device type, then major, minor and patch as 16-bit words
-static constexpr uint8_t VERSION_TYPE_SIZE = 4;
-static constexpr uint8_t VERSION_SIZE = VERSION_TYPE_SIZE + 3 * 2;
+static constexpr uint8_t CMD_FRAME_MAX_SIZE =
+    LONG_PAYLOAD_POS + 2 + OUTPUT_MODE_MINIMAL_SIZE + sizeof(CMD_FRAME_FOOTER);

-// Everything the module needs at start: configuration mode on, read the version and parameters when
-// an entity shows them, pick the output mode, configuration mode off
-static constexpr uint16_t INIT_SEQUENCE[] PROGMEM = {
-    CONFIG_MODE_START_CMD,
-#ifdef USE_LD2410S_VERSION
-    VERSION_READ_CMD,
-#endif
-#ifdef USE_LD2410S_PARAMETERS
-    PARAMETERS_READ_CMD,
-#endif
-    OUTPUT_MODE_SWITCH_CMD, CONFIG_MODE_END_CMD,
-};
-#ifdef USE_LD2410S_PARAMETERS
-static constexpr uint16_t WRITE_SEQUENCE[] PROGMEM = {CONFIG_MODE_START_CMD, PARAMETERS_WRITE_CMD, CONFIG_MODE_END_CMD};
-#endif
+// Everything the module needs at start: enter configuration mode, pick the output mode, leave it
+static constexpr uint16_t INIT_SEQUENCE[] PROGMEM = {CONFIG_MODE_START_CMD, OUTPUT_MODE_SWITCH_CMD,
+                                                     CONFIG_MODE_END_CMD};
 static constexpr uint8_t INIT_SEQUENCE_LENGTH = sizeof(INIT_SEQUENCE) / sizeof(INIT_SEQUENCE[0]);
-#ifdef USE_LD2410S_PARAMETERS
-static constexpr uint8_t WRITE_SEQUENCE_LENGTH = sizeof(WRITE_SEQUENCE) / sizeof(WRITE_SEQUENCE[0]);
-#endif
-static constexpr uint8_t STEP_MAX_TIMEOUTS = 2;
+static uint16_t init_command(uint8_t step) { return progmem_read_uint16(&INIT_SEQUENCE[step]); }
+static constexpr uint8_t INIT_MAX_TIMEOUTS = 2;
 static constexpr uint32_t ACK_TIMEOUT_MS = 300;
 static constexpr uint32_t COMMAND_GAP_MS = 300;     // pause after an acknowledgement before the next command
 static constexpr uint32_t REINIT_PAUSE_MS = 15000;  // pause before starting over after the module stopped answering
@@ -78,20 +49,6 @@ void LD2410SComponent::dump_config() {
 #ifdef USE_BINARY_SENSOR
  LOG_BINARY_SENSOR("  ", "Has Target", this->target_binary_sensor_);
 #endif
-#ifdef USE_SENSOR
-  LOG_SENSOR_WITH_DEDUP_SAFE("  ", "Distance", this->distance_sensor_);
-#endif
-#ifdef USE_LD2410S_VERSION
-  LOG_TEXT_SENSOR("  ", "Version", this->version_text_sensor_);
-#endif
-#if defined(USE_NUMBER) && defined(USE_LD2410S_PARAMETERS)
-  for (auto *number : this->numbers_) {
-    LOG_NUMBER("  ", "Setting", number);
-  }
-#endif
-#if defined(USE_SELECT) && defined(USE_LD2410S_PARAMETERS)
-  LOG_SELECT("  ", "Response Speed", this->response_speed_select_);
-#endif
 }

 void LD2410SComponent::loop() {
@@ -110,80 +67,35 @@ void LD2410SComponent::loop() {
    avail -= len;
  }
  const uint32_t now = App.get_loop_component_start_time();
-  if (this->sequence_ == nullptr) {
-    if (!this->init_done_) {
-      this->start_sequence_(INIT_SEQUENCE, INIT_SEQUENCE_LENGTH, now);
-#ifdef USE_LD2410S_PARAMETERS
-    } else if (this->parameters_dirty_) {
-      this->parameters_dirty_ = false;
-      this->start_sequence_(WRITE_SEQUENCE, WRITE_SEQUENCE_LENGTH, this->next_send_at_);
-#endif
-    }
-  }
-  this->run_sequence_(now);
-  if (this->init_done_ && now - this->last_frame_at_ > LINK_TIMEOUT_MS) {
+  this->run_init_sequence_(now);
+  if (this->init_step_ >= INIT_SEQUENCE_LENGTH && now - this->last_frame_at_ > LINK_TIMEOUT_MS) {
    // The count tells real silence apart from frames that never parse (wrong baud rate or firmware)
    ESP_LOGW(TAG, "No data for %" PRIu32 " s (%u frames dropped), starting over", LINK_TIMEOUT_MS / 1000,
             this->dropped_frames_);
    this->dropped_frames_ = 0;
-    this->restart_init_(now);
+    this->status_set_warning();
+    this->init_step_ = 0;
+    this->init_timeouts_ = 0;
+    this->awaiting_ack_ = false;
+    this->next_send_at_ = now;
  }
 }

-#ifdef USE_LD2410S_PARAMETERS
-bool LD2410SComponent::set_parameter(Parameter parameter, uint8_t value) {
-  // All six are written together, so the other five must be the module's own values
-  if (!this->init_done_) {
-    ESP_LOGW(TAG, "Parameters not read yet, change ignored");
-    return false;
-  }
-  if (!this->parameters_known_) {
-    ESP_LOGW(TAG, "The module reported a parameter out of range, changes are disabled");
-    return false;
-  }
-  this->parameters_[static_cast<uint8_t>(parameter)] = value;
-  this->parameters_dirty_ = true;  // written by loop() once no sequence is running
-  return true;
-}
-#endif
-
-void LD2410SComponent::restart_init_(uint32_t at) {
-  this->init_done_ = false;
-  this->status_set_warning();  // cleared again when the new init sequence is acknowledged
-#ifdef USE_LD2410S_PARAMETERS
-  // The module's own values count again once it is set up anew
-  if (this->parameters_dirty_) {
-    ESP_LOGW(TAG, "Dropping the pending parameter change, the module's values are read back");
-  }
-  this->parameters_dirty_ = false;
-  this->parameters_known_ = false;  // a refused value may sit in parameters_ until the read replaces it
-#endif
-  this->start_sequence_(INIT_SEQUENCE, INIT_SEQUENCE_LENGTH, at);
-}
-
-void LD2410SComponent::start_sequence_(const uint16_t *sequence, uint8_t length, uint32_t now) {
-  this->sequence_ = sequence;
-  this->sequence_len_ = length;
-  this->step_ = 0;
-  this->step_timeouts_ = 0;
-  this->awaiting_ack_ = false;
-  this->next_send_at_ = now;
-}
-
-uint16_t LD2410SComponent::current_command_() const { return progmem_read_uint16(&this->sequence_[this->step_]); }
-
-void LD2410SComponent::run_sequence_(uint32_t now) {
-  if (this->sequence_ == nullptr || static_cast<int32_t>(now - this->next_send_at_) < 0) {
+void LD2410SComponent::run_init_sequence_(uint32_t now) {
+  if (this->init_step_ >= INIT_SEQUENCE_LENGTH || static_cast<int32_t>(now - this->next_send_at_) < 0) {
    return;
  }
-  const uint16_t command = this->current_command_();
+  const uint16_t command = init_command(this->init_step_);
  if (this->awaiting_ack_) {
-    if (++this->step_timeouts_ > STEP_MAX_TIMEOUTS) {
+    if (++this->init_timeouts_ > INIT_MAX_TIMEOUTS) {
      ESP_LOGW(TAG, "No acknowledgement for command %04X, starting over in %" PRIu32 " s", command,
               REINIT_PAUSE_MS / 1000);
      // Leave configuration mode whatever state the module is in, then begin again
      this->send_command_(CONFIG_MODE_END_CMD);
-      this->restart_init_(now + REINIT_PAUSE_MS);
+      this->init_step_ = 0;
+      this->init_timeouts_ = 0;
+      this->awaiting_ack_ = false;
+      this->next_send_at_ = now + REINIT_PAUSE_MS;
      return;
    }
    ESP_LOGD(TAG, "No acknowledgement for command %04X, resending", command);
@@ -208,22 +120,6 @@ void LD2410SComponent::send_command_(uint16_t command) {
      frame[pos++] = CONFIG_MODE_START_VALUE & 0xFF;
      frame[pos++] = CONFIG_MODE_START_VALUE >> 8;
      break;
-#ifdef USE_LD2410S_PARAMETERS
-    case PARAMETERS_READ_CMD:
-    case PARAMETERS_WRITE_CMD:
-      for (uint8_t i = 0; i < PARAMETER_COUNT; i++) {
-        const uint16_t key = progmem_read_uint16(&PARAMETER_KEYS[i]);
-        frame[pos++] = key & 0xFF;
-        frame[pos++] = key >> 8;
-        if (command == PARAMETERS_WRITE_CMD) {
-          const uint32_t value = this->parameters_[i];  // a 32-bit field on the wire
-          for (uint8_t shift = 0; shift < 32; shift += 8) {
-            frame[pos++] = (value >> shift) & 0xFF;
-          }
-        }
-      }
-      break;
-#endif
    default:
      break;
  }
@@ -356,27 +252,27 @@ bool LD2410SComponent::handle_frame_() {
 }

 bool LD2410SComponent::handle_data_frame_(const uint8_t *payload, uint16_t len) {
-  // Short frames carry [state][distance low][distance high]; standard frames put a type byte first, and the
-  // module only sends them before the init sequence switches it to minimal output
-  const uint8_t *data = payload;
-  if (this->frame_type_ == FrameType::STD_DATA) {
-    if (len < 4 || payload[0] != DATA_TYPE_STANDARD) {
-      if (len >= 1) {
-        ESP_LOGV(TAG, "Ignoring data frame type %02X", payload[0]);
-      }
-      return true;
+  uint8_t state;
+  if (this->frame_type_ == FrameType::SHORT_DATA) {
+    // [state][distance low][distance high]
+    state = payload[0];
+  } else if (len >= 4 && payload[0] == DATA_TYPE_STANDARD) {
+    // [type][state][distance low][distance high]...; the module only sends these before the init
+    // sequence switches it to minimal output
+    state = payload[1];
+  } else {
+    if (len >= 1) {
+      ESP_LOGV(TAG, "Ignoring data frame type %02X", payload[0]);
    }
-    data = payload + 1;
+    return true;
  }
-  const uint8_t state = data[0];
-  const uint16_t distance = encode_uint16(data[2], data[1]);
  // States 0 and 1 mean no target, 2 and 3 a target; anything else is line noise that happened to
  // carry the header and footer bytes
  if (state > 3) {
    ESP_LOGV(TAG, "Dropping frame with impossible state %u", state);
    return false;
  }
-  this->publish_target_(state > 1, distance);
+  this->publish_target_(state > 1);
  return true;
 }

@@ -387,147 +283,32 @@ void LD2410SComponent::handle_command_ack_(const uint8_t *payload, uint16_t len)
  }
  const uint16_t command_word = encode_uint16(payload[1], payload[0]);
  const uint16_t ack = encode_uint16(payload[3], payload[2]);
-  if (!this->awaiting_ack_) {
+  if (!this->awaiting_ack_ || command_word != (init_command(this->init_step_) | CMD_CONFIRMATION)) {
    ESP_LOGV(TAG, "Unexpected acknowledgement %04X", command_word);
    return;
  }
-  const uint16_t command = this->current_command_();
-  if (command_word != (command | CMD_CONFIRMATION)) {
-    ESP_LOGV(TAG, "Unexpected acknowledgement %04X", command_word);
-    return;
-  }
-#ifdef USE_LD2410S_PARAMETERS
-  if (ack != 0 && command == PARAMETERS_WRITE_CMD) {
-    // Resending the same values would be rejected again; leave configuration mode and read the
-    // module's own values back, which republishes them
-    ESP_LOGW(TAG, "Module rejected the parameters, ack %04X", ack);
-    this->send_command_(CONFIG_MODE_END_CMD);
-    this->restart_init_(App.get_loop_component_start_time() + COMMAND_GAP_MS);
-    return;
-  }
-#endif
  if (ack != 0) {
    // Leave the command pending so the timeout resends it
-    ESP_LOGW(TAG, "Module rejected command %04X, ack %04X", command, ack);
+    ESP_LOGW(TAG, "Module rejected command %04X, ack %04X", init_command(this->init_step_), ack);
    return;
  }
-  // A short answer leaves the read pending the same way, so init cannot finish without the values
-#ifdef USE_LD2410S_PARAMETERS
-  if (command == PARAMETERS_READ_CMD && !this->handle_parameters_(&payload[4], len - 4))
-    return;
-#endif
-#ifdef USE_LD2410S_VERSION
-  if (command == VERSION_READ_CMD && !this->handle_version_(&payload[4], len - 4))
-    return;
-#endif
  this->awaiting_ack_ = false;
-  this->step_timeouts_ = 0;
-  const uint32_t now = App.get_loop_component_start_time();
-  this->next_send_at_ = now + COMMAND_GAP_MS;
-  if (++this->step_ < this->sequence_len_) {
-    return;
-  }
-  const bool was_init = this->sequence_ == INIT_SEQUENCE;
-  this->sequence_ = nullptr;
-  if (was_init) {
+  this->init_timeouts_ = 0;
+  this->init_step_++;
+  this->next_send_at_ = App.get_loop_component_start_time() + COMMAND_GAP_MS;
+  if (this->init_step_ >= INIT_SEQUENCE_LENGTH) {
    ESP_LOGD(TAG, "Setup done");
-    this->init_done_ = true;
-    this->last_frame_at_ = now;
+    this->last_frame_at_ = App.get_loop_component_start_time();
    this->status_clear_warning();
  }
 }

-#ifdef USE_LD2410S_PARAMETERS
-// The answer lists the parameter values in key order, 32 bits each; returns false when it is cut short
-bool LD2410SComponent::handle_parameters_(const uint8_t *values, uint16_t len) {
-  if (len < PARAMETER_COUNT * PARAMETER_VALUE_SIZE) {
-    ESP_LOGW(TAG, "Parameter answer too short (%u bytes)", len);
-    return false;
-  }
-  // Every parameter must fit the low byte of its little-endian value; otherwise nothing is stored or
-  // published and writes stay refused, so a cut-down value is never shown or sent back
-  for (uint8_t i = 0; i < PARAMETER_COUNT; i++) {
-    const uint8_t *v = &values[i * PARAMETER_VALUE_SIZE];
-    if ((v[1] | v[2] | v[3]) != 0) {
-      ESP_LOGW(TAG, "Parameter %u out of range: %" PRIu32 ", changes stay disabled", i,
-               encode_uint32(v[3], v[2], v[1], v[0]));
-      this->parameters_known_ = false;
-#ifdef USE_NUMBER
-      // A value a number showed before the module answered is not confirmed
-      for (auto *number : this->numbers_) {
-        if (number != nullptr) {
-          number->publish_state(NAN);
-        }
-      }
-#endif
-      return true;
-    }
-  }
-  for (uint8_t i = 0; i < PARAMETER_COUNT; i++) {
-    this->parameters_[i] = values[i * PARAMETER_VALUE_SIZE];
-  }
-  this->parameters_known_ = true;
-  this->publish_parameters_();
-  ESP_LOGD(TAG, "Parameters: gates %u to %u, no delay %u s, frequencies %u/%u dHz, response speed %u",
-           this->parameters_[1], this->parameters_[0], this->parameters_[2], this->parameters_[3], this->parameters_[4],
-           this->parameters_[5]);
-  return true;
-}
-#endif
-
-#ifdef USE_LD2410S_VERSION
-// Returns false when the answer is cut short
-bool LD2410SComponent::handle_version_(const uint8_t *values, uint16_t len) {
-  if (len < VERSION_SIZE) {
-    ESP_LOGW(TAG, "Version answer too short (%u bytes)", len);
-    return false;
-  }
-  const uint8_t *v = &values[VERSION_TYPE_SIZE];
-  char version[18];
-  snprintf(version, sizeof(version), "%u.%u.%u", encode_uint16(v[1], v[0]), encode_uint16(v[3], v[2]),
-           encode_uint16(v[5], v[4]));
-  ESP_LOGD(TAG, "Firmware %s", version);
-  if (this->version_text_sensor_ != nullptr) {
-    this->version_text_sensor_->publish_state(version);
-  }
-  return true;
-}
-#endif
-
-void LD2410SComponent::publish_target_(bool target, uint16_t distance) {
+void LD2410SComponent::publish_target_(bool target) {
 #ifdef USE_BINARY_SENSOR
  if (this->target_binary_sensor_ != nullptr) {
    this->target_binary_sensor_->publish_state(target);
  }
 #endif
-#ifdef USE_SENSOR
-  // The module keeps reporting the last distance after the target left
-  SAFE_PUBLISH_SENSOR(this->distance_sensor_, target ? distance : 0);
-#endif
 }

-#ifdef USE_LD2410S_PARAMETERS
-void LD2410SComponent::publish_parameters_() {
-#ifdef USE_NUMBER
-  for (uint8_t i = 0; i < PARAMETER_COUNT; i++) {
-    if (this->numbers_[i] != nullptr) {
-      this->numbers_[i]->publish_raw(this->parameters_[i]);
-    }
-  }
-#endif
-#ifdef USE_SELECT
-  if (this->response_speed_select_ != nullptr) {
-    const uint8_t speed = this->parameters_[static_cast<uint8_t>(Parameter::PARAMETER_RESPONSE_SPEED)];
-    for (uint8_t i = 0; i < RESPONSE_SPEED_COUNT; i++) {
-      if (progmem_read_byte(&RESPONSE_SPEEDS[i]) == speed) {
-        this->response_speed_select_->publish_state(i);
-        return;
-      }
-    }
-    ESP_LOGV(TAG, "Unknown response speed %u", speed);
-  }
-#endif
-}
-#endif
-
 }  // namespace esphome::ld2410s
@@ -2,21 +2,10 @@

 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/helpers.h"
 #include "esphome/components/uart/uart.h"
 #ifdef USE_BINARY_SENSOR
 #include "esphome/components/binary_sensor/binary_sensor.h"
 #endif
-#ifdef USE_SENSOR
-#include "esphome/components/sensor/sensor.h"
-#include "esphome/components/ld24xx/ld24xx.h"
-#endif
-#ifdef USE_LD2410S_VERSION
-#include "esphome/components/text_sensor/text_sensor.h"
-#endif
-#if defined(USE_SELECT) && defined(USE_LD2410S_PARAMETERS)
-#include "esphome/components/select/select.h"
-#endif

 namespace esphome::ld2410s {

@@ -24,55 +13,16 @@ namespace esphome::ld2410s {
 static constexpr size_t RX_BUFFER_SIZE = 96;
 static_assert(RX_BUFFER_SIZE <= 255, "frame lengths are kept in a byte");

-/// The module's common parameters, in the order the parameter read answers them
-enum class Parameter : uint8_t {
-  PARAMETER_MAX_DISTANCE,
-  PARAMETER_MIN_DISTANCE,
-  PARAMETER_NO_DELAY,
-  PARAMETER_STATUS_FREQUENCY,
-  PARAMETER_DISTANCE_FREQUENCY,
-  PARAMETER_RESPONSE_SPEED,
-  PARAMETER_COUNT,
-};
-static constexpr uint8_t PARAMETER_COUNT = static_cast<uint8_t>(Parameter::PARAMETER_COUNT);
-// Response speed values, in the order of the select's options (Normal, Fast)
-static constexpr uint8_t RESPONSE_SPEEDS[] PROGMEM = {5, 10};
-static constexpr uint8_t RESPONSE_SPEED_COUNT = sizeof(RESPONSE_SPEEDS);
-
-#if defined(USE_NUMBER) && defined(USE_LD2410S_PARAMETERS)
-class LD2410SNumber;
-#endif
-
 class LD2410SComponent final : public Component, public uart::UARTDevice {
 #ifdef USE_BINARY_SENSOR
  SUB_BINARY_SENSOR(target)
 #endif
-#ifdef USE_SENSOR
-  SUB_SENSOR_WITH_DEDUP(distance, uint16_t)
-#endif
-#ifdef USE_LD2410S_VERSION
-  SUB_TEXT_SENSOR(version)
-#endif
-#if defined(USE_SELECT) && defined(USE_LD2410S_PARAMETERS)
-  SUB_SELECT(response_speed)
-#endif

 public:
  void setup() override { this->status_set_warning(); }  // cleared once the module acknowledged the init sequence
  void loop() override;
  void dump_config() override;

-  /// Store a parameter in the module's units; loop() then writes all of them to the module.
-  /// Returns false, and changes nothing, until the module's own values have been read.
-#ifdef USE_LD2410S_PARAMETERS
-  bool set_parameter(Parameter parameter, uint8_t value);
-#ifdef USE_NUMBER
-  void set_number(Parameter parameter, LD2410SNumber *number) {
-    this->numbers_[static_cast<uint8_t>(parameter)] = number;
-  }
-#endif
-#endif
-
 protected:
  enum class FrameType : uint8_t { NONE, SHORT_DATA, STD_DATA, COMMAND };

@@ -82,12 +32,6 @@ class LD2410SComponent final : public Component, public uart::UARTDevice {
  /// Returns false for a data frame whose state byte is impossible, so it counts as dropped.
  bool handle_data_frame_(const uint8_t *payload, uint16_t len);
  void handle_command_ack_(const uint8_t *payload, uint16_t len);
-#ifdef USE_LD2410S_PARAMETERS
-  bool handle_parameters_(const uint8_t *values, uint16_t len);
-#endif
-#ifdef USE_LD2410S_VERSION
-  bool handle_version_(const uint8_t *values, uint16_t len);
-#endif
  void count_dropped_frame_() {
    if (this->dropped_frames_ < UINT8_MAX) {
      this->dropped_frames_++;
@@ -98,41 +42,21 @@ class LD2410SComponent final : public Component, public uart::UARTDevice {
    this->expected_len_ = 0;
    this->frame_type_ = FrameType::NONE;
  }
-  void start_sequence_(const uint16_t *sequence, uint8_t length, uint32_t now);
-  void restart_init_(uint32_t at);
-  void run_sequence_(uint32_t now);
-  uint16_t current_command_() const;
+  void run_init_sequence_(uint32_t now);
  void send_command_(uint16_t command);
-  void publish_target_(bool target, uint16_t distance);
-#ifdef USE_LD2410S_PARAMETERS
-  void publish_parameters_();
-#endif
+  void publish_target_(bool target);

-#if defined(USE_NUMBER) && defined(USE_LD2410S_PARAMETERS)
-  LD2410SNumber *numbers_[PARAMETER_COUNT]{};  // null for parameters without a number
-#endif
-
-  const uint16_t *sequence_{nullptr};  // PROGMEM; null while nothing is being sent
  uint32_t next_send_at_{0};
  uint32_t last_frame_at_{0};
-#ifdef USE_LD2410S_PARAMETERS
-  uint8_t parameters_[PARAMETER_COUNT]{};  // all fit a byte: gates, seconds, tenths of a hertz, speed
-#endif
  uint8_t rx_buffer_[RX_BUFFER_SIZE];
  uint8_t rx_len_{0};
  uint8_t expected_len_{0};
-  uint8_t sequence_len_{0};
-  uint8_t step_{0};
-  uint8_t step_timeouts_{0};
+  uint8_t init_step_{0};
+  uint8_t init_timeouts_{0};
  uint8_t dropped_frames_{0};  // since the last accepted data frame, saturates at 255
  FrameType frame_type_{FrameType::NONE};
  bool awaiting_ack_{false};
  bool rescanning_{false};
-  bool init_done_{false};
-#ifdef USE_LD2410S_PARAMETERS
-  bool parameters_known_{false};  // the module answered the parameter read at least once
-  bool parameters_dirty_{false};
-#endif
 };

 }  // namespace esphome::ld2410s
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
J. Nick Koston	65b32731d4	Keep the ESP8266 short string encode on the shared progmem copy	2026-10-12 16:53:23 -10:00
J. Nick Koston	9b873e2179	Keep the RAM short string encode on memcpy and drop unused ProgmemStringRef helpers	2026-10-12 16:47:08 -10:00
J. Nick Koston	dd495be861	Fold dev's ProgmemStringRef struct into the class	2026-10-12 16:28:37 -10:00
J. Nick Koston	a7fdb143cd	Merge branch 'dev' into api-action-strings-progmem	2026-10-12 16:02:23 -10:00
J. Nick Koston	229aa22006	Merge remote-tracking branch 'origin/dev' into api-action-strings-progmem # Conflicts: # esphome/components/api/__init__.py # tests/component_tests/api/test_action_metadata.py	2026-10-11 15:26:13 -10:00
J. Nick Koston	491a2e58d5	Merge remote-tracking branch 'origin/dev' into HEAD	2026-10-09 18:28:25 -10:00
J. Nick Koston	40ec3067b6	Merge remote-tracking branch 'origin/dev' into api-action-strings-progmem	2026-10-08 22:14:06 -10:00
J. Nick Koston	4497dad959	Keep the inline short string encode off ESP8266	2026-10-08 22:07:35 -10:00
J. Nick Koston	47655129e1	Share the outlined PROGMEM append for the progmem string dump	2026-10-08 21:44:06 -10:00
J. Nick Koston	40460f3e01	Dump progmem strings straight into the dump buffer, assert the scratch define is gone	2026-10-08 21:34:31 -10:00
J. Nick Koston	8378c935d6	Drop the scratch define assertion from the action metadata test	2026-10-08 20:17:56 -10:00
J. Nick Koston	1fa844a5d2	[api] Add encode_progmem_string for progmem string fields Generated code passes the ProgmemStringRef instead of spelling out the cast.	2026-10-08 20:17:55 -10:00
J. Nick Koston	7b5a1f9de9	[api] Encode action strings straight from flash The service name, description and argument strings are progmem fields, so list entities no longer copies them into a stack scratch buffer, and the ESP8266 per action string budget goes away.	2026-10-08 20:10:41 -10:00
J. Nick Koston	b63b74f236	[api] Allow the progmem option on string fields Mirrors the helper from the entity names change, so either PR can merge first.	2026-10-08 20:10:41 -10:00