Merge remote-tracking branch 'upstream/dev' into neutral-ble-client

# Conflicts:
#	esphome/components/ble_client/__init__.py

.agents/skills/component-codegen/SKILL.md

@@ -177,8 +177,7 @@ async def to_code(config):
 uses `button.ApplyButton` (`switch.ApplySwitch`, `number.ApplyNumber`, `select.ApplySelect`) in its schema
 and `apply=` on the `sub_*` call. The body is a call on the hub with `entity` and `state`, `value` or
 `index`/`option` in scope; on a switch, number or select `publish="before"` or `"after"` publishes the
-state, and `publish="on_success"` publishes only when the hub call returns true (a write the device can
-refuse). `publish="momentary"` is only for legacy action switches (restart, factory reset): it publishes off
+state. `publish="momentary"` is only for legacy action switches (restart, factory reset): it publishes off
 and runs the body only when turned on. Never use it for a new entity; an action is a button.
 ```python
 switches = switch.sub_switches(config, parent=hub)

.agents/skills/hardware-test/SKILL.md

@@ -67,17 +67,9 @@ driven, what the logs show, and the same flow on a `dev` build when a quirk coul
    automations in the config itself.
 7. **Analyze** with `grep -a -c` counts over the capture and keep an `-events.txt` extract of the lines
    that matter. Decode crashes with the platform's `addr2line` (see `reference/boards.md`).
-8. **Report** on the PR. Every result comment starts with this two-line GitHub alert, then a blank line:
-
-   ```
-   > [!NOTE]
-   > Automated testing results
-   ```
-
-   Then one short sentence saying what was tested (builds and SHAs, board, what was driven), a results table
-   (build SHA, board and framework, what was driven, counts, result, plus the `dev` control row), short bullets
-   for the findings, and the setup and exact flow in a collapsed `<details>` block. Answer any question asked on
-   the PR directly in the comment. No credentials, SSIDs, IP addresses, port names or other bench details.
+8. **Report** on the PR as a table: build SHA, board and framework, what was driven, counts, result,
+   plus the `dev` control row and the exact flow in a `<details>` block. No credentials, no port names,
+   no IP addresses.
 
 ## Flashing by chip family
 
@@ -123,7 +115,7 @@ Per-topic scripts, each described in the matching `reference/recipes/<component>
 (host driver, Zephyr driver probe), `rtsp_server/` (protocol client, raw rate reader, measurement set,
 API image grab), `cse7766/` (API observer with ping), `zephyr_coredump/` (reader flow, decode with the
 Zephyr tools), `libretiny_prefs/` (rtc preference harness header), `libretiny_crash/` (BK72xx crash probe header and
-capture decoder), `api_outgoing/` (wake cycle and Wi-Fi drop timing readers), `ld2450/` (zone number driver, loopback harness driver with number and binary sensor states and TX frame summarizer), `api/` (raw plaintext native API client for user defined actions, store_yaml recovery client over Noise or plaintext), `http_request/` (update manifest server, update state driver, request test server, action case driver, concurrency, reboot, update check and OTA drivers, `ota_auth/` OTA request cases with basic auth), `modem/` (button and sensor driver over the plaintext API, also used for the BLE MIDI boards), `dfrobot_sen0395/` (API driver and case runner), `homeassistant_light/` (direct bulb driver, held-report case driver), `usb_audio/` (URL player), `speaker_media_player/` (API player driver, pipeline task case runner), `web_server/` (SSE client, request mix, SSE and HTTPD case runners), `mqtt/` (broker config with TLS, client-certificate and WebSocket listeners, test CA with server and client certificates, transport case runner, flash-and-drive runner, CLI TLS check without a board, MAC suffix runner with per-variant configs for two boards, `shutdown/` shutdown message runner and matcher), `udp/` (datagram recorder, `udp.write` payload checker and case driver), `entity_icons/` (icon and device class readback over the API, MQTT discovery, web_server and dump_config, with a comparer), `uart_sim/` (API driver and flash, capture and drive runner for the simulated UART sensors), `remote_base/` (loopback runner and API log decoder per sent frame), `xiaomi_ble/` (frame and header generator with the expected counts, injecting, advertising and receiving configs, counter and runner), `ble_terminate/` (proxy and peer configs, connect and disconnect driver, peer disconnect matcher, runner), `i2c_slave/` (D1 mini slave and BK7238 master configs), `wpa3_ap/` (PMF AP with join and leave logging, BK7238 and CB3S DUTs, runner and summary), `wisp_ap/` (WISP upstream with AP buttons, WISP and ALWAYS_ON DUTs, client, runner and per phase summary), `wifi_restart/` (WPA3 mixed WISP upstream, static IP DUTs with syslog, runner and summary), `ota_timing/` (OTA upload timer with deflate, raw and TCP modes, API build check, A/B runner and median summary, `inflate_bench/` on-device inflate benchmark with stream generator, configs and syslog runner).
+capture decoder), `api_outgoing/` (wake cycle and Wi-Fi drop timing readers), `ld2450/` (zone number driver, loopback harness driver with number and binary sensor states and TX frame summarizer), `api/` (raw plaintext native API client for user defined actions, store_yaml recovery client over Noise or plaintext), `http_request/` (update manifest server, update state driver, request test server, action case driver, concurrency, reboot, update check and OTA drivers, `ota_auth/` OTA request cases with basic auth), `modem/` (button and sensor driver over the plaintext API, also used for the BLE MIDI boards), `dfrobot_sen0395/` (API driver and case runner), `homeassistant_light/` (direct bulb driver, held-report case driver), `usb_audio/` (URL player), `speaker_media_player/` (API player driver, pipeline task case runner), `web_server/` (SSE client, request mix, SSE and HTTPD case runners), `mqtt/` (broker config with TLS, client-certificate and WebSocket listeners, test CA with server and client certificates, transport case runner, flash-and-drive runner, CLI TLS check without a board, MAC suffix runner with per-variant configs for two boards, `shutdown/` shutdown message runner and matcher), `udp/` (datagram recorder, `udp.write` payload checker and case driver), `entity_icons/` (icon and device class readback over the API, MQTT discovery, web_server and dump_config, with a comparer), `uart_sim/` (API driver and flash, capture and drive runner for the simulated UART sensors), `remote_base/` (loopback runner and API log decoder per sent frame).
 
 ## Templates in `$SKILL/templates`
 

.agents/skills/hardware-test/reference/boards.md

@@ -125,11 +125,6 @@ Ports are not listed on purpose: they follow the USB hub port and change on ever
 - The BK7238 bootloader prints `App verify failed! Need to recovery factory firmware.` on every boot with any
   build; it is harmless. Even with the right layout an ESP32 client did not see the BK7238 fallback AP on
   LibreTiny 1.13.0 or 1.14.0, so the wifisave hammer cannot run on it.
-- Moving a BK7231N device (CB3S) that sits on its fallback AP to another network: join the host's Wi-Fi to
-  `<name>-fallback`, OTA to 192.168.4.1, then rejoin the host's own network. Moving it with `/wifisave` instead can
-  leave it in the captive portal's BLIND_RETRY state (no scan, `Beacon Timeout` every 46 s) until it reboots, and a
-  log-only serial adapter cannot reset it. Rejoining may change the host's address; update a syslog target that
-  points at the old one.
 - Callbacks run on the `async_tcp` task and log lines can lose a byte. Wi-Fi connect takes tens of ms;
   radio enable 160 to 278 ms, disable about 200 ms.
 
@@ -177,12 +172,6 @@ Ports are not listed on purpose: they follow the USB hub port and change on ever
   the port open, and the logger warns `logger took a long time`. Print one line per `loop()` instead.
 - Zephyr settings survive a reflash: key a `restore_value` global by a `run` substitution when a test needs
   a never-saved value.
-- Thread: nRF52 `openthread:` accepts only `tlv:`; the individual keys (network_key, channel, ...) are rejected at
-  validation. To list nearby networks with channel and PAN ID, call
-  `otThreadDiscover(InstanceLock::acquire().get_instance(), 0, 0xFFFF, false, false, cb, nullptr)` from an
-  `interval:` lambda in an included header; results arrive on the OpenThread thread and log fine.
-- A wrong network key on a real network's channel and PAN ID makes the device form its own partition as leader on
-  that PAN within about 30 s; take it off Thread at once. Never try guessed datasets against a network in use.
 
 ## Waveshare ESP32-S3-ETH with the OV5640 camera module
 

.agents/skills/hardware-test/reference/recipes/README.md

@@ -13,18 +13,18 @@ One file per component, named after it:
 - [`http_request.md`](http_request.md): update manifest URL changed at run time, every setter shape, a swap under a running check, non-blocking request actions with loop gap, queue, cancel and reboot checks, OTA request cases with basic auth and MD5 sources
 - [`ld2450.md`](ld2450.md): polygon zones, zone number round trip through the radar's readback, ESP8266 loopback harness without a radar
 - [`ld2412.md`](ld2412.md): output pin level through the basic configuration command, held back writes
-- [`libretiny.md`](libretiny.md): rtc preference emulation, BK72xx and RTL8720C crash report on the next boot
+- [`libretiny.md`](libretiny.md): rtc preference emulation, BK72xx crash report on the next boot
 - [`modem.md`](modem.md): PPPoS modem component boot check with no modem attached, loop blocking and disable timing
 - [`mqtt.md`](mqtt.md): broker bench, QoS, reconnect, crash log over MQTT, WebSocket transports with a local and a public broker, TLS trust sources (own CA, client certificate, certificate bundle, no verification) with the CLI check, MAC suffix topics and will messages on two boards, shutdown message delivery on restart, disable and deep sleep
 - [`nrf52.md`](nrf52.md): dongle board support
 - [`online_image.md`](online_image.md): stalled and malformed downloads, PNG, JPEG, BMP and QOI decode time per loop pass with large images and small buffers
 - [`openthread.md`](openthread.md): border router on the S3 host plus H2 RCP
-- [`ota.md`](ota.md): overlap and lock, timeouts, deflate, upload timing A/B per build and board with deflate and raw, on-device inflate benchmark
+- [`ota.md`](ota.md): overlap and lock, timeouts, deflate
 - [`rtsp_server.md`](rtsp_server.md): camera streaming on the Waveshare ESP32-S3-ETH
 - [`scheduler.md`](scheduler.md): loop wake A/B
 - [`udp.md`](udp.md): datagrams, multicast, sockets, `udp.write` payload shapes
 - [`usb_cdc_acm.md`](usb_cdc_acm.md): nRF52840 dongle host driver
-- [`wifi.md`](wifi.md): reboot_timeout with a fallback AP, DHCP lease cache, Easy Connect (DPP), WISP bridge with an ethernet upstream, reboots against a WPA2/WPA3 PMF access point, WISP and ALWAYS_ON AP switching, AP restarts with WPA3 mixed and LIGHT power save
+- [`wifi.md`](wifi.md): reboot_timeout with a fallback AP, DHCP lease cache, Easy Connect (DPP), WISP bridge with an ethernet upstream
 - [`zephyr.md`](zephyr.md): preferences on the nRF52840 dongle
 - [`zephyr_coredump.md`](zephyr_coredump.md): crash and decode on nRF52 boards
 - [`zwave_proxy.md`](zwave_proxy.md): frame checksums on a live proxy
@@ -36,8 +36,5 @@ One file per component, named after it:
 - [`web_server.md`](web_server.md): state SSE stress and the HTTPD task stack on web_server_idf, entity icon and device class readback
 - [`uart_sim.md`](uart_sim.md): UART sensors simulated on a classic ESP32 with loopback and cross-wired UARTs
 - [`gpio_expander.md`](gpio_expander.md): interrupt driven expander inputs, loop idle checks, testing a device out of reach
-- [`led_strip.md`](led_strip.md): forcing a failed strip allocation, RMT symbols per chip, loop cost per strip
+- [`led_strip.md`](led_strip.md): forcing a failed strip allocation, RMT symbols on the S3
 - [`remote_base.md`](remote_base.md): remote_receiver protocol decoding through a one-pin loopback on ESP32 and ESP8266, no IR hardware
-- [`xiaomi_ble.md`](xiaomi_ble.md): Xiaomi, ATC and PVVX parsing by injecting scan results into the ESP32 tracker or advertising them from a second ESP32, real AES-CCM frames, duplicate filter model
-- [`ble_terminate.md`](ble_terminate.md): proxy disconnect against a peer with peripheral latency
-- [`i2c_slave.md`](i2c_slave.md): fake I2C slave on a D1 mini, ESP32 hardware master as the control

.agents/skills/hardware-test/reference/recipes/ble_terminate.md

@@ -1,17 +0,0 @@
-# BLE terminate with peripheral latency (#20232)
-
-`scripts/ble_terminate`: an ESP32-S3 `bluetooth_proxy` (active) over Ethernet as the central (`btproxy.yaml`) and a
-classic devkit `esp32_ble_server` peer (`btpeer.yaml`). The peer asks for 50 ms / latency 10 / 6 s with
-`esp_ble_gap_update_conn_params` 4 s after connect; earlier requests are overwritten by the proxy's own "medium
-conn params" after service discovery. Read the proxy's `Conn params updated` line (VERBOSE, API logs) to confirm;
-the peer side never logs the event. The proxy only connects to a device its scanner has seen, so `btdrive.py`
-subscribes to raw advertisements first.
-
-Measure the peer's own disconnect (`serial_capture.py --ms`) after the client's disconnect: about 0.2 to 0.8 s when
-the terminate arrived, about 6 s (the supervision timeout) when it was lost. The client side disconnect time is the
-API reply and says nothing. On dev the S3 lost 6 of 12; the PR lost 0 of 16.
-
-`run.sh LABEL ROUNDS` writes `central_bda.hpp` from `PROXY_BT_MAC`, builds and flashes both boards, runs the rounds
-and `an.py`, which prints PASS only when every round completed, every peer disconnect came within 3 s and the last
-parameter update the proxy logged before each disconnect had latency=10 (a round without it did not test peripheral
-latency and counts as inconclusive).

.agents/skills/hardware-test/reference/recipes/i2c_slave.md

@@ -1,12 +0,0 @@
-# Fake I2C slave (#21586)
-
-`scripts/i2c_slave`: a D1 mini running an Arduino `Wire` slave at 0x40 (`i2cslave.yaml` with `i2cslave.hpp`): a fake
-HDC1080 plus a 256 byte register file, and reads of 0x7E and 0x7F stretch the clock for 0.5 and 5 ms. It needs
-`libraries: [Wire]` and 160 MHz. With jumper wires only and the internal pull ups it works to about 50 kHz; it cannot
-keep up with a true 100 kHz hardware master.
-
-The master (`i2cbk.yaml`, a BK7238 on P26/P24, needs the software I2C bus from that PR) writes a counter, reads it
-back with a repeated start, probes an absent address and reads both stretch registers every 2 s, logging `RW OK`
-(the read back matches, the absent address NACKs and both stretched reads succeed) or `RW BAD` with running totals.
-Control: the same blocks on a classic ESP32 devkit (SDA GPIO21, SCL GPIO22) with hardware I2C at 25 and 50 kHz got
-every repeated start read right, so failures on a bit banged master at a similar real clock point at the master.

.agents/skills/hardware-test/reference/recipes/led_strip.md

@@ -8,7 +8,3 @@
 - On the ESP32-S3 give each RMT strip `rmt_symbols: 48`, or the first channel takes all 192 symbols.
 - A board with a few WS2812 on a pin already defined as a light can be extended with `id: !extend <light id>` to
   add effects; restore its own config afterwards.
-- Loop cost of a strip (#19337): give each strip an `addressable_lambda` effect with `update_interval: 0ms` that
-  changes every pixel, and add `runtime_stats: log_interval: 30s`; compare the main loop and light times per pass,
-  leaving out the first period after boot. The strips need no LEDs attached. A classic ESP32 has 512 RMT symbols in
-  all, so three strips need `rmt_symbols: 128` each.

.agents/skills/hardware-test/reference/recipes/libretiny.md

@@ -56,18 +56,3 @@ OTA-only board: copy the device's own config, add the probe include and the step
 next to that config. A LibreTiny OTA is a 1.5 MB UF2 and takes minutes on a slow link, so do not wrap the
 upload in a short timeout. Read the replayed report with `esphome logs ... --device <name>.local` (an API
 client gets it on subscribe) or on the board's serial log port if it has one.
-
-## RTL8720C crash report on the next boot (#21648)
-
-`templates/rtl8720c-crash-buttons-dut.yaml` has one API button per case: `trap` (`__builtin_trap()`, usage fault),
-`bus fault` (store to 0x70000000, imprecise, CFSR 0x400), `wild call` (call to 0xFFFFFFF1, MemManage fault with PC
-0xFFFFFFF0 and LR in the caller), `isr trap` (a trap from a spare interrupt pended by software, hard fault), `hang`
-(interrupts off, the watchdog resets it and nothing must be reported) and `restart`. Every boot logs
-`boot reason N, crash record yes|no|n/a`; `n/a` means the handler is not built, as on a dev control build.
-
-Flow per build: flash with `flash_rtl87xx_kit.py`, start one `serial_capture.py PORT 600 OUT --released --ms`, then
-`scripts/libretiny_crash/rtl_drive.py HOST OUTDIR TREE YAML trap restart "bus fault" "wild call" "isr trap" hang restart`.
-The `restart` after the first crash checks the report shows only once. Time each reset from the serial capture
-(the ROM fault dump to the next `ROM Version` line), not from the API port: the board is back before an API client
-notices it went away. Compare the reported PC with the `PC  =` line of the ROM dump, and check the decoded lines in the
-`caseN-*.txt` files. Pass the UF2 by name (`firmware.uf2`): the build directory holds a second identically sized copy.

.agents/skills/hardware-test/reference/recipes/nrf52.md

@@ -4,10 +4,3 @@
 
 Test config: the two LEDs as inverted GPIO outputs, the button as an inverted pull-up binary sensor, a
 10 s alive interval. To retest the nrfutil download path, move the cached `sdk-nrf/nrfutil` aside first.
-
-## ItsyBitsy over UF2 when serial DFU fails (#20481)
-
-Serial DFU to the ItsyBitsy nRF52840 fails about half the time ("Target is not in DFU mode"). Reliable path: a
-1200 baud touch on the app port, wait for the `ITSY840BOOT` volume, convert `zephyr/zephyr.hex` with the SDK's
-`zephyr/scripts/build/uf2conv.py -f 0xADA52840 -c` and copy the .uf2 to the volume (the copy ends in an I/O error
-when the board reboots, which is normal). macOS BLE scans give UUIDs, not MAC addresses.

.agents/skills/hardware-test/reference/recipes/ota.md

@@ -6,51 +6,3 @@ All overlap orders (a web upload during a native OTA and the reverse) must be re
 after an interrupted web upload waits about 14 s (ESP8266) or 7 s (ESP-IDF) for disconnect detection. A
 refused web client on `web_server_idf` never gets the busy reply; the connection drops at reboot.
 `pkill -f "a\|b"` does not alternate; use two pkills.
-
-## OTA upload timing A/B (#21639, #21641, #21642)
-
-`scripts/ota_timing/run.sh N PHASE...` times native OTA uploads per build (phase) and per board. It builds every
-board from `TREE_<PHASE>`, does one warm-up upload per board (it installs the phase's build and is left out of the
-results), checks over the API that each board reports the compile time from that build's `build_info.json`
-(`apiinfo.py`), then runs N rounds of every mode on every board. Boards are interleaved per round so they share the
-same air; put a nearby ESP32 on the same Wi-Fi in `BOARDS` as a network control. `summ.py` prints medians: never
-judge from single runs, slow Wi-Fi gave 33 to 235 s for the same upload in one night.
-
-- `otatime.py` drives `espota2.run_ota()` from the tree on `PYTHONPATH` and prints one `RESULT` line with the
-  `Update took` split, the compressed size, whether UDP was used and the time at each tenth of the upload.
-  An upload that leaves no `RESULT` line (board gone, script crash, timeout) is recorded as `rc: -1`, and `summ.py`
-  fails when a board and mode has fewer than N rows or an upload time cannot be read.
-- Boards with an `api: encryption: key` also encrypt OTA: set `API_KEY` for `otatime.py` and `apiinfo.py`. LibreTiny
-  LN882H listens for OTA on 8820, not 8892; BK72xx and RTL87xx use 8892.
-- Raw mode leaves `CLIENT_FEATURE_SUPPORTS_DEFLATE` out of the client's offer. Never switch deflate off after the
-  offer (`if deflate and 0:`): once the device accepted deflate it expects a deflate stream.
-- `-tcp` modes make `espota2._loss_reason` return None, so the client asks to stay on TCP. Clearing
-  `CLIENT_FEATURE_SUPPORTS_UDP` instead desyncs the handshake (`receiving UDP token response: timed out`).
-- LibreTiny trimmed UF2 (#21642): the CLI sends what `esphome.components.libretiny.uf2.device_ota_uf2()` returns for
-  `firmware.uf2`; that module only exists with #21642, so on older trees the full UF2 goes out. Compare the sizes
-  in the `Compressed to` lines, and rely on the API compile time check to show that the trimmed image booted.
-
-`receiving chunk result: Unknown error from ESP` is error 0xFF sent by the device, not a dropped connection. The
-device sends it for a decode or flash write error, and also when no data arrives for 105 s, so on a weak link it
-usually means a stall. A failure about 105 s after the last progress, or the same error on a raw upload, points to
-the link; to be sure, capture the device log (`Inflate err`, `Inflate overrun`, `No data received`).
-
-Results: https://github.com/esphome/esphome/issues/21639#issuecomment-6409628227 (dev and LibreTiny 1.14.0 on a
-CB3S), https://github.com/esphome/esphome/pull/21642#issuecomment-6412972562 (trimmed UF2 on CB3S, BK7238 and BW15),
-https://github.com/esphome/esphome/pull/21641#issuecomment-6412976859 (new decoder on the same three).
-
-## On-device inflate benchmark (#21639, #21641)
-
-`scripts/ota_timing/inflate_bench`: `gen_streams.py NAME=IMAGE...` cuts a 128 KB slice from each image and writes
-`bench_streams.hpp` with raw deflate streams (level 9, 4 KB and 32 KB windows). `bench.hpp` inflates every stream with
-each ring size at least the encoder window, three times, and logs the best time plus input and output rates, then
-`BENCHDONE`. `bench.sh CONFIG DEVICE` builds and uploads `bench-esp32s3.yaml` or `bench-bk72xx.yaml`, collects one pass
-over syslog and fails when a case did not reach the end of its stream.
-
-- LibreTiny defines `micros` as a macro, so the header calls `(esphome::micros)()`.
-- Keep the streams near 130 KB on a BK7231N: an image with about 330 KB of extra incompressible data failed its
-  OTA with "Writing OTA data to flash memory failed". Use one image and `--windows 12` there.
-- `bench.hpp` targets the decoder interface with `dest_limit`. #21641 drops it (the output runs into the window up
-  to `dest`); after that lands, remove the `dest_limit` line.
-
-Results: https://github.com/esphome/esphome/issues/21639#issuecomment-6409786224

.agents/skills/hardware-test/reference/recipes/wifi.md

@@ -37,44 +37,3 @@ AP start (the fix in that PR), the first AP start failed on every boot with `esp
 (DHCP server already started by the AP start event) and `Failed to enable NAT`, and the bridge only came up on the
 retry 90 s later; a client that cannot find the SSID for the first minute on an older build is that. With the fix
 the bridge is up 6 s after boot. Any change to the ESP-IDF AP start should also rerun the captive portal hammer.
-
-## Reboot against a WPA2/WPA3 PMF access point (#21590)
-
-- AP: `scripts/wpa3_ap/wdap.yaml` on a classic devkit. ESPHome `wifi: ap:` only, then an on_boot lambda switches it
-  to `WIFI_AUTH_WPA2_WPA3_PSK`, PMF capable, and registers a WIFI_EVENT handler that logs `STA JOIN` and
-  `STA LEAVE ... reason N` (the include header pulls in `esp_wifi.h`). It disables Wi-Fi after 420 s.
-- AP leave reason 3 means the station sent a deauth; reason 2 means the AP found a stale association when the
-  station came back; several reason 2 before one join are rejected reconnects.
-- DUTs (`wdbk.yaml` BK7238, `wdcb.yaml` CB3S, both on `wd-common.yaml`) list the AP at priority 10 and the house
-  network at 0, and reboot 30 s after joining the AP and 150 s after joining the house network. So they move to the
-  AP while it is up and fall back to the house network (where they can be flashed over the air) once its window
-  ends. `run.sh BUILD` flashes the AP, does OTA for the CB3S and a serial flash for the BK7238, then captures one AP
-  window; `an.py` prints each station's join and leave sequence and fails on a rejected reconnect, an AP that did
-  not switch to WPA2/WPA3 (`AP CONFIG FAILED`), a DUT missing from the AP events (`DUT_MACS`) or a BK7238 that never
-  joined the AP.
-- Gotchas: the LibreTiny build directory has two `.uf2` files, so flash `firmware.uf2`. The BK7238 serial flash
-  sometimes fails to link while the chip is in a reboot loop; retry it 3 or 4 times. OTA fails if the DUT reboots
-  mid-upload; retry.
-- Finding: BDK 3.0.78 rejects about 2 reconnects per reboot when the station left without a deauth; BDK 3.0.33
-  does not.
-
-## WISP and ALWAYS_ON AP rig (#20077)
-
-`scripts/wisp_ap`: the upstream is an ESP32-S3 with Ethernet running a WISP bridge (`wisp-upstream.yaml`) with its AP on
-10.40.0.1/24 and web buttons `ap off` and `ap on`. Its subnet must not be 192.168.4.0/24, the DUT AP's default, or
-nothing routes. The DUT is a classic devkit (`dut-wisp.yaml` or `dut-always-on.yaml`); the client is a D1 mini on
-the DUT's AP (`wispcli.yaml`) logging its DNS server, a name lookup, a GET by name, the AP itself and a LAN file by
-IP. `run.sh DUT START SECONDS T:STATE...` switches the upstream AP at the given times and `sum.py` groups the client
-results by phase. Capture the D1 mini without `--reset` (a CH340 floods garbage after an RTS reset). Clients keep
-the captive portal's DNS answer for its TTL.
-
-## AP restart with WPA3 mixed and LIGHT power save (#21531)
-
-`scripts/wifi_restart`: the WISP upstream (`wisp-upstream-wpa3.yaml`) switched to WPA2/WPA3 mixed by a script that
-runs again after every `ap on`, DUTs (`rebk.yaml`, `recb.yaml` on `re-common.yaml`) with a static IP on the bridge's
-subnet, a fallback AP, `power_save_mode: LIGHT` and syslog to the host through the NAT. `run.sh BUILD` switches the
-AP off and on three times; `an.py` fails on a reboot, a crash or a DUT that is not back on syslog within 120 s of an
-AP start. After 19 minutes the DUTs run `wifi.configure` to the house network; that keeps the static IP, so the next
-OTA needs the host to have an address on the bridge's subnet as well (an interface alias). The CB3S log is on UART1
-(TX1), so its configs need `logger: hardware_uart: UART1`. Runners must `pkill` only their own ports; a global pkill
-stops the other runs' captures.

.agents/skills/hardware-test/reference/recipes/xiaomi_ble.md

@@ -1,38 +0,0 @@
-# Xiaomi BLE
-
-## Xiaomi, ATC and PVVX parsing without the sensors (#21483)
-
-No Xiaomi devices are needed, and one ESP32 cannot hear its own advertising, so the frames are injected into the
-tracker as scan results: everything after the radio runs as normal.
-
-- `scripts/xiaomi_ble/gen.py` writes `frames.hpp` and `expected.json`: plain MiBeacon (0x50), encrypted v5 23 byte
-  with MAC and 19 byte without, real AES-CCM (`cryptography` AESCCM, tag 4, AAD 0x11, nonce = MAC reversed + pid +
-  cnt + 3 byte ext counter), ATC (13 byte, big endian) and PVVX (15 byte, little endian) 0x181A frames, a corrupted
-  tag every other cycle and a counter 0 boot frame. It models the old shared duplicate counter (`base`) and the per
-  device one (`pr`) and prints the expected publish counts.
-- `xbinject.yaml` (ESP-IDF devkit) includes `frames.hpp`; an `interval:` builds a `BLEScanResult` and calls
-  `global_esp32_ble_tracker->gap_scan_event_handler(r)`. `count.py` counts the `Got Xiaomi` blocks (sensor
-  publishes are not logged at DEBUG) and compares them with `expected.json`.
-- On ESP32 the tracker's own triggers sit in `listeners_`, which runs before `neutral_listeners_` (the
-  ble_device_base devices), so an `on_ble_service_data_advertise` never sees what a Xiaomi listener did to the
-  shared data. Check that directly: `xb_rewrite_probe(id(xa))` builds an `ESPBTDevice` with `parse_scan_rst()`,
-  calls the component's `parse_device()` and logs the service data before and after (`[probe` lines).
-- `run.sh inject pr|base` builds, flashes, captures and prints PASS when the counts match that build's model and,
-  on the PR build, the probe's service data is the same before and after `parse_device()`.
-  Base dropped a second device's frame with the same counter, the frame after a bad tag and a first frame with
-  counter 0, and rewrote the shared data in place; the PR fixed all of them.
-
-## Over the air with a second ESP32
-
-- Advertiser: an ESP32-S3 with Ethernet (OTA over Ethernet), `xbadv.yaml` with `adv_frames.hpp` from
-  `gen.py --ota`. Per frame: stop advertising, `esp_ble_gap_set_rand_addr`, `config_adv_data_raw`, start
-  non-connectable advertising with `own_addr_type` random, 20 ms interval, 250 ms dwell. Random static addresses
-  need the top two bits set, so these use C4:C1:38 instead of A4. `esp32_ble:` alone brings up the stack. The
-  web_server button starts a run: `curl -X POST -d "" http://<advertiser>/button/start/press` (no body gives 411).
-  Its `failed sends` sensor counts only GAP calls rejected when queued; a frame the controller drops later shows
-  up as missing publishes in `count.py`, the same as radio loss.
-- Receiver: `xbrecv.yaml` on the devkit, passive scan with window = interval = 100 ms. `run.sh ota pr|base` (with
-  `ADV` set) flashes it, resets it with a capture and presses start 18 s later, so the counter 0 boot frame is the
-  first one it hears.
-- Each frame arrives about 4 times; the counts matched the injection run exactly apart from one radio loss, so the
-  over the air comparison allows two missing publishes per tag.

.agents/skills/hardware-test/scripts/ble_terminate/an.py

@@ -1,90 +0,0 @@
-"""Match each proxy disconnect with the peer's own disconnect line and count the links the peer kept.
-Usage: an.py DIR LABEL [ROUNDS]   reads LABEL-drive.txt, LABEL-peer.txt (serial_capture --ms) and LABEL-proxy.txt
-(esphome logs, VERBOSE). A round counts only when the last `Conn params updated` the proxy logged since the previous
-disconnect shows latency=10; otherwise it is inconclusive. Exits 1 when the peer kept a link past 3 s (the terminate
-was lost), a round was inconclusive, or fewer than ROUNDS rounds completed."""
-
-import datetime as dt
-from pathlib import Path
-import re
-import sys
-
-D, label = Path(sys.argv[1]), sys.argv[2]
-ROUNDS = int(sys.argv[3]) if len(sys.argv) > 3 else None
-
-
-def read(name: str) -> list[str]:
-    return (
-        (D / f"{label}-{name}.txt")
-        .read_text(encoding="utf-8", errors="replace")
-        .splitlines()
-    )
-
-
-def ptime(line: str) -> float | None:
-    """Seconds since midnight from a leading [HH:MM:SS.mmm] stamp."""
-    m = re.match(r"\[(\d+):(\d+):(\d+)\.(\d+)\]", line)
-    return (
-        int(m[1]) * 3600 + int(m[2]) * 60 + int(m[3]) + int(m[4]) / 1000 if m else None
-    )
-
-
-pdisc = [
-    t
-    for line in read("peer")
-    if "PEER DISCONNECT" in line and (t := ptime(line)) is not None
-]
-params = [
-    (t, int(m[1]))
-    for line in read("proxy")
-    if "Conn params updated" in line
-    and (m := re.search(r"latency=(\d+)", line))
-    and (t := ptime(line)) is not None
-]
-res = []
-prev = -1.0
-for line in read("drive"):
-    m = re.search(
-        r"R(\d+) .*DISC_CALL ([\d.]+) DISC_DONE ([\d.]+) \(\+([\d.]+)s\)", line
-    )
-    if not m:
-        if line.startswith("R"):
-            print("  ", line)
-        continue
-    # Both captures stamp local wall clock time; compare as seconds since midnight.
-    t = dt.datetime.fromtimestamp(float(m[2])).astimezone()
-    tc = t.hour * 3600 + t.minute * 60 + t.second + t.microsecond / 1e6
-    after = [p - tc for p in pdisc if -1 < p - tc < 12]
-    window = [lat for pt, lat in params if prev < pt <= tc]
-    res.append(
-        (
-            int(m[1]),
-            float(m[4]),
-            after[0] if after else None,
-            window[-1] if window else None,
-        )
-    )
-    prev = tc
-for r, done, pd, lat in res:
-    peer = (
-        f"peer disconnect +{pd:.2f}s" if pd is not None else "peer disconnect not seen"
-    )
-    print(f"  R{r:2} central done +{done:.3f}s  {peer}  latency at disconnect {lat}")
-late = sum(1 for _, _, pd, lat in res if lat == 10 and (pd is None or pd > 3))
-inconclusive = sum(1 for *_, lat in res if lat != 10)
-print(
-    f"{label}: rounds {len(res)}, peer kept the link (>3 s or not seen) {late}, inconclusive {inconclusive}"
-)
-failed = []
-if not res:
-    failed.append("no round completed")
-if ROUNDS is not None and len(res) < ROUNDS:
-    failed.append(f"only {len(res)} of {ROUNDS} rounds completed")
-if late:
-    failed.append(f"{late} links kept")
-if inconclusive:
-    failed.append(
-        f"INCONCLUSIVE: {inconclusive} rounds had no latency=10 update before the disconnect"
-    )
-print(f"PASS: {label}" if not failed else f"FAIL: {label}: " + "; ".join(failed))
-sys.exit(1 if failed else 0)

.agents/skills/hardware-test/scripts/ble_terminate/btdrive.py

@@ -1,100 +0,0 @@
-"""Connect to the peer through the proxy, read its services, idle, disconnect; print host timestamps per round.
-Usage: btdrive.py PROXY KEY PEER_MAC ROUNDS IDLE_S"""
-
-import asyncio
-import sys
-import time
-
-from aioesphomeapi import APIClient, APIConnectionError
-
-
-async def main(host: str, key: str, peer: str, rounds: int, idle: float) -> int:
-    addr = int(peer.replace(":", ""), 16)
-    cli = APIClient(host, 6053, None, noise_psk=key)
-    await cli.connect(login=True)
-    info = await cli.device_info()
-    print(f"proxy {info.name} bt_mac {info.bluetooth_mac_address}", flush=True)
-    seen = 0
-
-    def adv(msg) -> None:
-        nonlocal seen
-        seen += sum(a.address == addr for a in msg.advertisements)
-
-    # The proxy only connects to a device its scanner has seen.
-    cli.subscribe_bluetooth_le_raw_advertisements(adv)
-    await asyncio.sleep(5)
-    print(f"peer advertisements seen in 5 s: {seen}", flush=True)
-    if not seen:
-        print("FAIL: the proxy does not see the peer", flush=True)
-        await cli.disconnect()
-        return 1
-    done = 0
-    for r in range(1, rounds + 1):
-        state: asyncio.Queue = asyncio.Queue()
-
-        def cb(
-            connected: bool, mtu: int, err: int, state: asyncio.Queue = state
-        ) -> None:
-            state.put_nowait((connected, err, time.time()))
-
-        t0 = time.time()
-        try:
-            cancel = await cli.bluetooth_device_connect(
-                addr, cb, timeout=20, address_type=0, feature_flags=0xFF
-            )
-        except (APIConnectionError, TimeoutError) as e:
-            print(f"R{r} CONNECT ERROR {type(e).__name__}", flush=True)
-            await asyncio.sleep(9)
-            continue
-        try:
-            c, err, t = await asyncio.wait_for(state.get(), 25)
-        except TimeoutError:
-            print(f"R{r} CONNECT TIMEOUT", flush=True)
-            cancel()
-            await asyncio.sleep(8)
-            continue
-        if not c:
-            print(f"R{r} CONNECT FAIL err {err} after {t - t0:.2f}s", flush=True)
-            cancel()
-            await asyncio.sleep(8)
-            continue
-        try:
-            n = len((await cli.bluetooth_gatt_get_services(addr)).services)
-        except (APIConnectionError, TimeoutError) as e:
-            n = f"err {e!r}"
-        await asyncio.sleep(idle)
-        td = time.time()
-        await cli.bluetooth_device_disconnect(addr)
-        try:
-            c2, err2, t2 = await asyncio.wait_for(state.get(), 15)
-            if c2 or not isinstance(n, int):
-                # an unexpected connect state or a failed service read: the round did not run as intended
-                print(
-                    f"R{r} BAD ROUND services {n} connected {c2} err {err2}", flush=True
-                )
-            else:
-                print(
-                    f"R{r} services {n} DISC_CALL {td:.3f} DISC_DONE {t2:.3f} (+{t2 - td:.3f}s) err {err2}",
-                    flush=True,
-                )
-                done += 1
-        except TimeoutError:
-            print(
-                f"R{r} services {n} DISC_CALL {td:.3f} no disconnect state", flush=True
-            )
-        cancel()
-        await asyncio.sleep(
-            9
-        )  # a peer that missed the terminate hits its 6 s supervision timeout in this gap
-    await cli.disconnect()
-    print(f"rounds completed {done} of {rounds}", flush=True)
-    return 0 if done == rounds else 1
-
-
-sys.exit(
-    asyncio.run(
-        main(
-            sys.argv[1], sys.argv[2], sys.argv[3], int(sys.argv[4]), float(sys.argv[5])
-        )
-    )
-)

.agents/skills/hardware-test/scripts/ble_terminate/btpeer.hpp

@@ -1,17 +0,0 @@
-#pragma once
-#include <cstring>
-#include <esp_gap_ble_api.h>
-#include "esphome/core/log.h"
-#include "central_bda.hpp"  // written by run.sh from PROXY_BT_MAC
-
-// 50 ms interval, peripheral latency 10, 6 s supervision timeout
-inline void btpeer_request_latency() {
-  esp_ble_conn_update_params_t p{};
-  memcpy(p.bda, CENTRAL_BDA, 6);
-  p.min_int = 40;
-  p.max_int = 40;
-  p.latency = 10;
-  p.timeout = 600;
-  esp_err_t err = esp_ble_gap_update_conn_params(&p);
-  ESP_LOGI("peer", "requested interval 50 ms latency 10 timeout 6 s: %d", err);
-}

.agents/skills/hardware-test/scripts/ble_terminate/btpeer.yaml

@@ -1,36 +0,0 @@
-esphome:
-  name: btpeer
-  includes:
-    - btpeer.hpp
-    - central_bda.hpp
-
-esp32:
-  board: esp32dev
-  framework:
-    type: esp-idf
-
-logger:
-  level: VERBOSE
-  logs:
-    esp32_ble: VERBOSE
-    scheduler: DEBUG
-    component: DEBUG
-
-esp32_ble:
-  max_connections: 1
-
-esp32_ble_server:
-  manufacturer: test
-  on_connect:
-    - lambda: ESP_LOGI("peer", "PEER CONNECT conn %u", (unsigned) id);
-    - delay: 4s
-    - lambda: btpeer_request_latency();
-  on_disconnect:
-    - lambda: ESP_LOGI("peer", "PEER DISCONNECT conn %u", (unsigned) id);
-  services:
-    - uuid: 6e400001-b5a3-f393-e0a9-e50e24dcca9e
-      advertise: true
-      characteristics:
-        - uuid: 6e400002-b5a3-f393-e0a9-e50e24dcca9e
-          read: true
-          value: "peer"

.agents/skills/hardware-test/scripts/ble_terminate/btproxy.yaml

@@ -1,44 +0,0 @@
-substitutions:
-  name: btproxy
-
-esphome:
-  name: ${name}
-
-esp32:
-  board: esp32-s3-devkitc-1
-  variant: esp32s3
-  flash_size: 16MB
-  framework:
-    type: esp-idf
-
-logger:
-  hardware_uart: USB_SERIAL_JTAG
-  level: VERBOSE
-  logs:
-    scheduler: DEBUG
-    component: DEBUG
-    esp32_ble_tracker: DEBUG
-
-ethernet:
-  type: W5500
-  clk_pin: GPIO13
-  mosi_pin: GPIO11
-  miso_pin: GPIO12
-  cs_pin: GPIO14
-  interrupt_pin: GPIO10
-  reset_pin: GPIO9
-
-api:
-  encryption:
-    key: !secret api_key
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-esp32_ble_tracker:
-  scan_parameters:
-    active: false
-
-bluetooth_proxy:
-  active: true

.agents/skills/hardware-test/scripts/ble_terminate/run.sh

@@ -1,31 +0,0 @@
-#!/bin/bash
-# usage: run.sh LABEL ROUNDS   build both boards, then ROUNDS connect/disconnect rounds through the proxy
-# Copy this directory into a scratch directory with a secrets.yaml (api_key, base64 Noise key) and run it there.
-# env: TREE (esphome checkout to build the proxy from), PORT (peer devkit serial port), PROXY (proxy address, flashed
-# over the air; the first flash of a fresh board goes over USB), PROXY_BT_MAC (the proxy's Bluetooth MAC, printed by
-# btdrive.py as bt_mac), PEER_MAC (the peer's Bluetooth MAC, base MAC + 2 on a classic ESP32), SC (path to
-# serial_capture.py), PY (checkout python), PEER_TREE (checkout for the peer, defaults to TREE)
-D=$(cd "$(dirname "$0")" && pwd); L=${1:?label}; N=${2:-12}; T=${TREE:?set TREE}; PT=${PEER_TREE:-$T}
-P=${PORT:?set PORT}; S3=${PROXY:?set PROXY}; SC=${SC:?set SC}; PY=${PY:-$T/venv/bin/python}
-PEER=${PEER_MAC:?set PEER_MAC}; CM=${PROXY_BT_MAC:?set PROXY_BT_MAC}
-KEY=$(sed -n 's/^api_key: *"\{0,1\}\([^"]*\)"\{0,1\}$/\1/p' "$D/secrets.yaml")
-[ -n "$KEY" ] || { echo "FAIL: no api_key in secrets.yaml"; exit 1; }
-cd "$D" || exit 1
-printf '#pragma once\n#include <cstdint>\nstatic const uint8_t CENTRAL_BDA[6] = {0x%s};\n' "${CM//:/, 0x}" > central_bda.hpp
-(cd "$PT" && PYTHONUNBUFFERED=1 timeout 1500 $PY -m esphome run --no-logs "$D/btpeer.yaml" --device "$P" > "$D/$L-peer-upload.log" 2>&1) \
-  || { echo "FAIL: peer build or upload failed"; exit 1; }
-(cd "$T" && PYTHONUNBUFFERED=1 timeout 1500 $PY -m esphome run --no-logs "$D/btproxy.yaml" --device "$S3" > "$D/$L-proxy-upload.log" 2>&1) \
-  || { echo "FAIL: proxy build or upload failed"; exit 1; }
-SECS=$((N * 26 + 40))
-pkill -f "[s]erial_capture.py $P"
-$PY "$SC" "$P" $SECS "$D/$L-peer.txt" --ms > /dev/null 2>&1 & CAP=$!
-(cd "$T" && PYTHONUNBUFFERED=1 exec timeout $((SECS - 10)) $PY -m esphome logs "$D/btproxy.yaml" --device "$S3" > "$D/$L-proxy.txt" 2>&1) & LOGS=$!
-trap 'kill $CAP $LOGS 2>/dev/null' EXIT
-sleep 6
-$PY "$D/btdrive.py" "$S3" "$KEY" "$PEER" "$N" 10 > "$D/$L-drive.txt" 2>&1; RC=$?
-sleep 10
-kill $CAP $LOGS 2>/dev/null; wait 2>/dev/null; trap - EXIT
-[ -s "$D/$L-peer.txt" ] || { tail -3 "$D/$L-drive.txt"; echo "FAIL: peer capture got nothing"; exit 1; }
-$PY "$D/an.py" "$D" "$L" "$N"; ARC=$?
-[ "$RC" = 0 ] || { tail -1 "$D/$L-drive.txt"; echo "FAIL: driver rc $RC (not every round completed)"; exit 1; }
-exit $ARC

.agents/skills/hardware-test/scripts/i2c_slave/i2cbk.yaml

@@ -1,79 +0,0 @@
-# BK7238 bit banged master; needs the BK72xx software I2C bus from #21586 (dev rejects the pins).
-# The ESP32 control is the same i2c, sensor and interval blocks on a devkit (sda GPIO21, scl GPIO22, 25 or 50 kHz).
-substitutions:
-  frequency: 100kHz
-
-esphome:
-  name: i2cbk
-
-bk72xx:
-  board: xh-wb3s
-
-logger:
-  hardware_uart: UART1
-  level: DEBUG
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-
-api:
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-i2c:
-  id: bus
-  sda: P26
-  scl: P24
-  scan: true
-  frequency: ${frequency}
-  timeout: 20ms  # clock stretch limit; the bus default (1 ms) is shorter than the slave's 5 ms stretch
-
-sensor:
-  - platform: hdc1080
-    address: 0x40
-    update_interval: 5s
-    temperature:
-      name: fake temperature
-    humidity:
-      name: fake humidity
-
-globals:
-  - id: n
-    type: uint8_t
-    initial_value: "0"
-  - id: n_ok
-    type: uint32_t
-    initial_value: "0"
-  - id: n_bad
-    type: uint32_t
-    initial_value: "0"
-
-interval:
-  - interval: 2s
-    then:
-      - lambda: |-
-          uint8_t k = ++id(n);
-          uint8_t w[4] = {0x20, k, (uint8_t) ~k, 0xA5};
-          uint32_t t0 = micros();
-          auto e1 = id(bus)->write(0x40, w, 4);
-          uint8_t reg = 0x20, r[3] = {0, 0, 0};
-          auto e2 = id(bus)->write_readv(0x40, &reg, 1, r, 3);
-          uint32_t t1 = micros();
-          uint8_t x;
-          auto e3 = id(bus)->read(0x41, &x, 1);
-          uint8_t s1 = 0x7E, s2 = 0x7F, rr[2];
-          uint32_t t2 = micros();
-          auto e4 = id(bus)->write_readv(0x40, &s1, 1, rr, 2);
-          uint32_t t3 = micros();
-          auto e5 = id(bus)->write_readv(0x40, &s2, 1, rr, 2);
-          uint32_t t4 = micros();
-          // the absent address must NACK and both clock stretched reads must succeed
-          bool ok = e1 == 0 && e2 == 0 && r[0] == k && r[1] == (uint8_t) ~k && r[2] == 0xA5 && e3 != 0 && e4 == 0 &&
-                    e5 == 0;
-          if (ok) id(n_ok)++; else id(n_bad)++;
-          ESP_LOGI("t", "RW %s e1 %d e2 %d got %02X %02X %02X want %02X %02X A5 | %u us | absent e %d | stretch500 e %d %u us | stretch5ms e %d %u us | ok %u bad %u",
-                   ok ? "OK" : "BAD", e1, e2, r[0], r[1], r[2], k, (uint8_t) ~k, (unsigned) (t1 - t0), e3, e4,
-                   (unsigned) (t3 - t2), e5, (unsigned) (t4 - t3), (unsigned) id(n_ok), (unsigned) id(n_bad));

.agents/skills/hardware-test/scripts/i2c_slave/i2cslave.hpp

@@ -1,50 +0,0 @@
-#pragma once
-#include <Wire.h>
-#include "esphome/core/log.h"
-
-// Fake HDC1080 at 0x40: 0x00 temperature (26.0 C), 0x01 humidity (50 %), other registers are a
-// 256 byte file; reading 0x7E holds SCL for 500 us, reading 0x7F for 5 ms.
-static volatile uint8_t SL_REGS[256];
-static volatile uint8_t sl_ptr = 0;
-static volatile uint32_t sl_rx = 0, sl_tx = 0, sl_stretch = 0;
-
-static void sl_on_receive(int n) {
-  if (n < 1)
-    return;
-  sl_ptr = Wire.read();
-  uint8_t p = sl_ptr;
-  while (--n > 0 && Wire.available())
-    SL_REGS[p++] = Wire.read();
-  sl_rx++;
-}
-
-static void sl_on_request() {
-  uint8_t b[8];
-  uint8_t p = sl_ptr;
-  sl_tx++;
-  if (p == 0x7E || p == 0x7F) {
-    sl_stretch++;
-    delayMicroseconds(p == 0x7E ? 500 : 5000);
-  }
-  for (int i = 0; i < 8; i++)
-    b[i] = SL_REGS[(uint8_t) (p + i)];
-  if (p == 0x00) {
-    b[0] = 0x66;
-    b[1] = 0x66;
-  } else if (p == 0x01) {
-    b[0] = 0x80;
-    b[1] = 0x00;
-  }
-  Wire.write(b, 8);
-}
-
-inline void i2cslave_begin() {
-  Wire.begin(4, 5, 0x40);
-  Wire.onReceive(sl_on_receive);
-  Wire.onRequest(sl_on_request);
-  ESP_LOGI("slave", "I2C slave at 0x40 on SDA GPIO4 SCL GPIO5");
-}
-
-inline void i2cslave_report() {
-  ESP_LOGI("slave", "rx %u tx %u stretch %u", (unsigned) sl_rx, (unsigned) sl_tx, (unsigned) sl_stretch);
-}

.agents/skills/hardware-test/scripts/i2c_slave/i2cslave.yaml

@@ -1,29 +0,0 @@
-esphome:
-  name: i2cslave
-  libraries:
-    - Wire
-  includes:
-    - i2cslave.hpp
-  platformio_options:
-    board_build.f_cpu: 160000000L
-  on_boot:
-    priority: -100
-    then:
-      - lambda: i2cslave_begin();
-
-esp8266:
-  board: d1_mini
-
-logger:
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-
-ota:
-  - platform: esphome
-
-interval:
-  - interval: 10s
-    then:
-      - lambda: i2cslave_report();

.agents/skills/hardware-test/scripts/libretiny_crash/rtl_drive.py

@@ -1,124 +0,0 @@
-"""Press one crash button after another on an RTL8720C test build and keep the decoded API logs of each next boot.
-Usage: rtl_drive.py HOST OUTDIR TREE YAML BUTTON...   (button names from templates/rtl8720c-crash-buttons-dut.yaml)
-Prints PRESS lines with the wall clock time, so resets can be timed against a serial capture taken with --ms.
-Each case waits for the board to answer on the API port again, then saves 15 s of `esphome logs` (run from TREE,
-so the CLI decodes the addresses) as OUTDIR/caseN-BUTTON.txt. The run prints CASE N BUTTON and exits 1 with NO RESET
-when the API port never closes after the press (the button did not reset the board), NO BOOT when the board is not
-back within BOOT_DEADLINE_S, and NO LOGS when the log capture never connected."""
-
-import asyncio
-import contextlib
-import os
-from pathlib import Path
-import socket
-import subprocess
-import sys
-import time
-
-from aioesphomeapi import APIClient
-
-host, out, tree, yaml = sys.argv[1:5]
-buttons = sys.argv[5:]
-BOOT_DEADLINE_S = 120
-# Every case button resets the board: a fault, the watchdog (hang) or a restart. The watchdog takes about 11 s.
-RESET_DEADLINE_S = 20
-
-
-def port_open() -> bool:
-    try:
-        socket.create_connection((host, 6053), 1).close()
-    except OSError:
-        return False
-    return True
-
-
-def wait_for_port() -> bool:
-    deadline = time.monotonic() + BOOT_DEADLINE_S
-    while not port_open():
-        if time.monotonic() > deadline:
-            return False
-        time.sleep(1)
-    return True
-
-
-def wait_for_reset() -> bool:
-    deadline = time.monotonic() + RESET_DEADLINE_S
-    while port_open():
-        if time.monotonic() > deadline:
-            return False
-        time.sleep(0.2)
-    return True
-
-
-def fail(i: int, name: str, why: str) -> None:
-    print(f"CASE {i} {name} {why}", flush=True)
-    sys.exit(1)
-
-
-async def button_keys() -> dict[str, int]:
-    cli = APIClient(host, 6053, None)
-    await cli.connect(login=True)
-    try:
-        entities, _ = await cli.list_entities_services()
-    finally:
-        await cli.disconnect()
-    return {e.name: e.key for e in entities if type(e).__name__ == "ButtonInfo"}
-
-
-async def press(name: str, key: int) -> None:
-    cli = APIClient(host, 6053, None)
-    await cli.connect(login=True)
-    now = time.time()
-    print(
-        f"PRESS {name} at {time.strftime('%H:%M:%S', time.localtime(now))}.{int(now * 1000) % 1000:03d}",
-        flush=True,
-    )
-    cli.button_command(key)
-    await asyncio.sleep(0.5)
-    # the board resets within about a second, so the disconnect reply may never come
-    with contextlib.suppress(Exception):
-        await asyncio.wait_for(cli.disconnect(), 2)
-
-
-if not wait_for_port():
-    sys.exit("NO BOOT before the first case")
-# Check every name up front, so a typo in the last case does not waste the crashes before it
-keys = asyncio.run(button_keys())
-if missing := [b for b in buttons if b not in keys]:
-    sys.exit(f"Unknown buttons {missing}; the board has {sorted(keys)}")
-
-for i, name in enumerate(buttons):
-    if not wait_for_port():
-        fail(i, name, "NO BOOT")
-    time.sleep(5)
-    asyncio.run(press(name, keys[name]))
-    if not wait_for_reset():
-        fail(i, name, "NO RESET")
-    time.sleep(20)  # boot and Wi-Fi
-    if not wait_for_port():
-        fail(i, name, "NO BOOT")
-    case_file = Path(out) / f"case{i}-{name.replace(' ', '_')}.txt"
-    with case_file.open("w", encoding="utf-8") as fh:
-        subprocess.run(
-            [
-                "timeout",
-                "15",
-                sys.executable,
-                "-m",
-                "esphome",
-                "logs",
-                yaml,
-                "--device",
-                host,
-            ],
-            cwd=tree,
-            env={**os.environ, "PYTHONPATH": tree, "PYTHONUNBUFFERED": "1"},
-            stdout=fh,
-            stderr=subprocess.STDOUT,
-            check=False,
-        )
-    if "Successful handshake" not in case_file.read_text(
-        encoding="utf-8", errors="replace"
-    ):
-        fail(i, name, "NO LOGS")
-    print(f"CASE {i} {name} done", flush=True)

.agents/skills/hardware-test/scripts/ota_timing/apiinfo.py

@@ -1,43 +0,0 @@
-"""Check over the API that each board runs the expected build.
-Usage: apiinfo.py HOST[=BUILD_INFO_JSON]...
-Prints name and compilation time per host. With a build_info.json (from the build directory), the board's
-compilation time must equal that build's build_time_str. Exits 1 when a host fails or runs another build.
-env: API_KEY (the boards' api encryption key, when they have one)"""
-
-import asyncio
-import json
-import os
-from pathlib import Path
-import sys
-
-from aioesphomeapi import APIClient, APIConnectionError
-
-
-async def info(host: str) -> tuple[str, str]:
-    cli = APIClient(host, 6053, None, noise_psk=os.environ.get("API_KEY"))
-    await cli.connect(login=True)
-    try:
-        i = await cli.device_info()
-    finally:
-        await cli.disconnect()
-    return i.name, i.compilation_time
-
-
-bad = 0
-for arg in sys.argv[1:]:
-    host, _, build_info = arg.partition("=")
-    try:
-        name, built = asyncio.run(asyncio.wait_for(info(host), 30))
-    except (APIConnectionError, TimeoutError, OSError) as err:
-        print("API", host, "ERROR", repr(err), flush=True)
-        bad += 1
-        continue
-    want = (
-        json.loads(Path(build_info).read_text(encoding="utf-8"))["build_time_str"]
-        if build_info
-        else None
-    )
-    ok = want is None or built == want
-    bad += not ok
-    print("API", host, name, built, "" if ok else f"MISMATCH want {want}", flush=True)
-sys.exit(1 if bad else 0)

.agents/skills/hardware-test/scripts/ota_timing/inflate_bench/bench-bk72xx.yaml

@@ -1,42 +0,0 @@
-# Inflate benchmark: run gen_streams.py first, then bench.sh. Results go out over syslog to syslog_ip:5514.
-substitutions:
-  name: inflbench-bk
-  board: cb3s
-
-esphome:
-  name: ${name}
-  includes:
-    - bench_streams.hpp
-    - bench.hpp
-
-bk72xx:
-  board: ${board}
-
-logger:
-  hardware_uart: UART1
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-
-api:
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-udp:
-  addresses:
-    - !secret syslog_ip
-
-time:
-  - platform: sntp
-
-syslog:
-  port: 5514
-
-interval:
-  - interval: 90s
-    then:
-      - delay: 20s
-      - lambda: run_inflate_bench();

.agents/skills/hardware-test/scripts/ota_timing/inflate_bench/bench-esp32s3.yaml

@@ -1,44 +0,0 @@
-# Inflate benchmark: run gen_streams.py first, then bench.sh. Results go out over syslog to syslog_ip:5514.
-substitutions:
-  name: inflbench-s3
-
-esphome:
-  name: ${name}
-  includes:
-    - bench_streams.hpp
-    - bench.hpp
-
-esp32:
-  board: esp32-s3-devkitc-1
-  variant: esp32s3
-  framework:
-    type: esp-idf
-
-logger:
-  hardware_uart: USB_SERIAL_JTAG
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-
-api:
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-udp:
-  addresses:
-    - !secret syslog_ip
-
-time:
-  - platform: sntp
-
-syslog:
-  port: 5514
-
-interval:
-  - interval: 90s
-    then:
-      - delay: 20s
-      - lambda: run_inflate_bench();

.agents/skills/hardware-test/scripts/ota_timing/inflate_bench/bench.hpp

@@ -1,54 +0,0 @@
-#pragma once
-// On-device inflate speed for the ESPHome OTA decoder. Targets the decoder interface with dest_limit (dev as of
-// this writing); once the interface without dest_limit lands (#21641), drop the dest_limit line.
-#include "esphome/components/esphome/ota/ota_esphome_inflate.h"
-#include "esphome/core/application.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/log.h"
-#include "bench_streams.hpp"
-
-static uint8_t bench_ring[32768];
-static OtaInflateState bench_state;
-
-// LibreTiny defines micros as a macro; the parentheses call the ESPHome function.
-inline uint32_t bench_now() { return (esphome::micros) (); }
-
-inline void run_inflate_bench() {
-  unsigned expected = 0;
-  for (const auto &c : BENCH_CASES) {
-    for (unsigned ring : {4096u, 8192u, 16384u, 32768u})
-      expected += ring >= c.enc_window;
-  }
-  ESP_LOGI("bench", "BENCHSTART cases=%u", expected);
-  for (const auto &c : BENCH_CASES) {
-    for (unsigned ring : {4096u, 8192u, 16384u, 32768u}) {
-      if (ring < c.enc_window)
-        continue;
-      uint32_t best = UINT32_MAX;
-      size_t out = 0;
-      int res = 0;
-      for (int rep = 0; rep < 3; rep++) {
-        ota_inflate_init(&bench_state, bench_ring, ring);
-        bench_state.source = c.data;
-        bench_state.source_limit = c.data + c.len;
-        bench_state.source_read_cb = [](OtaInflateState *) -> int { return -1; };
-        out = 0;
-        uint32_t t0 = bench_now();
-        do {
-          bench_state.dest = bench_ring;
-          bench_state.dest_limit = bench_ring + ring;
-          res = ota_inflate(&bench_state);
-          out += bench_state.dest - bench_ring;
-          esphome::App.feed_wdt();
-        } while (res == OTA_INFLATE_OK);
-        uint32_t dt = bench_now() - t0;
-        if (dt < best)
-          best = dt;
-      }
-      ESP_LOGI("bench", "%s enc=%u ring=%u in=%u out=%u/%u res=%d best_us=%u out_kBps=%u in_kBps=%u", c.name,
-               c.enc_window, ring, (unsigned) c.len, (unsigned) out, (unsigned) c.raw, res, (unsigned) best,
-               (unsigned) ((uint64_t) out * 1000 / best), (unsigned) ((uint64_t) c.len * 1000 / best));
-    }
-  }
-  ESP_LOGI("bench", "BENCHDONE");
-}

.agents/skills/hardware-test/scripts/ota_timing/inflate_bench/bench.sh

@@ -1,42 +0,0 @@
-#!/bin/bash
-# usage: bench.sh CONFIG DEVICE   build and upload CONFIG (bench-bk72xx or bench-esp32s3) to DEVICE (OTA address or
-# serial port), then collect one benchmark pass over syslog. Run gen_streams.py in this directory first.
-# Copy this directory into a scratch directory with a secrets.yaml (wifi_ssid, wifi_password, syslog_ip = this
-# host's address) and run it there. env: TREE (esphome checkout under test), PY (checkout python), WAIT (seconds to
-# wait for a pass, default 300)
-D=$(cd "$(dirname "$0")" && pwd); C=${1:?config name}; DEV=${2:?device}; T=${TREE:?set TREE}
-PY=${PY:-$T/venv/bin/python}; WAIT=${WAIT:-300}; OUT=$D/$C-syslog.txt
-[ -f "$D/bench_streams.hpp" ] || { echo "FAIL: run gen_streams.py first"; exit 1; }
-(cd "$T" && PYTHONUNBUFFERED=1 timeout 1500 $PY -m esphome run --no-logs "$D/$C.yaml" --device "$DEV" > "$D/$C-upload.log" 2>&1) \
-  || { echo "FAIL: build or upload failed, see $C-upload.log"; exit 1; }
-$PY - "$OUT" "$WAIT" << 'PYEOF'
-import socket
-import sys
-import time
-
-s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-s.bind(("0.0.0.0", 5514))
-s.settimeout(1)
-end = time.time() + int(sys.argv[2])
-started = False
-with open(sys.argv[1], "w", encoding="utf-8") as out:
-    while time.time() < end:
-        try:
-            d, _ = s.recvfrom(2048)
-        except TimeoutError:
-            continue
-        line = d.decode(errors="replace").strip()
-        # keep one whole pass: lines from a pass already under way are dropped
-        started = started or "BENCHSTART" in line
-        if started and "bench" in line:
-            print(line, file=out, flush=True)
-            if "BENCHDONE" in line:
-                break
-PYEOF
-grep -q BENCHDONE "$OUT" || { echo "FAIL: no complete pass within $WAIT s"; exit 1; }
-grep -o 'bench:[0-9]*\]: .*' "$OUT"
-BAD=$(grep 'best_us=' "$OUT" | grep -v 'res=1 ' | wc -l | tr -d ' ')
-SHORT=$(grep -o 'out=[0-9]*/[0-9]*' "$OUT" | awk -F'[=/]' '$2 != $3' | wc -l | tr -d ' ')
-WANT=$(grep -o 'BENCHSTART cases=[0-9]*' "$OUT" | cut -d= -f2); GOT=$(grep -c 'best_us=' "$OUT")
-[ "$BAD" = 0 ] && [ "$SHORT" = 0 ] && [ "$GOT" = "$WANT" ] && echo "PASS" \
-  || { echo "FAIL: $BAD cases did not finish, $SHORT short outputs, $GOT of $WANT results (lost syslog lines)"; exit 1; }

.agents/skills/hardware-test/scripts/ota_timing/inflate_bench/gen_streams.py

@@ -1,43 +0,0 @@
-"""Write bench_streams.hpp: one 128 KB slice per image, raw deflate at level 9 with 4 KB and 32 KB windows.
-Usage: gen_streams.py NAME=IMAGE[@OFFSET]... [--windows 12,15]
-Each image gives one case per window. Keep the total near 130 KB on a BK7231N: an image with about 330 KB of extra
-incompressible data failed its OTA ("Writing OTA data to flash memory failed"); use one image and --windows 12 there."""
-
-import argparse
-from pathlib import Path
-import zlib
-
-SLICE = 128 * 1024
-ap = argparse.ArgumentParser()
-ap.add_argument("images", nargs="+")
-ap.add_argument("--windows", default="12,15")
-args = ap.parse_args()
-arrays, cases, total = [], [], 0
-for spec in args.images:
-    name, _, rest = spec.partition("=")
-    path, _, offset = rest.partition("@")
-    raw = Path(path).read_bytes()[int(offset or 0) :][:SLICE]
-    for wbits in (int(w) for w in args.windows.split(",")):
-        data = zlib.compress(raw, 9, -wbits)
-        total += len(data)
-        var = f"{name}_w{wbits}"
-        arrays.append(
-            f"static const uint8_t {var}[{len(data)}] = {{{','.join(map(str, data))}}};"
-        )
-        cases.append(f'{{"{name}", {var}, sizeof({var}), {len(raw)}u, {1 << wbits}u}}')
-        print(f"{var}: {len(raw)} -> {len(data)} bytes")
-head = "#pragma once\n#include <cstddef>\n#include <cstdint>\n"
-case_struct = (
-    "struct BenchCase {\n  const char *name;\n  const uint8_t *data;\n  size_t len;\n  size_t raw;\n"
-    "  unsigned enc_window;\n};\n"
-)
-body = (
-    "\n".join(arrays)
-    + "\n"
-    + case_struct
-    + "static const BenchCase BENCH_CASES[] = {"
-    + ", ".join(cases)
-    + "};\n"
-)
-Path("bench_streams.hpp").write_text(head + body, encoding="utf-8")
-print(f"total {total} bytes of streams")

.agents/skills/hardware-test/scripts/ota_timing/otatime.py

@@ -1,88 +0,0 @@
-"""Time one ESPHome OTA upload and print one RESULT json line.
-Usage: otatime.py HOST IMAGE MODE   (MODE: deflate, raw, deflate-tcp or raw-tcp)
-env: OTA_PORT (default 3232), OTA_PASSWORD, API_KEY (a board with an api encryption key also encrypts OTA),
-TAG (label stored in the result)
-Run it with the checkout under test first on PYTHONPATH, so its espota2 is the client being measured.
-raw: the client leaves deflate out of its feature offer. Never patch the deflate branch off after the offer: once
-the device accepted deflate it expects a deflate stream. -tcp: the link is reported clean, so the client asks to
-stay on TCP. Clearing the UDP feature bit instead desyncs the handshake ("receiving UDP token response: timed out")."""
-
-import json
-import logging
-import os
-from pathlib import Path
-import sys
-import time
-
-import esphome.espota2 as espota
-
-host, image, mode = sys.argv[1], Path(sys.argv[2]), sys.argv[3]
-# Assigning a missing attribute would silently do nothing, so a renamed name must stop the run
-for name in ("CLIENT_FEATURE_SUPPORTS_DEFLATE", "_loss_reason"):
-    if not hasattr(espota, name):
-        sys.exit(f"espota2 in this tree has no {name}; update otatime.py")
-if mode.startswith("raw"):
-    espota.CLIENT_FEATURE_SUPPORTS_DEFLATE = 0
-if mode.endswith("-tcp"):
-    espota._loss_reason = lambda *a: None  # noqa: SLF001
-marks: list[tuple[float, float]] = []
-
-
-class Recorder:
-    """Stands in for the progress bar and records when each fraction went out."""
-
-    def __init__(self, *args) -> None:
-        pass
-
-    def update(self, progress: float) -> None:
-        marks.append((time.perf_counter(), progress))
-
-    def done(self) -> None:
-        pass
-
-
-espota.ProgressBar = Recorder
-lines: list[str] = []
-
-
-class Keep(logging.Handler):
-    def emit(self, record: logging.LogRecord) -> None:
-        lines.append(record.getMessage())
-
-
-logging.basicConfig(level=logging.INFO)
-logging.getLogger().addHandler(Keep())
-t0 = time.perf_counter()
-rc, _ = espota.run_ota(
-    host,
-    int(os.environ.get("OTA_PORT", "3232")),
-    os.environ.get("OTA_PASSWORD"),
-    image,
-    noise_psk=os.environ.get("API_KEY"),
-)
-total = time.perf_counter() - t0
-deciles = []
-if marks:
-    start = marks[0][0]
-    for q in range(1, 11):
-        hit = next((t for t, f in marks if f >= q / 10 - 1e-9), None)
-        deciles.append(round(hit - start, 2) if hit is not None else None)
-result = {
-    "board": os.environ.get("TAG", ""),
-    "mode": mode,
-    "rc": rc,
-    "total": round(total, 2),
-    "took": next((x for x in lines if x.startswith("Update took")), ""),
-    "size": next((x for x in lines if "Compressed to" in x), ""),
-    "udp": any("Using UDP" in x for x in lines),
-    "deciles": deciles,
-}
-# The log must agree with the mode, or the row would be counted under the wrong mode
-if mode.startswith("raw") and result["size"]:
-    result["rc"] = rc = rc or 1
-    print("raw mode upload was compressed anyway", file=sys.stderr)
-if mode.endswith("-tcp") and result["udp"]:
-    result["rc"] = rc = rc or 1
-    print("-tcp mode upload switched to UDP", file=sys.stderr)
-print("RESULT", json.dumps(result), flush=True)
-sys.exit(1 if rc else 0)

.agents/skills/hardware-test/scripts/ota_timing/run.sh

@@ -1,65 +0,0 @@
-#!/bin/bash
-# usage: run.sh N PHASE...   OTA upload timing A/B: per phase build every board, one warm-up upload per board
-# (installs the phase's build, not timed), an API check that each board booted that build, then N rounds of every
-# MODE on every board, interleaved so the boards share the same air. summ.py prints medians at the end.
-# Layout: $D/PHASE/NAME.yaml per phase and board (with its secrets.yaml); outputs go to $D/res.txt.
-# env: BOARDS ("NAME,HOST,OTA_PORT ..."; add an ESP32 on the same Wi-Fi as a network control), TREE_<PHASE>
-# (esphome checkout for each phase, e.g. TREE_base, TREE_pr), PY (python with esphome's requirements),
-# MODES (default "deflate-tcp raw-tcp"), SETTLE (seconds after a board answers again, default 15), API_KEY (when the
-# boards have an api encryption key; it also encrypts their OTA, so all boards in one run need the same key)
-D=$(cd "$(dirname "$0")" && pwd); N=${1:?rounds}; shift; [ $# -gt 0 ] || { echo "usage: run.sh N PHASE..."; exit 2; }
-B=${BOARDS:?set BOARDS}; PY=${PY:?set PY}; MODES=${MODES:-deflate-tcp raw-tcp}; SETTLE=${SETTLE:-15}
-wait_up() {  # wait_up HOST PORT: up to 5 minutes for the OTA port to answer
-  local i
-  for i in $(seq 60); do
-    "$PY" -c "import socket,sys; socket.create_connection((sys.argv[1], int(sys.argv[2])), 2).close()" "$1" "$2" 2>/dev/null \
-      && { sleep "$SETTLE"; return 0; }
-    sleep 5
-  done
-  return 1
-}
-up() {  # up PHASE NAME HOST PORT MODE TAG OUTFILE; returns 1 unless the upload succeeded
-  local tree=TREE_$1 out=""
-  if wait_up "$3" "$4"; then
-    out=$(TAG=$1-$2-$6 OTA_PORT=$4 PYTHONPATH=${!tree} timeout 900 "$PY" "$D/otatime.py" "$3" \
-      "$(cat "$D/img-$1-$2.txt")" "$5" 2>> "$D/stderr-$1.log" | grep RESULT)
-  else
-    echo "FAIL: $3 not answering on $4"
-  fi
-  # no RESULT line (board gone, otatime.py crashed or timed out): record a failed upload so summ.py counts it
-  [ -n "$out" ] || out="RESULT {\"board\": \"$1-$2-$6\", \"mode\": \"$5\", \"rc\": -1, \"total\": 0, \"took\": \"\", \"size\": \"\", \"udp\": false, \"deciles\": []}"
-  echo "$out" | tee -a "$7"
-  [[ $out == *'"rc": 0,'* ]]
-}
-# results from an earlier run would fill in for missing rows: move them aside
-for f in res.txt warm.txt api.txt; do [ -f "$D/$f" ] && mv "$D/$f" "$D/$f.$(date +%Y%m%d-%H%M%S)"; done
-for ph in "$@"; do
-  tree=TREE_$ph; [ -n "${!tree}" ] || { echo "FAIL: set $tree"; exit 1; }
-  checks=()
-  for b in $B; do
-    IFS=, read -r n h p <<< "$b"
-    (cd "${!tree}" && PYTHONUNBUFFERED=1 timeout 1500 "$PY" -m esphome compile "$D/$ph/$n.yaml") > "$D/build-$ph-$n.log" 2>&1 \
-      || { echo "FAIL: build $ph/$n"; exit 1; }
-    # the image the CLI uploads (CORE.firmware_bin): ESP-IDF build, LibreTiny UF2, else the PlatformIO bin
-    bd=$D/$ph/.esphome/build/$n; : > "$D/img-$ph-$n.txt"
-    for f in "$bd/build/$n.bin" "$bd/.pioenvs/$n/firmware.uf2" "$bd/.pioenvs/$n/firmware.bin"; do
-      [ -f "$f" ] && { echo "$f" > "$D/img-$ph-$n.txt"; break; }
-    done
-    [ -s "$D/img-$ph-$n.txt" ] || { echo "FAIL: no firmware image under $bd"; exit 1; }
-    case $(cat "$D/img-$ph-$n.txt") in
-      *.uf2) PYTHONPATH=${!tree} "$PY" "$D/trim_uf2.py" "$(cat "$D/img-$ph-$n.txt")" > "$D/img-$ph-$n.tmp" \
-        && mv "$D/img-$ph-$n.tmp" "$D/img-$ph-$n.txt" || { echo "FAIL: trim_uf2.py $ph/$n"; exit 1; } ;;
-    esac
-    checks+=("$h=$D/$ph/.esphome/build/$n/build_info.json")
-  done
-  for b in $B; do IFS=, read -r n h p <<< "$b"; up "$ph" "$n" "$h" "$p" deflate-tcp warm "$D/warm.txt" || exit 1; done
-  for b in $B; do IFS=, read -r n h p <<< "$b"; wait_up "$h" "$p"; done
-  "$PY" "$D/apiinfo.py" "${checks[@]}" | tee -a "$D/api.txt"; [ "${PIPESTATUS[0]}" = 0 ] || { echo "FAIL: $ph did not boot everywhere"; exit 1; }
-  for i in $(seq "$N"); do
-    for m in $MODES; do
-      for b in $B; do IFS=, read -r n h p <<< "$b"; up "$ph" "$n" "$h" "$p" "$m" "r$i" "$D/res.txt"; done
-    done
-  done
-  echo "PHASE DONE $ph"
-done
-"$PY" "$D/summ.py" "$D/res.txt" "$N"

.agents/skills/hardware-test/scripts/ota_timing/summ.py

@@ -1,43 +0,0 @@
-"""Median upload time per board and mode from otatime.py RESULT lines.
-Usage: summ.py RESULTS_FILE [ROUNDS]
-Exits 1 when any upload failed, an upload time could not be read, or (with ROUNDS) a board and mode has fewer rows."""
-
-import json
-from pathlib import Path
-import re
-import statistics
-import sys
-
-rows = [
-    json.loads(line.split("RESULT ", 1)[1])
-    for line in Path(sys.argv[1]).read_text(encoding="utf-8").splitlines()
-    if "RESULT " in line
-]
-by: dict[tuple[str, str], list[dict]] = {}
-for r in rows:
-    m = re.search(r"upload ([\d.]+)", r["took"])
-    r["up"] = float(m[1]) if m else None
-    # TAG is PHASE-BOARD-ROUND; group per phase and board
-    by.setdefault((r["board"].rsplit("-", 1)[0], r["mode"]), []).append(r)
-rounds = int(sys.argv[2]) if len(sys.argv) > 2 else 0
-failed = unparsed = short = 0
-for (board, mode), v in sorted(by.items()):
-    ok = sorted(r["up"] for r in v if r["rc"] == 0 and r["up"] is not None)
-    fails = sum(r["rc"] != 0 for r in v)
-    failed += fails
-    unparsed += sum(r["rc"] == 0 and r["up"] is None for r in v)
-    short += len(v) < rounds
-    udp = sum(r["udp"] for r in v if r["rc"] == 0)
-    med = statistics.median(ok) if ok else None
-    print(
-        f"{board:24} {mode:12} n={len(v)} fail={fails} udp={udp} median={med} upload s: {ok}"
-    )
-if not rows:
-    print("FAIL: no results")
-elif failed or unparsed or short:
-    print(
-        f"FAIL: {failed} failed uploads, {unparsed} without an upload time, {short} groups under {rounds} rows"
-    )
-else:
-    print("PASS")
-sys.exit(0 if rows and not (failed or unparsed or short) else 1)

.agents/skills/hardware-test/scripts/ota_timing/trim_uf2.py

@@ -1,24 +0,0 @@
-"""Write the trimmed LibreTiny UF2 the CLI would send (esphome#21642) next to firmware.uf2 and print its path.
-Usage: trim_uf2.py FIRMWARE_UF2   (run with the phase's checkout on PYTHONPATH)
-Prints the input path unchanged when the tree has no device_ota_uf2() or there is nothing to drop."""
-
-from pathlib import Path
-import sys
-
-src = Path(sys.argv[1])
-try:
-    from esphome.components.libretiny.uf2 import device_ota_uf2
-except ModuleNotFoundError as err:
-    if err.name != "esphome.components.libretiny.uf2":
-        raise
-    print("no device_ota_uf2() in this tree, sending the full UF2", file=sys.stderr)
-    print(src)
-    sys.exit(0)
-data = src.read_bytes()
-if (trimmed := device_ota_uf2(data)) is None:
-    print(src)
-    sys.exit(0)
-out = src.with_name("firmware.ota.uf2")
-out.write_bytes(trimmed)
-print(f"trimmed {len(data)} -> {len(trimmed)} bytes", file=sys.stderr)
-print(out)

.agents/skills/hardware-test/scripts/wifi_restart/an.py

@@ -1,95 +0,0 @@
-"""Summarise the AP restart run: alive lines over syslog per DUT, reboots, gaps, recovery after each AP start.
-Usage: an.py DIR BUILD [RECOVER_S]   reads BUILD-marks.txt, BUILD-syslog.txt, BUILD-bk.txt, BUILD-cb.txt (optional)
-and BUILD-up.txt (the bridge's API logs)
-Exits 1 when a DUT rebooted, crashed, sent nothing, or had no syslog line within RECOVER_S (default 120) of an
-AP start, when the BK7238 capture (or a CB3S capture that was started) is empty, or when the bridge did not switch
-its AP to WPA2/WPA3 mixed after each AP start."""
-
-from itertools import pairwise
-from pathlib import Path
-import re
-import sys
-
-D, b = Path(sys.argv[1]), sys.argv[2]
-RECOVER = int(sys.argv[3]) if len(sys.argv) > 3 else 120
-
-
-def read(suffix: str) -> str | None:
-    f = D / f"{b}-{suffix}.txt"
-    return f.read_text(encoding="utf-8", errors="replace") if f.exists() else None
-
-
-def secs(t: str) -> int:
-    h, m, s = t.split(":")
-    return int(h) * 3600 + int(m) * 60 + int(float(s))
-
-
-marks = [
-    (secs(line.split()[0]), line.split()[3])
-    for line in read("marks").splitlines()
-    if line.strip()
-]
-sl = (read("syslog") or "").splitlines()
-bad = []
-for dev in ("rebk", "recb"):
-    lines = [line for line in sl if re.search(rf"\b{dev}\b", line)]
-    ups = [
-        (secs(line.split()[0]), int(m[1]))
-        for line in lines
-        if (m := re.search(r"up (\d+) s", line))
-    ]
-    if not ups:
-        print(f"== {dev}: no alive lines over syslog")
-        bad.append(f"{dev} silent")
-        continue
-    reboots = sum(1 for (_, u0), (_, u1) in pairwise(ups) if u1 < u0)
-    gaps = [t1 - t0 for (t0, _), (t1, _) in pairwise(ups) if t1 - t0 > 25]
-    print(
-        f"== {dev}: alive lines {len(ups)}, reboots {reboots}, syslog gaps over 25 s: {gaps}"
-    )
-    if reboots:
-        bad.append(f"{dev} rebooted")
-    for t, st in marks:
-        if st != "on":
-            continue
-        after = [x for x in ups if x[0] > t]
-        first = after[0][0] - t if after else None
-        print(
-            f"   ap back at t={t % 86400 // 3600:02d}:{t % 3600 // 60:02d}:{t % 60:02d}, first syslog line {first} s later"
-        )
-        if first is None or first > RECOVER:
-            bad.append(f"{dev} not back {RECOVER} s after an AP start")
-for dev, suffix in (("rebk", "bk"), ("recb", "cb")):
-    if (s := read(suffix)) is None and dev == "recb":
-        continue  # the CB3S capture is optional
-    if not s:
-        bad.append(f"{dev} serial capture missing or empty")
-        continue
-    crashes = len(re.findall(r"(?i)hard fault|exception|abort|watchdog", s))
-    connected = len(re.findall(r"\[wifi:\d+\]: Connected", s))
-    print(
-        f"-- {dev} serial: lines {s.count(chr(10))}, overflow {s.count('queue overflow')}, fallback AP starts "
-        f"{s.count('Starting fallback AP')}, connected {connected}, boots {s.count('ESPHome version')}, crashes {crashes}"
-    )
-    if crashes:
-        bad.append(f"{dev} crashed")
-up = read("up") or ""
-switches = [
-    secs(m[1]) for m in re.finditer(r"\[(\d+:\d+:\d+)[.\d]*\].*PMF capable: 0", up)
-]
-# each AP start needs its own switch between that mark (less a few seconds of clock skew) and the next mark
-ends = [t for t, _ in marks[1:]] + [float("inf")]
-missed = [
-    t
-    for (t, st), end in zip(marks, ends, strict=True)
-    if st == "on" and not any(t - 5 <= s < end for s in switches)
-]
-starts = sum(1 for _, st in marks if st == "on")
-print(
-    f"-- bridge: WPA2/WPA3 switches {len(switches)}, AP starts {starts} ({len(missed)} without a switch), "
-    f"failures {up.count('AP CONFIG FAILED')}"
-)
-if "AP CONFIG FAILED" in up or missed:
-    bad.append("the bridge did not switch its AP to WPA2/WPA3 mixed after every start")
-print("PASS" if not bad else "FAIL: " + ", ".join(bad))
-sys.exit(1 if bad else 0)

.agents/skills/hardware-test/scripts/wifi_restart/re-common.yaml

@@ -1,58 +0,0 @@
-esphome:
-  name: ${name}
-
-logger:
-  level: DEBUG
-
-wifi:
-  networks:
-    - ssid: !secret wisp_up_ssid
-      password: !secret wisp_up_password
-      manual_ip:
-        static_ip: ${ip}
-        gateway: 10.40.0.1
-        subnet: 255.255.255.0
-        dns1: 10.40.0.1
-  power_save_mode: LIGHT
-  ap:
-    ssid: ${name}-fallback
-    password: !secret fallback_ap_password
-
-captive_portal:
-
-web_server:
-  port: 80
-
-api:
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-udp:
-  addresses:
-    - !secret syslog_ip
-time:
-  - platform: sntp
-syslog:
-  port: 5514
-
-interval:
-  - interval: 10s
-    then:
-      - lambda: ESP_LOGI("alive", "up %u s", (unsigned) (millis() / 1000));
-  - interval: 30s
-    then:
-      - if:
-          condition:
-            lambda: |-
-              static bool done = false;
-              if (done || millis() < 19 * 60 * 1000) return false;
-              done = true;
-              return true;
-          then:
-            - lambda: ESP_LOGI("alive", "GOING HOME");
-            - wifi.configure:
-                ssid: !secret wifi_ssid
-                password: !secret wifi_password
-                save: false

.agents/skills/hardware-test/scripts/wifi_restart/rebk.yaml

@@ -1,13 +0,0 @@
-# BK7238 DUT (NiceMCU XH-WB3S), flashed over serial by run.sh
-substitutions:
-  name: rebk
-  ip: 10.40.0.21
-
-packages:
-  common: !include re-common.yaml
-
-bk72xx:
-  board: xh-wb3s
-
-logger:
-  hardware_uart: UART1

.agents/skills/hardware-test/scripts/wifi_restart/recb.yaml

@@ -1,13 +0,0 @@
-# CB3S (BK7231N) DUT, flashed over the air by run.sh; its log port is UART1 (TX1)
-substitutions:
-  name: recb
-  ip: 10.40.0.22
-
-packages:
-  common: !include re-common.yaml
-
-bk72xx:
-  board: cb3s
-
-logger:
-  hardware_uart: UART1

.agents/skills/hardware-test/scripts/wifi_restart/run.sh

@@ -1,57 +0,0 @@
-#!/bin/bash
-# usage: run.sh BUILD   OTA the CB3S, serial flash the BK7238, then switch the upstream AP off and on three times
-# while both DUTs send alive lines over syslog. BUILD is a label (pr, base) for the output files.
-# Copy this directory into a scratch directory with a secrets.yaml (wifi_ssid, wifi_password, wisp_up_ssid,
-# wisp_up_password, fallback_ap_password, syslog_ip, api_key) and run it there. wisp-upstream-wpa3.yaml runs on the
-# ethernet ESP32-S3 upstream; syslog_ip is this host's address as the DUTs reach it through the bridge's NAT.
-# env: TREE (esphome checkout for the DUTs), BK_PORT (BK7238 serial), CB_PORT (CB3S log only serial, optional),
-# CB_HOST (CB3S address to OTA), UPSTREAM (bridge address), SC (path to serial_capture.py), FLASH_BK (path to
-# flash_bk72xx.py), LT (LibreTiny penv python), PY (checkout python), UP_TREE (checkout for the bridge's API logs)
-D=$(cd "$(dirname "$0")" && pwd); b=${1:?build label}; T=${TREE:?set TREE}; PY=${PY:-$T/venv/bin/python}
-BK=${BK_PORT:?set BK_PORT}; CBH=${CB_HOST:?set CB_HOST}; UP=${UPSTREAM:?set UPSTREAM}; SC=${SC:?set SC}
-FB=${FLASH_BK:?set FLASH_BK}; LT=${LT:-$HOME/.platformio/penv/.libretiny/bin/python}; CB=${CB_PORT:-}
-ap() { curl -s -m 5 -X POST -d "" -o /dev/null -w "%{http_code}" "http://$UP/button/ap%20$1/press"; }
-# retry N PAUSE CMD...: run CMD up to N times, PAUSE seconds apart; fails when every attempt failed
-retry() { local n=$1 pause=$2 i; shift 2; for i in $(seq "$n"); do "$@" && return 0; [ "$i" -lt "$n" ] && sleep "$pause"; done; return 1; }
-build() { (cd "$T" && PYTHONUNBUFFERED=1 timeout 1500 $PY -m esphome "$@"); }
-# only this run's ports: a global pkill stops other runs' captures
-pkill -f "[s]erial_capture.py $BK"; [ -n "$CB" ] && pkill -f "[s]erial_capture.py $CB"
-[ "$(ap on)" = 200 ] || { echo "FAIL: upstream bridge did not take ap on"; exit 1; }
-cb_upload() { build run --no-logs "$D/recb.yaml" --device "$CBH" > "$D/cb-$b-upload.log" 2>&1; }
-retry 3 15 cb_upload || { echo "FAIL: CB3S build or OTA after 3 tries"; exit 1; }
-build compile "$D/rebk.yaml" > "$D/bk-$b-build.log" 2>&1 || { echo "FAIL: BK7238 build"; exit 1; }
-UF2=$D/.esphome/build/rebk/.pioenvs/rebk/firmware.uf2
-bk_flash() { $LT "$FB" flash write -d "$BK" "$UF2" > "$D/bk-$b-flash.log" 2>&1; }
-retry 4 5 bk_flash || { echo "FAIL: BK7238 flash after 4 tries"; exit 1; }
-PIDS=()
-$PY - > "$D/$b-syslog.txt" 2>&1 << 'PYEOF' &
-import socket
-import time
-
-s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-s.bind(("0.0.0.0", 5514))
-s.settimeout(1)
-end = time.time() + 1250
-while time.time() < end:
-    try:
-        d, a = s.recvfrom(2048)
-        print(time.strftime("%H:%M:%S"), a[0], d.decode(errors="replace").strip(), flush=True)
-    except TimeoutError:
-        pass
-PYEOF
-PIDS+=($!)
-$PY "$SC" "$BK" 1240 "$D/$b-bk.txt" --released > /dev/null 2>&1 & PIDS+=($!)
-# an empty file marks the CB3S capture as requested, so an.py fails it if the capture never writes anything
-[ -n "$CB" ] && { : > "$D/$b-cb.txt"; $PY "$SC" "$CB" 1240 "$D/$b-cb.txt" --released > /dev/null 2>&1 & PIDS+=($!); }
-(cd "${UP_TREE:-$T}" && PYTHONUNBUFFERED=1 exec timeout 1240 $PY -m esphome logs "$D/wisp-upstream-wpa3.yaml" --device "$UP" > "$D/$b-up.txt" 2>&1) & PIDS+=($!)
-trap 'kill "${PIDS[@]}" 2>/dev/null' EXIT
-t0=$(date +%s); : > "$D/$b-marks.txt"
-for step in 180:off 330:on 480:off 630:on 780:off 930:on; do
-  t=${step%%:*}; st=${step#*:}
-  while [ $(($(date +%s) - t0)) -lt "$t" ]; do sleep 1; done
-  code=$(ap "$st")
-  echo "$(date +%H:%M:%S) t=$t ap $st $code" | tee -a "$D/$b-marks.txt"
-  [ "$code" = 200 ] || { echo "FAIL: upstream bridge returned $code for ap $st"; exit 1; }
-done
-wait "${PIDS[@]}"; trap - EXIT
-$PY "$D/an.py" "$D" "$b"

.agents/skills/hardware-test/scripts/wifi_restart/wdap_inc.h

@@ -1,3 +0,0 @@
-#pragma once
-#include <esp_wifi.h>
-#include <esp_event.h>

.agents/skills/hardware-test/scripts/wifi_restart/wisp-upstream-wpa3.yaml

@@ -1,95 +0,0 @@
-esphome:
-  name: wisp-upstream
-  includes:
-    - wdap_inc.h
-  on_boot:
-    priority: -100
-    then:
-      - delay: 3s
-      - script.execute: wpa3_ap
-
-esp32:
-  board: esp32-s3-devkitc-1
-  variant: esp32s3
-  flash_size: 16MB
-  framework:
-    type: esp-idf
-
-logger:
-  hardware_uart: USB_SERIAL_JTAG
-
-ethernet:
-  type: W5500
-  clk_pin: GPIO13
-  mosi_pin: GPIO11
-  miso_pin: GPIO12
-  cs_pin: GPIO14
-  interrupt_pin: GPIO10
-  reset_pin: GPIO9
-
-wifi:
-  ap:
-    ssid: !secret wisp_up_ssid
-    password: !secret wisp_up_password
-    ap_mode: WISP
-    manual_ip:
-      static_ip: 10.40.0.1
-      gateway: 10.40.0.1
-      subnet: 255.255.255.0
-
-api:
-  encryption:
-    key: !secret api_key
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-web_server:
-  port: 80
-
-button:
-  - platform: template
-    name: ap off
-    on_press:
-      - wifi.disable:
-  - platform: template
-    name: ap on
-    on_press:
-      - wifi.enable:
-      - delay: 3s
-      - script.execute: wpa3_ap
-
-script:
-  - id: wpa3_ap
-    then:
-      - lambda: |-
-          static bool registered = false;
-          wifi_config_t c{};
-          esp_err_t err = esp_wifi_get_config(WIFI_IF_AP, &c);
-          if (err == ESP_OK) {
-            c.ap.authmode = WIFI_AUTH_WPA2_WPA3_PSK;
-            c.ap.pmf_cfg.required = false;
-            c.ap.sae_pwe_h2e = WPA3_SAE_PWE_BOTH;
-            err = esp_wifi_set_config(WIFI_IF_AP, &c);
-          }
-          // read back: only a running AP that reports WPA2/WPA3 mixed counts as switched
-          wifi_config_t check{};
-          if (err == ESP_OK)
-            err = esp_wifi_get_config(WIFI_IF_AP, &check);
-          if (err != ESP_OK || check.ap.authmode != WIFI_AUTH_WPA2_WPA3_PSK) {
-            ESP_LOGE("wdap", "AP CONFIG FAILED: %d authmode %d", err, (int) check.ap.authmode);
-          } else {
-            ESP_LOGI("wdap", "AP set to WPA2/WPA3 mixed, PMF capable: %d", err);
-          }
-          if (registered) return;
-          registered = true;
-          esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, [](void *, esp_event_base_t, int32_t id, void *data) {
-            if (id == WIFI_EVENT_AP_STACONNECTED) {
-              auto *e = (wifi_event_ap_staconnected_t *) data;
-              ESP_LOGI("wdap", "STA JOIN %02X:%02X:%02X:%02X:%02X:%02X", e->mac[0], e->mac[1], e->mac[2], e->mac[3], e->mac[4], e->mac[5]);
-            } else if (id == WIFI_EVENT_AP_STADISCONNECTED) {
-              auto *e = (wifi_event_ap_stadisconnected_t *) data;
-              ESP_LOGI("wdap", "STA LEAVE %02X:%02X:%02X:%02X:%02X:%02X reason %u", e->mac[0], e->mac[1], e->mac[2], e->mac[3], e->mac[4], e->mac[5], e->reason);
-            }
-          }, nullptr);

.agents/skills/hardware-test/scripts/wisp_ap/dut-always-on.yaml

@@ -1,16 +0,0 @@
-substitutions:
-  name: wispdut-aoi
-  framework: esp-idf
-packages:
-  common: !include dut-common.yaml
-wifi:
-  networks:
-    - ssid: !secret wisp_up_ssid
-      password: !secret wisp_up_password
-  post_connect_roaming: false
-  ap:
-    ssid: !secret dut_ap_ssid
-    password: !secret dut_ap_password
-    ap_mode: ALWAYS_ON
-web_server:
-  port: 80

.agents/skills/hardware-test/scripts/wisp_ap/dut-common.yaml

@@ -1,16 +0,0 @@
-esphome:
-  name: ${name}
-
-esp32:
-  board: esp32dev
-  framework:
-    type: ${framework}
-
-logger:
-  level: DEBUG
-
-api:
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome

.agents/skills/hardware-test/scripts/wisp_ap/dut-wisp.yaml

@@ -1,14 +0,0 @@
-substitutions:
-  name: wispdut-wisp
-  framework: esp-idf
-packages:
-  common: !include dut-common.yaml
-wifi:
-  networks:
-    - ssid: !secret wisp_up_ssid
-      password: !secret wisp_up_password
-  ap:
-    ssid: !secret dut_ap_ssid
-    password: !secret dut_ap_password
-    ap_mode: WISP
-captive_portal:

.agents/skills/hardware-test/scripts/wisp_ap/run.sh

@@ -1,36 +0,0 @@
-#!/bin/bash
-# usage: run.sh DUT START SECONDS T:STATE...   e.g. run.sh dut-wisp on 600 120:off 300:on
-# Builds and flashes DUT.yaml (dut-wisp or dut-always-on) over serial, sets the upstream AP to START, captures the
-# DUT and the client, and switches the upstream AP at each T seconds; sum.py summarises the client per phase.
-# Copy this directory into a scratch directory with a secrets.yaml (wisp_up_ssid, wisp_up_password, dut_ap_ssid,
-# dut_ap_password, lan_probe_url, api_key) and run it there. wisp-upstream.yaml runs on an ethernet ESP32-S3 and
-# wispcli.yaml on a D1 mini; flash both once (CLI_FLASH=1 builds and flashes the client too).
-# env: TREE (esphome checkout for the DUT), PORT (DUT serial), CLI_PORT (client serial), UPSTREAM (upstream bridge
-# address), SC (path to serial_capture.py), PY (checkout python)
-D=$(cd "$(dirname "$0")" && pwd); n=${1:?dut yaml name}; start=${2:?on or off}; dur=${3:?seconds}; shift 3
-T=${TREE:?set TREE}; P=${PORT:?set PORT}; CP=${CLI_PORT:?set CLI_PORT}; UP=${UPSTREAM:?set UPSTREAM}
-SC=${SC:?set SC}; PY=${PY:-$T/venv/bin/python}
-ap() { curl -s -m 5 -X POST -d "" -o /dev/null -w "%{http_code}" "http://$UP/button/ap%20$1/press"; }
-pkill -f "[s]erial_capture.py ($P|$CP)"
-[ "$(ap "$start")" = 200 ] || { echo "FAIL: upstream bridge did not take ap $start"; exit 1; }
-if [ "${CLI_FLASH:-0}" = 1 ]; then
-  (cd "$T" && PYTHONUNBUFFERED=1 timeout 1500 $PY -m esphome run --no-logs "$D/wispcli.yaml" --device "$CP" > "$D/wispcli-upload.log" 2>&1) \
-    || { echo "FAIL: client build or upload"; exit 1; }
-fi
-(cd "$T" && PYTHONUNBUFFERED=1 timeout 1500 $PY -m esphome run --no-logs "$D/$n.yaml" --device "$P" > "$D/$n-upload.log" 2>&1) \
-  || { echo "FAIL: DUT build or upload"; exit 1; }
-echo "$(date +%H:%M:%S) t=0 upstream $start start" > "$D/$n-marks.txt"  # phase 1 is the start state
-$PY "$SC" "$P" "$dur" "$D/$n-dut.txt" --reset > /dev/null 2>&1 & C1=$!
-# no --reset on the client: a CH340 D1 mini floods garbage after an RTS reset
-$PY "$SC" "$CP" "$dur" "$D/$n-cli.txt" > /dev/null 2>&1 & C2=$!
-trap 'kill $C1 $C2 2>/dev/null' EXIT
-t0=$(date +%s)
-for step in "$@"; do
-  t=${step%%:*}; st=${step#*:}
-  while [ $(($(date +%s) - t0)) -lt "$t" ]; do sleep 1; done
-  code=$(ap "$st")
-  echo "$(date +%H:%M:%S) t=$t upstream $st $code" | tee -a "$D/$n-marks.txt"
-  [ "$code" = 200 ] || { echo "FAIL: upstream bridge returned $code for ap $st"; exit 1; }
-done
-wait $C1 $C2; trap - EXIT
-$PY "$D/sum.py" "$D" "$n"

.agents/skills/hardware-test/scripts/wisp_ap/sum.py

@@ -1,80 +0,0 @@
-"""Summarise the client's results per upstream phase and the DUT's connects, AP starts, crashes and boots.
-Usage: sum.py DIR NAME   reads NAME-marks.txt, NAME-cli.txt and NAME-dut.txt
-Phase N runs from mark N (the first mark is the start state). Exits 1 when the DUT crashed, the DUT capture does not
-hold exactly one boot (empty or rebooted), the client had no successful result at all, or a phase with the upstream
-on had no successful name lookup (an answer equal to the gateway is the captive portal and does not count)."""
-
-from collections import defaultdict
-from pathlib import Path
-import re
-import sys
-
-D, n = Path(sys.argv[1]), sys.argv[2]
-
-
-def read(suffix: str) -> str:
-    return (D / f"{n}-{suffix}.txt").read_text(encoding="utf-8", errors="replace")
-
-
-mark_lines = [line.split() for line in read("marks").splitlines() if line.strip()]
-marks = [m[0] for m in mark_lines]
-upstream = {
-    i + 1: m[3] for i, m in enumerate(mark_lines)
-}  # "HH:MM:SS t=N upstream on|off CODE"
-cli = [line for line in read("cli").splitlines() if "[cli" in line]
-
-
-def phase(t: str) -> int:
-    return sum(1 for m in marks if t >= m)
-
-
-stat: dict[int, dict[str, int]] = defaultdict(lambda: defaultdict(int))
-good: dict[int, int] = defaultdict(int)  # successful name lookups per phase
-any_ok = 0
-for line in cli:
-    m = re.search(r"\]: (NOT CONNECTED|NET .*|NAME \S+|GW \S+|MAC \S+)", line)
-    if not m:
-        continue
-    s = m.group(1)
-    if s.startswith("NET"):
-        dns = re.search(r"dns (\S+)", s).group(1)
-        gw = re.search(r"gw (\S+)", s).group(1)
-        res = s.split("-> ")[1].strip()
-        # the captive portal answers every name with the AP's own address; that is not a working upstream
-        s = f"dns={dns} resolve={'CAPTIVE' if res == gw else res}"
-        if res not in ("FAIL", gw):
-            good[phase(line[1:9])] += 1
-            any_ok += 1
-    elif re.match(r"(NAME|GW|MAC) 200\b", s):
-        any_ok += 1
-    stat[phase(line[1:9])][s] += 1
-for p in sorted(stat):
-    print(f"phase {p} (upstream {upstream.get(p, '?')}):", dict(stat[p]))
-dead = [p for p, st in upstream.items() if st == "on" and not good[p]]
-dut = read("dut")
-crash = len(re.findall(r"Guru|panic|abort\(", dut))
-boots = dut.count("ESPHome version")
-print(
-    "DUT connected:",
-    len(re.findall(r"\[wifi:\d+\]: Connected", dut)),
-    "AP starts:",
-    dut.count("Starting AP"),
-    "crash:",
-    crash,
-    "boots:",
-    boots,
-)
-failed = []
-if not cli:
-    failed.append("empty client log")
-elif not any_ok:
-    failed.append("the client never got a successful result")
-if dead:
-    failed.append(f"no successful lookup in upstream on phases {dead}")
-# run.sh resets the DUT when the capture starts, so a good capture holds exactly one boot
-if boots != 1:
-    failed.append(f"{boots} DUT boots captured, expected 1")
-if crash:
-    failed.append(f"{crash} DUT crash lines")
-print("PASS" if not failed else "FAIL: " + "; ".join(failed))
-sys.exit(1 if failed else 0)

.agents/skills/hardware-test/scripts/wisp_ap/wisp-upstream.yaml

@@ -1,52 +0,0 @@
-esphome:
-  name: wisp-upstream
-
-esp32:
-  board: esp32-s3-devkitc-1
-  variant: esp32s3
-  flash_size: 16MB
-  framework:
-    type: esp-idf
-
-logger:
-  hardware_uart: USB_SERIAL_JTAG
-
-ethernet:
-  type: W5500
-  clk_pin: GPIO13
-  mosi_pin: GPIO11
-  miso_pin: GPIO12
-  cs_pin: GPIO14
-  interrupt_pin: GPIO10
-  reset_pin: GPIO9
-
-wifi:
-  ap:
-    ssid: !secret wisp_up_ssid
-    password: !secret wisp_up_password
-    ap_mode: WISP
-    manual_ip:
-      static_ip: 10.40.0.1
-      gateway: 10.40.0.1
-      subnet: 255.255.255.0
-
-api:
-  encryption:
-    key: !secret api_key
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-web_server:
-  port: 80
-
-button:
-  - platform: template
-    name: ap off
-    on_press:
-      - wifi.disable:
-  - platform: template
-    name: ap on
-    on_press:
-      - wifi.enable:

.agents/skills/hardware-test/scripts/wisp_ap/wispcli.yaml

@@ -1,77 +0,0 @@
-esphome:
-  name: wispcli
-
-esp8266:
-  board: d1_mini
-
-logger:
-  level: DEBUG
-
-wifi:
-  networks:
-    - ssid: !secret dut_ap_ssid
-      password: !secret dut_ap_password
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-http_request:
-  timeout: 5s
-  verify_ssl: false
-
-globals:
-  - id: tick
-    type: int
-    initial_value: "0"
-
-interval:
-  - interval: 3s
-    then:
-      - lambda: |-
-          id(tick)++;
-          if (id(tick) % 4 != 1) return;
-          if (!WiFi.isConnected()) { ESP_LOGI("cli", "NOT CONNECTED"); return; }
-          IPAddress r;
-          bool ok = WiFi.hostByName("neverssl.com", r, 3000);
-          ESP_LOGI("cli", "NET ip %s gw %s dns %s | neverssl.com -> %s", WiFi.localIP().toString().c_str(),
-                   WiFi.gatewayIP().toString().c_str(), WiFi.dnsIP(0).toString().c_str(),
-                   ok ? r.toString().c_str() : "FAIL");
-      - if:
-          condition:
-            lambda: return id(tick) % 4 == 2 && WiFi.isConnected();
-          then:
-            - http_request.get:
-                url: http://neverssl.com/
-                capture_response: true
-                max_response_buffer_size: 160
-                collect_headers:
-                  - location
-                on_response:
-                  - lambda: ESP_LOGI("cli", "NAME %d loc=%s body=%.60s", response->status_code, response->get_response_header("location").c_str(), body.c_str());
-                on_error:
-                  - lambda: ESP_LOGI("cli", "NAME error");
-      - if:
-          condition:
-            lambda: return id(tick) % 4 == 3 && WiFi.isConnected();
-          then:
-            - http_request.get:
-                url: !lambda 'return std::string("http://") + WiFi.gatewayIP().toString().c_str() + "/";'
-                capture_response: true
-                max_response_buffer_size: 160
-                on_response:
-                  - lambda: ESP_LOGI("cli", "GW %d body=%.60s", response->status_code, body.c_str());
-                on_error:
-                  - lambda: ESP_LOGI("cli", "GW error");
-      - if:
-          condition:
-            lambda: return id(tick) % 4 == 0 && WiFi.isConnected();
-          then:
-            - http_request.get:
-                url: !secret lan_probe_url
-                capture_response: true
-                max_response_buffer_size: 64
-                on_response:
-                  - lambda: ESP_LOGI("cli", "MAC %d body=%.20s", response->status_code, body.c_str());
-                on_error:
-                  - lambda: ESP_LOGI("cli", "MAC error");

.agents/skills/hardware-test/scripts/wpa3_ap/an.py

@@ -1,56 +0,0 @@
-"""Summarise the PMF AP's join and leave events per station and the BK7238's joins.
-Usage: an.py DIR BUILD [AP_SSID]   reads DIR/ap-BUILD.txt and DIR/bk-BUILD.txt (AP_SSID defaults to wd-pmf-ap)
-J = join, L<n> = leave with reason n. Reason 3: the station sent a deauth. Reason 2: the AP found a stale
-association when the station came back; a run of reason 2 before one join is reconnects the AP rejected.
-env DUT_MACS: comma separated station MACs that must appear in the AP events (default: at least two stations).
-Exits 1 on a rejected reconnect, an AP that did not switch to WPA2/WPA3, a missing DUT, or a BK7238 that never
-joined the AP."""
-
-from itertools import pairwise
-import os
-from pathlib import Path
-import re
-import sys
-
-D, b = Path(sys.argv[1]), sys.argv[2]
-AP_SSID = sys.argv[3] if len(sys.argv) > 3 else "wd-pmf-ap"
-failed = []
-ap = (D / f"ap-{b}.txt").read_text(encoding="utf-8", errors="replace").splitlines()
-if not any("PMF capable: 0" in line for line in ap) or any(
-    "AP CONFIG FAILED" in line for line in ap
-):
-    failed.append("the AP did not switch to WPA2/WPA3 mixed")
-ev = [line for line in ap if "STA JOIN" in line or "STA LEAVE" in line]
-mac_re = re.compile(r"([0-9A-F]{2}(?::[0-9A-F]{2}){5})")
-macs = sorted({m.group(1) for line in ev if (m := mac_re.search(line))})
-rejected = 0
-print(f"== {b}")
-for m in macs:
-    seq = [
-        "J" if "JOIN" in line else "L" + re.search(r"reason (\d+)", line).group(1)
-        for line in ev
-        if m in line
-    ]
-    # every L2 after the first in a run without a join in between is a rejected reconnect
-    rej = sum(1 for prev, cur in pairwise(seq) if prev == cur == "L2")
-    rejected += rej
-    print(" ", m, " ".join(seq), f"(rejected {rej})")
-if rejected:
-    failed.append(f"{rejected} rejected reconnects")
-if want := [
-    x.strip().upper() for x in os.environ.get("DUT_MACS", "").split(",") if x.strip()
-]:
-    if missing := [x for x in want if x not in macs]:
-        failed.append(f"no AP events for {', '.join(missing)}")
-elif len(macs) < 2:
-    failed.append(f"AP events for {len(macs)} stations, expected both DUTs")
-bk = (D / f"bk-{b}.txt").read_text(encoding="utf-8", errors="replace").splitlines()
-joins = [
-    m.groups() for line in bk if (m := re.search(r"JOINED (.+?) after (\d+) ms", line))
-]
-print("  bk7238 joins:", " ".join(f"{s}@{int(t) / 1000:.1f}s" for s, t in joins))
-print("  bk7238 reboots:", sum("REBOOT on" in line for line in bk))
-if not any(s == AP_SSID for s, _ in joins):
-    failed.append(f"the BK7238 never joined {AP_SSID}")
-print("PASS" if not failed else "FAIL: " + "; ".join(failed))
-sys.exit(1 if failed else 0)

.agents/skills/hardware-test/scripts/wpa3_ap/run.sh

@@ -1,32 +0,0 @@
-#!/bin/bash
-# usage: run.sh BUILD   flash the PMF AP, OTA the CB3S, serial flash the BK7238, then capture one AP window
-# Copy this directory into a scratch directory with a secrets.yaml (wifi_ssid, wifi_password, wd_ap_password) and
-# run it there. BUILD is a label (pr, base) for the output files.
-# env: TREE (esphome checkout for the DUTs), AP_PORT (classic devkit running wdap.yaml), BK_PORT (BK7238 serial),
-# CB_HOST (CB3S address on the house network), SC (path to serial_capture.py), FLASH_BK (path to flash_bk72xx.py),
-# LT (LibreTiny penv python, default ~/.platformio/penv/.libretiny/bin/python), PY (checkout python), DUT_MACS
-# (optional, comma separated station MACs of both DUTs for an.py)
-D=$(cd "$(dirname "$0")" && pwd); b=${1:?build label}; T=${TREE:?set TREE}; PY=${PY:-$T/venv/bin/python}
-AP=${AP_PORT:?set AP_PORT}; BK=${BK_PORT:?set BK_PORT}; CB=${CB_HOST:?set CB_HOST}; SC=${SC:?set SC}
-FB=${FLASH_BK:?set FLASH_BK}; LT=${LT:-$HOME/.platformio/penv/.libretiny/bin/python}
-pkill -f "[s]erial_capture.py ($AP|$BK)"
-# retry N PAUSE CMD...: run CMD up to N times, PAUSE seconds apart; fails when every attempt failed
-retry() { local n=$1 pause=$2 i; shift 2; for i in $(seq "$n"); do "$@" && return 0; [ "$i" -lt "$n" ] && sleep "$pause"; done; return 1; }
-build() { (cd "$T" && PYTHONUNBUFFERED=1 timeout 1500 $PY -m esphome "$@"); }
-build run --no-logs "$D/wdap.yaml" --device "$AP" > "$D/ap-$b-upload.log" 2>&1 || { echo "FAIL: AP build or upload"; exit 1; }
-# The DUT reboots 150 s after joining the house network; retry when it reboots mid-upload.
-cb_upload() { build run --no-logs "$D/wdcb.yaml" --device "$CB" > "$D/cb-$b-upload.log" 2>&1; }
-retry 3 20 cb_upload || { echo "FAIL: CB3S build or OTA after 3 tries"; exit 1; }
-build compile "$D/wdbk.yaml" > "$D/bk-$b-build.log" 2>&1 || { echo "FAIL: BK7238 build"; exit 1; }
-# The build directory has two .uf2 files; firmware.uf2 is the one to flash.
-UF2=$D/.esphome/build/wdbk/.pioenvs/wdbk/firmware.uf2
-bk_flash() { $LT "$FB" flash write -d "$BK" "$UF2" > "$D/bk-$b-flash.log" 2>&1; }
-retry 4 5 bk_flash || { echo "FAIL: BK7238 flash after 4 tries"; exit 1; }
-sleep 20
-# The reset restarts the AP's 420 s window.
-$PY "$SC" "$AP" 450 "$D/ap-$b.txt" --reset > /dev/null 2>&1 & C1=$!
-sleep 8
-$PY "$SC" "$BK" 440 "$D/bk-$b.txt" --released > /dev/null 2>&1 & C2=$!
-trap 'kill $C1 $C2 2>/dev/null' EXIT
-wait $C1 $C2; trap - EXIT
-$PY "$D/an.py" "$D" "$b"

.agents/skills/hardware-test/scripts/wpa3_ap/wd-common.yaml

@@ -1,44 +0,0 @@
-esphome:
-  name: ${name}
-
-logger:
-  level: DEBUG
-
-globals:
-  - id: connect_ms
-    type: uint32_t
-    initial_value: "0"
-
-wifi:
-  networks:
-    - ssid: ${ap_ssid}
-      password: !secret wd_ap_password
-      priority: 10
-    - ssid: !secret wifi_ssid
-      password: !secret wifi_password
-      priority: 0
-  on_connect:
-    - lambda: |-
-        id(connect_ms) = millis();
-        char buf[wifi::SSID_BUFFER_SIZE];
-        ESP_LOGI("wd", "JOINED %s after %u ms since boot", wifi::global_wifi_component->wifi_ssid_to(buf), (unsigned) millis());
-
-api:
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-interval:
-  - interval: 5s
-    then:
-      - lambda: |-
-          if (!wifi::global_wifi_component->is_connected() || id(connect_ms) == 0)
-            return;
-          char buf[wifi::SSID_BUFFER_SIZE];
-          bool on_ap = strcmp(wifi::global_wifi_component->wifi_ssid_to(buf), "${ap_ssid}") == 0;
-          uint32_t up = millis() - id(connect_ms);
-          if (up > (on_ap ? 30000u : 150000u)) {
-            ESP_LOGI("wd", "REBOOT on %s", on_ap ? "ap" : "home");
-            App.safe_reboot();
-          }

.agents/skills/hardware-test/scripts/wpa3_ap/wdap.yaml

@@ -1,59 +0,0 @@
-substitutions:
-  ap_ssid: wd-pmf-ap
-
-esphome:
-  name: wdap
-  includes:
-    - wdap_inc.h
-  on_boot:
-    priority: -100
-    then:
-      - delay: 3s
-      - lambda: |-
-          wifi_config_t c{};
-          esp_err_t err = esp_wifi_get_config(WIFI_IF_AP, &c);
-          if (err == ESP_OK) {
-            c.ap.authmode = WIFI_AUTH_WPA2_WPA3_PSK;
-            c.ap.pmf_cfg.required = false;
-            c.ap.sae_pwe_h2e = WPA3_SAE_PWE_BOTH;
-            c.ap.max_connection = 4;
-            err = esp_wifi_set_config(WIFI_IF_AP, &c);
-          }
-          // read back: only a running AP that reports WPA2/WPA3 mixed counts as switched
-          wifi_config_t check{};
-          if (err == ESP_OK)
-            err = esp_wifi_get_config(WIFI_IF_AP, &check);
-          if (err != ESP_OK || check.ap.authmode != WIFI_AUTH_WPA2_WPA3_PSK) {
-            ESP_LOGE("wdap", "AP CONFIG FAILED: %d authmode %d", err, (int) check.ap.authmode);
-          } else {
-            ESP_LOGI("wdap", "AP set to WPA2/WPA3 mixed, PMF capable: %d", err);
-          }
-          esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, [](void *, esp_event_base_t, int32_t id, void *data) {
-            if (id == WIFI_EVENT_AP_STACONNECTED) {
-              auto *e = (wifi_event_ap_staconnected_t *) data;
-              ESP_LOGI("wdap", "STA JOIN %02X:%02X:%02X:%02X:%02X:%02X aid %u t %u", e->mac[0], e->mac[1], e->mac[2], e->mac[3], e->mac[4], e->mac[5], e->aid, (unsigned) millis());
-            } else if (id == WIFI_EVENT_AP_STADISCONNECTED) {
-              auto *e = (wifi_event_ap_stadisconnected_t *) data;
-              ESP_LOGI("wdap", "STA LEAVE %02X:%02X:%02X:%02X:%02X:%02X aid %u reason %u t %u", e->mac[0], e->mac[1], e->mac[2], e->mac[3], e->mac[4], e->mac[5], e->aid, e->reason, (unsigned) millis());
-            }
-          }, nullptr);
-      - delay: 420s
-      - lambda: ESP_LOGI("wdap", "AP WINDOW OVER");
-      - wifi.disable:
-
-esp32:
-  board: esp32dev
-  framework:
-    type: esp-idf
-
-logger:
-  level: DEBUG
-
-wifi:
-  ap:
-    ssid: ${ap_ssid}
-    password: !secret wd_ap_password
-    ap_timeout: 0s
-
-ota:
-  - platform: esphome

.agents/skills/hardware-test/scripts/wpa3_ap/wdap_inc.h

@@ -1,3 +0,0 @@
-#pragma once
-#include <esp_wifi.h>
-#include <esp_event.h>

.agents/skills/hardware-test/scripts/wpa3_ap/wdbk.yaml

@@ -1,13 +0,0 @@
-# BK7238 DUT (NiceMCU XH-WB3S), flashed over serial by run.sh
-substitutions:
-  name: wdbk
-  ap_ssid: wd-pmf-ap
-
-packages:
-  common: !include wd-common.yaml
-
-bk72xx:
-  board: xh-wb3s
-
-logger:
-  hardware_uart: UART1

.agents/skills/hardware-test/scripts/wpa3_ap/wdcb.yaml

@@ -1,13 +0,0 @@
-# CB3S (BK7231N) DUT, flashed over the air by run.sh
-substitutions:
-  name: wdcb
-  ap_ssid: wd-pmf-ap
-
-packages:
-  common: !include wd-common.yaml
-
-bk72xx:
-  board: cb3s
-
-logger:
-  hardware_uart: UART1

.agents/skills/hardware-test/scripts/xiaomi_ble/count.py

@@ -1,76 +0,0 @@
-"""Count the Xiaomi, ATC and PVVX publishes in a capture and compare them with expected.json from gen.py.
-Usage: count.py CAPTURE [pr|base] [--allow-loss N] [--probe]
---probe (injection run): the PR build must leave the probe frame's service data unchanged.
-Exits 0 when every count matches the model (or falls short by at most N over the air), 1 otherwise."""
-
-import argparse
-import collections
-import json
-from pathlib import Path
-import re
-import sys
-
-ap = argparse.ArgumentParser()
-ap.add_argument("capture", type=Path)
-ap.add_argument("build", nargs="?", choices=["pr", "base"])
-ap.add_argument("--allow-loss", type=int, default=0)
-ap.add_argument("--probe", action="store_true")
-a = ap.parse_args()
-cap, build, loss = a.capture, a.build, a.allow_loss
-LETTER = {"0A": "A", "0B": "B", "0C": "C", "0D": "D", "0E": "E", "0F": "F", "10": "G"}
-GOT = re.compile(
-    r"Got (?:Xiaomi \S+|ATC MiThermometer|PVVX MiThermometer) \([AC]4:C1:38:00:00:(\w\w)\)"
-)
-
-counts = collections.Counter()
-cur = None
-humidity = set()
-probe = {}
-for line in cap.read_text(encoding="utf-8", errors="replace").splitlines():
-    if m := GOT.search(line):
-        cur = LETTER[m.group(1)]
-        continue
-    if m := re.search(r"\[probe.*\b(before|after)\s+([0-9A-F]+)", line):
-        probe[m.group(1)] = m.group(2)
-    if "Humidity:" in line:
-        humidity.add(line.split("Humidity:")[1].strip())
-    if (m := re.search(r"Temperature: (-?[\d.]+)", line)) and cur:
-        t = float(m.group(1))
-        tag = cur
-        if (
-            cur == "A" and t >= 50
-        ):  # after-bad frames are 60.1 to 64.0, normal ones 22.1 to 26.0
-            tag = "A_after_bad"
-        if cur == "A" and abs(t - 33.3) < 0.01:
-            tag = "A_probe"  # xb_rewrite_probe's own parse, not part of the model
-        if cur == "D" and abs(t - 11.1) < 0.01:
-            tag = "D_boot"
-        counts[tag] += 1
-        cur = None
-print(cap.name, dict(sorted(counts.items())))
-print("  humidity values", len(humidity))
-if not counts:
-    print("FAIL: no Xiaomi publishes in the capture")
-    sys.exit(1)
-if build is None:
-    sys.exit(0)
-expected = json.loads(Path("expected.json").read_text(encoding="utf-8"))[build]
-bad = 0
-for tag in sorted((set(expected) | set(counts)) - {"A_probe"}):
-    want, got = expected.get(tag, 0), counts.get(tag, 0)
-    ok = want - loss <= got <= want
-    bad += not ok
-    print(f"  {tag:12} want {want:3} got {got:3} {'ok' if ok else 'DIFF'}")
-if a.probe:
-    before, after = probe.get("before"), probe.get("after")
-    print(f"  probe before {before}\n  probe after  {after}")
-    if before is None or after is None:
-        print("  probe lines missing")
-        bad += 1
-    elif build == "pr" and before != after:
-        print("  the listener rewrote the shared service data")
-        bad += 1
-print(
-    f"{'PASS' if not bad else 'FAIL'}: {build} model {'matches' if not bad else f'has {bad} failed checks'}"
-)
-sys.exit(1 if bad else 0)

.agents/skills/hardware-test/scripts/xiaomi_ble/gen.py

@@ -1,256 +0,0 @@
-"""Generate MiBeacon, ATC and PVVX advertisements, a C++ header that sends them and the expected publish counts.
-Usage: gen.py [--ota]
-Without --ota: frames.hpp for xbinject.yaml (scan results injected into the tracker, A4:C1:38 addresses).
-With --ota: adv_frames.hpp for xbadv.yaml (a second ESP32 advertises them, C4:C1:38 random static addresses).
-Both write expected.json ({"base": {...}, "pr": {...}}) for count.py."""
-
-import json
-from pathlib import Path
-import struct
-import sys
-
-from cryptography.hazmat.primitives.ciphers.aead import AESCCM
-
-OTA = "--ota" in sys.argv[1:]
-CYCLES = 40
-K1 = bytes.fromhex("6c0d1a3e5b7f29c4a18e90d2f3b46a57")
-K2 = bytes.fromhex("0f1e2d3c4b5a69788796a5b4c3d2e1f0")
-# Random static addresses need the top two bits set, so the over the air run uses C4 instead of A4.
-PREFIX = "C4C138" if OTA else "A4C138"
-MACS = {
-    k: f"{PREFIX}0000{i + 10:02X}" for i, k in enumerate("ABCDEFG")
-}  # ...0A to ...10
-MAC = {k: bytes.fromhex(v) for k, v in MACS.items()}
-MIDX = {k: i for i, k in enumerate(MACS)}
-
-
-def mibeacon_plain(dev, pid, cnt, obj):
-    return (
-        bytes([0x50, 0x20])
-        + struct.pack("<H", pid)
-        + bytes([cnt])
-        + MAC[dev][::-1]
-        + obj
-    )
-
-
-def mibeacon_enc(dev, pid, cnt, obj, key, short, corrupt=False):
-    ext = bytes([cnt, 0x00, 0x00])
-    if short:
-        hdr = bytes([0x48, 0x59]) + struct.pack("<H", pid) + bytes([cnt])
-    else:
-        hdr = (
-            bytes([0x58, 0x58]) + struct.pack("<H", pid) + bytes([cnt]) + MAC[dev][::-1]
-        )
-    nonce = MAC[dev][::-1] + hdr[2:5] + ext
-    ct = AESCCM(key, tag_length=4).encrypt(nonce, obj, b"\x11")
-    body, tag = ct[:-4], ct[-4:]
-    if corrupt:
-        tag = bytes([tag[0] ^ 0xFF]) + tag[1:]
-    out = hdr + body + ext + tag
-    assert len(out) == (19 if short else 18 + len(obj)), len(out)
-    return out
-
-
-def t16(v):  # 0x1004 temperature object
-    return bytes([0x04, 0x10, 0x02]) + struct.pack("<h", round(v * 10))
-
-
-def th(t, h):  # 0x100D temperature + humidity
-    return bytes([0x0D, 0x10, 0x04]) + struct.pack("<hh", round(t * 10), round(h * 10))
-
-
-frames = []  # (dev, kind 0 = FE95 / 1 = 181A, data, tag for the expectation)
-frames.append(("D", 0, mibeacon_plain("D", 0x0347, 0, t16(11.1)), "D_boot"))
-steps = [len(frames)]
-for k in range(1, CYCLES + 1):
-    frames.append(("B", 0, mibeacon_plain("B", 0x01AA, k, th(20 + k / 10, 40)), "B"))
-    frames.append(("C", 0, mibeacon_plain("C", 0x0098, k, t16(21 + k / 10)), "C"))
-    frames.append(
-        ("A", 0, mibeacon_enc("A", 0x055B, k + 100, t16(22 + k / 10), K1, False), "A")
-    )
-    if k % 2 == 0:
-        bad = mibeacon_enc("A", 0x055B, k + 150, t16(60 + k / 10), K1, False, True)
-        frames.append(("A", 0, bad, "A_bad"))
-        good = mibeacon_enc("A", 0x055B, k + 150, t16(60 + k / 10), K1, False)
-        frames.append(("A", 0, good, "A_after_bad"))
-    frames.append(
-        ("E", 0, mibeacon_enc("E", 0x1203, k + 50, th(23 + k / 10, 50), K2, True), "E")
-    )
-    frames.append(("D", 0, mibeacon_plain("D", 0x0347, k + 200, t16(24 + k / 10)), "D"))
-    atc = (
-        MAC["F"]
-        + struct.pack(">h", round((26 + k / 10) * 10))
-        + bytes([45, 90])
-        + struct.pack(">H", 2950)
-    )
-    frames.append(("F", 1, atc + bytes([k]), "F"))
-    pv = (
-        MAC["G"][::-1]
-        + struct.pack("<hHH", round((27 + k / 10) * 100), 4600, 3010)
-        + bytes([88, k, 0])
-    )
-    frames.append(("G", 1, pv, "G"))
-    steps.append(len(frames))
-
-
-def simulate(pr):
-    """Base keeps one counter shared by every device and checks it before the tag; the PR keeps one per device."""
-    last_shared = 0
-    last = {}
-    pub = {}
-    for dev, kind, data, tag in frames:
-        if kind == 1:
-            cnt = data[12 if dev == "F" else 13]
-            if last.get(("x", dev)) == cnt:
-                continue
-            last["x", dev] = cnt
-        elif pr:
-            if last.get(dev) == data[4] or tag == "A_bad":
-                continue
-            last[dev] = data[4]
-        else:
-            if last_shared == data[4]:
-                continue
-            last_shared = data[4]
-            if tag == "A_bad":
-                continue
-        pub[tag] = pub.get(tag, 0) + 1
-    return pub
-
-
-expected = {"base": simulate(False), "pr": simulate(True)}
-print("base", expected["base"])
-print("pr  ", expected["pr"])
-Path("expected.json").write_text(json.dumps(expected), encoding="utf-8")
-
-
-def c_rows(name, rows):
-    out = [f"static const uint8_t {name}[{len(rows)}][{len(rows[0][0])}] = {{"]
-    out += [
-        "  {" + ",".join(f"0x{b:02X}" for b in row) + "}," + (f"  // {c}" if c else "")
-        for row, c in rows
-    ]
-    return "\n".join([*out, "};", ""])
-
-
-mac_rows = [(MAC[k], "") for k in MACS]
-frame_rows = [
-    ((bytes([MIDX[d], kind, len(data)]) + data).ljust(28, b"\0"), tag)
-    for d, kind, data, tag in frames
-]
-
-INJECT = """
-inline void xb_fill(esphome::esp32_ble::BLEScanResult &r, const uint8_t *mac, bool fe95, const uint8_t *data,
-                    uint8_t len) {
-  memcpy(r.bda, mac, 6);
-  r.ble_addr_type = 0;
-  r.rssi = -50;
-  uint8_t n = 0;
-  r.ble_adv[n++] = 2;
-  r.ble_adv[n++] = 0x01;
-  r.ble_adv[n++] = 0x06;
-  r.ble_adv[n++] = len + 3;
-  r.ble_adv[n++] = 0x16;
-  r.ble_adv[n++] = fe95 ? 0x95 : 0x1A;
-  r.ble_adv[n++] = fe95 ? 0xFE : 0x18;
-  memcpy(r.ble_adv + n, data, len);
-  r.adv_data_len = n + len;
-  r.scan_rsp_len = 0;
-  r.search_evt = ESP_GAP_SEARCH_INQ_RES_EVT;
-}
-
-inline void xb_inject(size_t first, size_t last) {
-  for (size_t i = first; i < last; i++) {
-    const uint8_t *row = XB_FRAMES[i];
-    esphome::esp32_ble::BLEScanResult r{};
-    xb_fill(r, XB_MACS[row[0]], row[1] == 0, row + 3, row[2]);
-    esphome::esp32_ble_tracker::global_esp32_ble_tracker->gap_scan_event_handler(r);
-  }
-}
-
-inline void xb_hex(const char *label, const std::vector<uint8_t> &v) {
-  char buf[80];
-  size_t n = 0;
-  for (size_t i = 0; i < v.size() && n + 3 < sizeof(buf); i++)
-    n += snprintf(buf + n, sizeof(buf) - n, "%02X", v[i]);
-  ESP_LOGI("probe", "%s %s", label, buf);
-}
-
-// Parse one encrypted frame with the listener directly and show whether it rewrote the shared service data.
-inline void xb_rewrite_probe(esphome::ble_device_base::ESPBTDeviceListener *listener) {
-  esphome::esp32_ble::BLEScanResult r{};
-  xb_fill(r, XB_MACS[0], true, XB_PROBE, sizeof(XB_PROBE));
-  esphome::ble_device_base::ESPBTDevice device;
-  device.parse_scan_rst(r);
-  xb_hex("before", device.get_service_datas()[0].data);
-  bool ok = listener->parse_device(device);
-  ESP_LOGI("probe", "parse_device returned %d", ok);
-  xb_hex("after ", device.get_service_datas()[0].data);
-}
-"""
-
-ADVERTISE = """
-// Sends where a GAP call returned an error when it was queued. Failures the controller reports later in the GAP
-// completion events are not counted; those frames show up as missing publishes in count.py.
-static uint32_t af_failed = 0;
-
-// Returns false (and counts it) when the address, the data or the start was rejected.
-inline bool af_send(int i) {
-  const uint8_t *row = AF_FRAMES[i];
-  uint8_t adv[31];
-  uint8_t n = 0;
-  adv[n++] = 2;
-  adv[n++] = 0x01;
-  adv[n++] = 0x06;
-  adv[n++] = row[2] + 3;
-  adv[n++] = 0x16;
-  adv[n++] = row[1] == 0 ? 0x95 : 0x1A;
-  adv[n++] = row[1] == 0 ? 0xFE : 0x18;
-  memcpy(adv + n, row + 3, row[2]);
-  n += row[2];
-  esp_ble_gap_stop_advertising();  // fails harmlessly when nothing is advertising yet
-  uint8_t addr[6];
-  memcpy(addr, AF_MACS[row[0]], 6);
-  esp_err_t e1 = esp_ble_gap_set_rand_addr(addr);
-  esp_err_t e2 = esp_ble_gap_config_adv_data_raw(adv, n);
-  esp_ble_adv_params_t p{};
-  p.adv_int_min = 0x20;  // 20 ms
-  p.adv_int_max = 0x20;
-  p.adv_type = ADV_TYPE_NONCONN_IND;
-  p.own_addr_type = BLE_ADDR_TYPE_RANDOM;
-  p.channel_map = ADV_CHNL_ALL;
-  p.adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
-  esp_err_t e3 = esp_ble_gap_start_advertising(&p);
-  if (e1 == ESP_OK && e2 == ESP_OK && e3 == ESP_OK)
-    return true;
-  af_failed++;
-  ESP_LOGW("af", "frame %d send failed: rand_addr %d adv_data %d start %d", i, e1, e2, e3);
-  return false;
-}
-
-inline void af_stop() { esp_ble_gap_stop_advertising(); }
-"""
-
-if OTA:
-    head = '#pragma once\n#include <esp_gap_ble_api.h>\n#include <cstring>\n#include "esphome/core/log.h"\n'
-    body = c_rows("AF_MACS", mac_rows) + c_rows("AF_FRAMES", frame_rows)
-    body += f"static constexpr int AF_COUNT = {len(frames)};\n" + ADVERTISE
-    Path("adv_frames.hpp").write_text(head + body, encoding="utf-8")
-else:
-    head = '#pragma once\n#include <cstring>\n#include "esphome/components/esp32_ble/ble_scan_result.h"\n'
-    probe = mibeacon_enc("A", 0x055B, 0xF5, t16(33.3), K1, False)
-    body = c_rows("XB_MACS", mac_rows) + c_rows("XB_FRAMES", frame_rows)
-    body += (
-        f"static const uint16_t XB_STEPS[{len(steps)}] = {{"
-        + ",".join(map(str, steps))
-        + "};\n"
-    )
-    body += f"static constexpr size_t XB_NUM_STEPS = {len(steps)};\n"
-    body += (
-        "static const uint8_t XB_PROBE[] = {"
-        + ",".join(f"0x{b:02X}" for b in probe)
-        + "};\n"
-    )
-    Path("frames.hpp").write_text(head + body + INJECT, encoding="utf-8")
-print("frames", len(frames), "longest", max(len(d) for _, _, d, _ in frames))

.agents/skills/hardware-test/scripts/xiaomi_ble/run.sh

@@ -1,41 +0,0 @@
-#!/bin/bash
-# usage: run.sh inject|ota pr|base   build and flash the receiver, capture its serial log, compare the counts
-# Copy this directory into a scratch directory with a secrets.yaml (wifi_ssid, wifi_password, api_key) and run it there.
-# inject: xbinject.yaml injects the frames into its own tracker. ota: xbrecv.yaml listens to xbadv.yaml, which must
-# already run on a second ESP32 (python gen.py --ota, then flash xbadv.yaml once).
-# env: TREE (esphome checkout to build from), PORT (receiver serial port), SC (path to serial_capture.py),
-# PY (checkout python), ADV (advertiser address, ota only)
-D=$(cd "$(dirname "$0")" && pwd); MODE=${1:?inject or ota}; B=${2:?pr or base}; T=${TREE:?set TREE}
-P=${PORT:?set PORT}; SC=${SC:?set SC}; PY=${PY:-$T/venv/bin/python}
-cd "$D" || exit 1
-if [ "$MODE" = ota ]; then
-  A=${ADV:?set ADV}; Y=xbrecv; SECS=130; LOSS=2
-  $PY gen.py --ota > gen.txt || { echo "gen.py failed"; exit 1; }
-else
-  Y=xbinject; SECS=80; LOSS=0; PROBE=--probe
-  $PY gen.py > gen.txt || { echo "gen.py failed"; exit 1; }
-fi
-OUT=$D/$MODE-$B; mkdir -p "$OUT"
-pkill -f "[s]erial_capture.py $P"
-(cd "$T" && PYTHONUNBUFFERED=1 timeout 1500 $PY -m esphome run --no-logs "$D/$Y.yaml" --device "$P" > "$OUT/upload.log" 2>&1) \
-  || { echo "FAIL: build or upload failed, see $OUT/upload.log"; exit 1; }
-$PY "$SC" "$P" $SECS "$OUT/cap.txt" --reset > /dev/null 2>&1 & CAP=$!
-trap 'kill $CAP 2>/dev/null' EXIT
-if [ "$MODE" = ota ]; then
-  # 18 s lets the receiver boot and start scanning, so the counter 0 boot frame is the first one it hears
-  sleep 18
-  CODE=$(curl -s -m 5 -X POST -d "" -o /dev/null -w "%{http_code}" "http://$A/button/start/press")
-  [ "$CODE" = 200 ] || { echo "FAIL: advertiser start button returned $CODE"; exit 1; }
-fi
-wait $CAP; trap - EXIT
-[ -s "$OUT/cap.txt" ] || { echo "FAIL: serial capture got nothing"; exit 1; }
-CRASH=$(grep -acE 'Guru|abort\(\)|Backtrace:' "$OUT/cap.txt")
-$PY count.py "$OUT/cap.txt" "$B" --allow-loss $LOSS $PROBE; RC=$?
-if [ "$MODE" = ota ]; then
-  # the advertiser counts frames whose GAP calls failed; those are not radio loss
-  FAILED=$(curl -s -m 5 "http://$A/sensor/failed%20sends" | $PY -c "import json,sys; print(int(json.load(sys.stdin)['value']))")
-  echo "advertiser failed sends: ${FAILED:-unknown}"
-  [ "$FAILED" = 0 ] || RC=1
-fi
-echo "crash lines: $CRASH"
-[ "$RC" = 0 ] && [ "$CRASH" = 0 ]

.agents/skills/hardware-test/scripts/xiaomi_ble/xbadv.yaml

@@ -1,76 +0,0 @@
-esphome:
-  name: xbadv
-  includes:
-    - adv_frames.hpp
-
-esp32:
-  board: esp32-s3-devkitc-1
-  variant: esp32s3
-  flash_size: 16MB
-  framework:
-    type: esp-idf
-
-logger:
-  hardware_uart: USB_SERIAL_JTAG
-
-ethernet:
-  type: W5500
-  clk_pin: GPIO13
-  mosi_pin: GPIO11
-  miso_pin: GPIO12
-  cs_pin: GPIO14
-  interrupt_pin: GPIO10
-  reset_pin: GPIO9
-
-api:
-  encryption:
-    key: !secret api_key
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-web_server:
-  port: 80
-
-esp32_ble:
-
-globals:
-  - id: af_idx
-    type: int
-    initial_value: "-1"
-
-button:
-  - platform: template
-    name: start
-    on_press:
-      - lambda: |-
-          id(af_idx) = 0;
-          af_failed = 0;
-          // an unfinished sequence reads as unknown, not as the 0 from an earlier run
-          id(failed_sends).publish_state(NAN);
-          ESP_LOGI("af", "sequence start");
-
-interval:
-  - interval: 250ms
-    then:
-      - lambda: |-
-          int i = id(af_idx);
-          if (i < 0)
-            return;
-          if (i >= AF_COUNT) {
-            af_stop();
-            id(af_idx) = -1;
-            ESP_LOGI("af", "sequence done, %u failed sends", (unsigned) af_failed);
-            id(failed_sends).publish_state(af_failed);
-            return;
-          }
-          af_send(i);
-          id(af_idx) = i + 1;
-
-sensor:
-  - platform: template
-    id: failed_sends
-    name: failed sends
-    accuracy_decimals: 0
-    update_interval: never

.agents/skills/hardware-test/scripts/xiaomi_ble/xbinject.yaml

@@ -1,107 +0,0 @@
-substitutions:
-  name: xbinject
-
-esphome:
-  name: ${name}
-  includes:
-    - frames.hpp
-
-esp32:
-  board: esp32dev
-  framework:
-    type: esp-idf
-
-logger:
-  level: DEBUG
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-
-api:
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-globals:
-  - id: xb_step
-    type: int
-    initial_value: "0"
-
-esp32_ble_tracker:
-  on_ble_service_data_advertise:
-    - mac_address: A4:C1:38:00:00:0A
-      service_uuid: FE95
-      then:
-        - lambda: |-
-            char buf[80];
-            size_t n = 0;
-            for (size_t i = 0; i < x.size() && n + 3 < sizeof(buf); i++)
-              n += snprintf(buf + n, sizeof(buf) - n, "%02X", x[i]);
-            ESP_LOGI("svcA", "len %u data %s", (unsigned) x.size(), buf);
-
-interval:
-  - interval: 1s
-    startup_delay: 15s
-    then:
-      - lambda: |-
-          if (id(xb_step) + 1 >= (int) XB_NUM_STEPS) {
-            if (id(xb_step) + 1 == (int) XB_NUM_STEPS) {
-              ESP_LOGI("xb", "INJECT DONE");
-              xb_rewrite_probe(id(xa));
-              id(xb_step)++;
-            }
-            return;
-          }
-          int s = id(xb_step);
-          ESP_LOGI("xb", "inject step %d frames %u..%u", s, XB_STEPS[s], XB_STEPS[s + 1]);
-          if (s == 0)
-            xb_inject(0, XB_STEPS[0]);
-          xb_inject(XB_STEPS[s], XB_STEPS[s + 1]);
-          id(xb_step)++;
-
-sensor:
-  - platform: xiaomi_lywsd03mmc
-    id: xa
-    mac_address: A4:C1:38:00:00:0A
-    bindkey: 6c0d1a3e5b7f29c4a18e90d2f3b46a57
-    temperature:
-      name: "xA lywsd03mmc temp"
-  - platform: xiaomi_lywsdcgq
-    mac_address: A4:C1:38:00:00:0B
-    temperature:
-      name: "xB lywsdcgq temp"
-    humidity:
-      name: "xB lywsdcgq hum"
-  - platform: xiaomi_hhccjcy01
-    mac_address: A4:C1:38:00:00:0C
-    temperature:
-      name: "xC hhccjcy01 temp"
-  - platform: xiaomi_cgg1
-    mac_address: A4:C1:38:00:00:0D
-    temperature:
-      name: "xD cgg1 temp"
-  - platform: xiaomi_xmwsdj04mmc
-    mac_address: A4:C1:38:00:00:0E
-    bindkey: 0f1e2d3c4b5a69788796a5b4c3d2e1f0
-    temperature:
-      name: "xE xmwsdj04mmc temp"
-    humidity:
-      name: "xE xmwsdj04mmc hum"
-  - platform: atc_mithermometer
-    mac_address: A4:C1:38:00:00:0F
-    temperature:
-      name: "xF atc temp"
-    humidity:
-      name: "xF atc hum"
-    battery_voltage:
-      name: "xF atc volt"
-  - platform: pvvx_mithermometer
-    mac_address: A4:C1:38:00:00:10
-    temperature:
-      name: "xG pvvx temp"
-    humidity:
-      name: "xG pvvx hum"
-    battery_voltage:
-      name: "xG pvvx volt"

.agents/skills/hardware-test/scripts/xiaomi_ble/xbrecv.yaml

@@ -1,83 +0,0 @@
-substitutions:
-  name: xbrecv
-
-esphome:
-  name: ${name}
-
-esp32:
-  board: esp32dev
-  framework:
-    type: esp-idf
-
-logger:
-  level: DEBUG
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-
-api:
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-esp32_ble_tracker:
-  scan_parameters:
-    interval: 100ms
-    window: 100ms
-    active: false
-  on_ble_service_data_advertise:
-    - mac_address: C4:C1:38:00:00:0A
-      service_uuid: FE95
-      then:
-        - lambda: |-
-            char buf[80];
-            size_t n = 0;
-            for (size_t i = 0; i < x.size() && n + 3 < sizeof(buf); i++)
-              n += snprintf(buf + n, sizeof(buf) - n, "%02X", x[i]);
-            ESP_LOGI("svcA", "len %u data %s", (unsigned) x.size(), buf);
-
-sensor:
-  - platform: xiaomi_lywsd03mmc
-    mac_address: C4:C1:38:00:00:0A
-    bindkey: 6c0d1a3e5b7f29c4a18e90d2f3b46a57
-    temperature:
-      name: "xA lywsd03mmc temp"
-  - platform: xiaomi_lywsdcgq
-    mac_address: C4:C1:38:00:00:0B
-    temperature:
-      name: "xB lywsdcgq temp"
-    humidity:
-      name: "xB lywsdcgq hum"
-  - platform: xiaomi_hhccjcy01
-    mac_address: C4:C1:38:00:00:0C
-    temperature:
-      name: "xC hhccjcy01 temp"
-  - platform: xiaomi_cgg1
-    mac_address: C4:C1:38:00:00:0D
-    temperature:
-      name: "xD cgg1 temp"
-  - platform: xiaomi_xmwsdj04mmc
-    mac_address: C4:C1:38:00:00:0E
-    bindkey: 0f1e2d3c4b5a69788796a5b4c3d2e1f0
-    temperature:
-      name: "xE xmwsdj04mmc temp"
-    humidity:
-      name: "xE xmwsdj04mmc hum"
-  - platform: atc_mithermometer
-    mac_address: C4:C1:38:00:00:0F
-    temperature:
-      name: "xF atc temp"
-    humidity:
-      name: "xF atc hum"
-    battery_voltage:
-      name: "xF atc volt"
-  - platform: pvvx_mithermometer
-    mac_address: C4:C1:38:00:00:10
-    temperature:
-      name: "xG pvvx temp"
-    humidity:
-      name: "xG pvvx hum"
-    battery_voltage:
-      name: "xG pvvx volt"

.agents/skills/hardware-test/templates/rtl8720c-crash-buttons-dut.yaml

@@ -1,64 +0,0 @@
-# RTL8720C (BW15) crash report test build (#21648): one API button per fault, driven by
-# scripts/libretiny_crash/rtl_drive.py. Each boot logs the reboot reason and whether a crash record was found.
-substitutions:
-  name: rtlcrash
-
-esphome:
-  name: ${name}
-  on_boot:
-    priority: -100
-    then:
-      - lambda: |-
-          // "n/a" when the handler is not built (a dev control build), so it is not read as a lost record
-          const char *rec = "n/a";
-          #ifdef USE_LIBRETINY_CRASH_HANDLER
-          rec = esphome::libretiny::crash_handler_has_data() ? "yes" : "no";
-          #endif
-          ESP_LOGI("probe", "boot reason %d, crash record %s", (int) lt_get_reboot_reason(), rec);
-
-rtl87xx:
-  board: bw15
-
-logger:
-  level: DEBUG
-
-wifi:
-  ssid: !secret wifi_ssid
-  password: !secret wifi_password
-
-api:
-  reboot_timeout: 0s
-
-ota:
-  - platform: esphome
-
-button:
-  - platform: template
-    name: trap
-    on_press:
-      - lambda: __builtin_trap();
-  - platform: template
-    name: bus fault
-    on_press:
-      - lambda: '*(volatile uint32_t *) 0x70000000 = 1;'
-  - platform: template
-    name: wild call
-    on_press:
-      - lambda: ((void (*)()) 0xFFFFFFF1)();
-  - platform: template
-    name: isr trap
-    on_press:
-      - lambda: |-
-          auto *vt = (uint32_t *) *(volatile uint32_t *) 0xE000ED08;
-          vt[16 + 11] = (uint32_t) +[]() { __builtin_trap(); };
-          *(volatile uint32_t *) 0xE000E100 = 1u << 11;
-          *(volatile uint32_t *) 0xE000E200 = 1u << 11;
-  - platform: template
-    name: hang
-    on_press:
-      - lambda: |-
-          __disable_irq();
-          while (true) {
-          }
-  - platform: restart
-    name: restart

esphome/components/binary_sensor/binary_sensor.cpp

@@ -31,13 +31,6 @@ void BinarySensor::publish_initial_state(bool new_state) {
   this->publish_state(new_state);
 }
 bool BinarySensor::set_new_state(const optional<bool> &new_state) {
-#ifdef USE_BINARY_SENSOR_FILTER
-  // An unknown state drops each filter's pending output and last value, so the next value is not dropped as a repeat
-  if (!new_state.has_value()) {
-    for (Filter *filter = this->filter_list_; filter != nullptr; filter = filter->next_)
-      filter->reset();
-  }
-#endif
   if (StatefulEntityBase::set_new_state(new_state)) {
     // weirdly, this file could be compiled even without USE_BINARY_SENSOR defined
 #if defined(USE_BINARY_SENSOR) && defined(USE_CONTROLLER_REGISTRY)

esphome/components/binary_sensor/filter.cpp

@@ -17,10 +17,6 @@ void Filter::output(bool value) {
     this->next_->input(value);
   }
 }
-void Filter::reset() {
-  this->dedup_.next_unknown();
-  App.scheduler.cancel_timeout(this);
-}
 void Filter::input(bool value) {
   if (!this->dedup_.next(value))
     return;
@@ -32,7 +28,7 @@ void Filter::input(bool value) {
 
 void TimeoutFilter::input(bool value) {
   App.scheduler.set_timeout(this, this->timeout_delay_.value(), [this]() { this->parent_->invalidate_state(); });
-  // Every input re-arms the timeout, including repeats, so this filter must not de-dup
+  // we do not de-dup here otherwise changes from invalid to valid state will not be output
   this->output(value);
 }
 
@@ -86,12 +82,6 @@ optional<bool> AutorepeatFilterBase::new_value(bool value) {
   }
 }
 
-void AutorepeatFilterBase::reset() {
-  this->dedup_.next_unknown();
-  // The release cancels both timers; Filter::reset() would leave the on/off timer running
-  AutorepeatFilterBase::new_value(false);
-}
-
 void AutorepeatFilterBase::next_timing_() {
   if (this->active_timing_ < this->timings_count_) {
     App.scheduler.set_timeout(this, this->timings_[this->active_timing_].delay, [this]() { this->next_timing_(); });
@@ -106,9 +96,6 @@ void AutorepeatFilterBase::next_timing_() {
 void AutorepeatFilterBase::next_value_(bool val) {
   const AutorepeatFilterTiming &timing = this->timings_[this->active_timing_ - 2];
   this->output(val);
-  // A callback of that output may have stopped the filter
-  if (this->active_timing_ < 2)
-    return;
   App.scheduler.set_timeout(&this->active_timing_, val ? timing.time_on : timing.time_off,
                             [this, val]() { this->next_value_(!val); });
 }
@@ -117,11 +104,6 @@ LambdaFilter::LambdaFilter(std::function<optional<bool>(bool)> f) : f_(std::move
 
 optional<bool> LambdaFilter::new_value(bool value) { return this->f_(value); }
 
-void SettleFilter::reset() {
-  Filter::reset();
-  this->steady_ = true;
-}
-
 optional<bool> SettleFilter::new_value(bool value) {
   if (!this->steady_) {
     App.scheduler.set_timeout(this, this->delay_.value(), [this, value]() {

esphome/components/binary_sensor/filter.h

@@ -24,9 +24,6 @@ class Filter {
  protected:
   friend BinarySensor;
 
-  /// Forget the last value and drop any pending scheduled output; called when the sensor's state is invalidated.
-  virtual void reset();
-
   Filter *next_{nullptr};
   BinarySensor *parent_{nullptr};
   Deduplicator<bool> dedup_;
@@ -103,7 +100,6 @@ class AutorepeatFilterBase : public Filter {
 
  protected:
   AutorepeatFilterBase() = default;
-  void reset() override;
   void next_timing_();
   void next_value_(bool val);
 
@@ -160,8 +156,6 @@ class SettleFilter : public Filter {
   template<typename T> void set_delay(T delay) { this->delay_ = delay; }
 
  protected:
-  void reset() override;
-
   TemplatableFn<uint32_t> delay_{};
   bool steady_{true};
 };

esphome/components/bk72xx_ble/__init__.py

@@ -4,11 +4,12 @@ The platform analog of esp32_ble / rp2040_ble: owns the Beken BDK BLE stack
 bring-up and the controller BLE address. Consumers (bk72xx_ble_tracker) build
 on this component and contain no SDK calls of their own.
 
-Supported SoCs (BLE 5.x): BK7231N/BK7236 (BLE 5.1), BK7238/BK7252N/BK7253 (BLE 5.2),
-and any future BLE-5.x SoC. LibreTiny 1.14 or newer is required: earlier releases
-have no BLE bonding partition, so the Beken SDK erases the bootloader flash sector
-at boot on BK7238 (esphome#18646, libretiny-eu/libretiny#408). Known non-5.x
-families are rejected in to_code. Unknown families are capability-checked at compile time via
+Supported SoCs (BLE 5.x): BK7231N/BK7236 (BLE 5.1), BK7252N/BK7253 (BLE 5.2),
+and any future BLE-5.x SoC. BK7238 (BLE 5.2) is blocked for now: with BLE
+compiled in, the Beken SDK erases the bootloader flash sector at boot because
+LibreTiny's partition table has no BLE bonding entry (esphome#18646,
+libretiny-eu/libretiny#408). Known non-5.x families and BK7238 are rejected in
+to_code. Unknown families are capability-checked at compile time via
 `__has_include("app_ble.h")`, a header only on the BLE 5.x include path
 (ble_api.h ships for every SoC, so it cannot be the probe). A non-5.x build
 fails with a clear #error.
@@ -28,6 +29,7 @@ from esphome.components.libretiny.const import (
     FAMILY_BK7231N,
     FAMILY_BK7231Q,
     FAMILY_BK7231T,
+    FAMILY_BK7238,
     FAMILY_BK7251,
 )
 import esphome.config_validation as cv
@@ -52,9 +54,7 @@ BEKEN_BDK_VERSION_OPTION = "custom_versions.beken-bdk"
 # bootloader with BLE compiled in; the libretiny platform builds with this one
 MIN_BDK_VERSION = (3, 0, 78)
 # Older LibreTiny releases arm the Beken MCU sleep with wifi power save, which halts
-# the device once the station stops while BLE runs (libretiny-eu/libretiny#414), and
-# have no BLE bond partition, so the BK7238 bond store erases flash sector 0 and
-# bricks the chip (libretiny-eu/libretiny#408)
+# the device once the station stops while BLE runs (libretiny-eu/libretiny#414)
 MIN_LIBRETINY_VERSION = (1, 14, 0)
 
 _LOGGER = logging.getLogger(__name__)
@@ -86,6 +86,14 @@ def _unsupported_family_message(family: str) -> str | None:
         )
     if family == FAMILY_BK7231Q:
         return "bk72xx_ble does not support BK7231Q: this SoC has no BLE"
+    if family == FAMILY_BK7238:
+        return (
+            "bk72xx_ble is disabled on BK7238: with BLE compiled in, the Beken SDK "
+            "erases the bootloader flash sector at boot and the device can no longer "
+            "start (see https://github.com/esphome/esphome/issues/18646); support "
+            "returns once the LibreTiny partition table fix "
+            "(libretiny-eu/libretiny#408) is released"
+        )
     return None
 
 
@@ -109,15 +117,14 @@ def check_bdk_version(value: str | None) -> None:
 
 
 def check_libretiny_version(version: cv.Version) -> None:
-    """Reject a LibreTiny release older than the one whose WiFi sleep and bond storage are safe with BLE."""
+    """Reject a LibreTiny release older than the one whose WiFi sleep is safe with BLE."""
     if (version.major, version.minor, version.patch) >= MIN_LIBRETINY_VERSION:
         return
     minimum = ".".join(str(part) for part in MIN_LIBRETINY_VERSION)
     raise cv.Invalid(
         f"bk72xx_ble needs LibreTiny {minimum} or newer, not {version}: older releases "
         "arm the Beken MCU sleep with wifi power save and the device halts once the "
-        "station stops while BLE runs, and on BK7238 the bond store erases flash "
-        "sector 0 and bricks the chip"
+        "station stops while BLE runs"
     )
 
 

esphome/components/ble_client/__init__.py

@@ -1,12 +1,24 @@
-from collections.abc import Coroutine
+from collections.abc import Callable, Coroutine
+import functools
 from typing import Any
 
 from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
-from esphome.components import esp32_ble, esp32_ble_client, esp32_ble_tracker
+from esphome.components import ble_device_base, bluetooth_connection
+from esphome.components.ble_device_base import (
+    BT_UUID16_FORMAT as bt_uuid16_format,
+    BT_UUID32_FORMAT as bt_uuid32_format,
+    BT_UUID128_FORMAT as bt_uuid128_format,
+    as_hex,
+    as_reversed_hex_array,
+    bt_uuid,
+)
 from esphome.components.const import CONF_ACCEPT, CONF_ON_NUMERIC_COMPARISON_REQUEST
-from esphome.components.esp32_ble import BTLoggers
+from esphome.config_helpers import (
+    filter_source_files_from_platform,
+    frameworks_for_platforms,
+)
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHARACTERISTIC_UUID,
@@ -19,15 +31,55 @@ from esphome.const import (
     CONF_SERVICE_UUID,
     CONF_TRIGGER_ID,
     CONF_VALUE,
+    PLATFORM_ESP32,
+    PlatformFramework,
 )
-from esphome.core import ID
+from esphome.core import CORE, ID
+from esphome.enum import StrEnum
+from esphome.schema_extractors import SCHEMA_EXTRACT, schema_extractor
 from esphome.types import ConfigType
 
-AUTO_LOAD = ["esp32_ble_client"]
+# The esp32 BLE stack (esp32_ble, esp32_ble_tracker) is imported lazily inside
+# the esp32 schema/codegen arms: importing those modules registers esp32-only
+# automations as a side effect, which must not leak into the neutral
+# platforms' registries (the bluetooth_proxy pattern).
+
+
+def _legacy_engine() -> bool:
+    """True when the build uses the legacy raw-gattc engine - one line to
+    flip when esp32 moves to the neutral engine (with
+    USE_BLE_CLIENT_LEGACY_ENGINE in _to_code_esp32)."""
+    return CORE.is_esp32
+
+
+def AUTO_LOAD() -> list[str]:
+    """The engine's closure per platform: the legacy esp32 engine builds on
+    esp32_ble_client plus bluetooth_connection (the shared service-table
+    materializer; its sources compile empty in builds without a neutral
+    node), the neutral engine on the bluetooth_connection backend. The
+    platform-less arm is the union for manifest-resolving tooling."""
+    if _legacy_engine() or CORE.target_platform is None:
+        return ["bluetooth_connection", "esp32_ble_client"]
+    return ["bluetooth_connection"]
+
+
 CODEOWNERS = ["@buxtronix", "@clydebarrow"]
-DEPENDENCIES = ["esp32_ble_tracker"]
 DOMAIN = "ble_client"
 
+FILTER_SOURCE_FILES = filter_source_files_from_platform(
+    {
+        "ble_client.cpp": {
+            PlatformFramework.ESP32_ARDUINO,
+            PlatformFramework.ESP32_IDF,
+        },
+        # Every framework of every non-esp32 registry platform: a platform
+        # that validates the neutral arm must also compile the neutral engine.
+        "ble_client_gatt.cpp": frameworks_for_platforms(
+            set(bluetooth_connection.GATT_CLIENT_PLATFORMS) - {PLATFORM_ESP32}
+        ),
+    }
+)
+
 CONF_DESCRIPTOR_UUID = "descriptor_uuid"
 CONF_ON_NOTIFY = "on_notify"
 
@@ -63,16 +115,12 @@ def notify_from_on_notify(config: ConfigType) -> ConfigType:
 
 
 ble_client_ns = cg.esphome_ns.namespace("ble_client")
-BLEClient = ble_client_ns.class_("BLEClient", esp32_ble_client.BLEClientBase)
+# One codegen class for both engines: the exclusively-gated headers resolve
+# the name to exactly one C++ definition per build.
+BLEClient = ble_client_ns.class_("BLEClient", cg.Component)
 BLEClientNode = ble_client_ns.class_("BLEClientNode")
 BLEClientNodeConstRef = BLEClientNode.operator("ref").operator("const")
 # Triggers
-BLEClientConnectTrigger = ble_client_ns.class_(
-    "BLEClientConnectTrigger", automation.Trigger.template(BLEClientNodeConstRef)
-)
-BLEClientDisconnectTrigger = ble_client_ns.class_(
-    "BLEClientDisconnectTrigger", automation.Trigger.template(BLEClientNodeConstRef)
-)
 BLEClientPasskeyRequestTrigger = ble_client_ns.class_(
     "BLEClientPasskeyRequestTrigger", automation.Trigger.template(BLEClientNodeConstRef)
 )
@@ -108,62 +156,175 @@ CONF_AUTO_CONNECT = "auto_connect"
 
 MULTI_CONF = True
 
-CONFIG_SCHEMA = cv.All(
-    cv.Schema(
-        {
-            cv.GenerateID(): cv.declare_id(BLEClient),
-            cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
-            cv.Optional(CONF_NAME): cv.string,
-            cv.Optional(CONF_AUTO_CONNECT, default=True): cv.boolean,
-            cv.Optional(CONF_ON_CONNECT): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        BLEClientConnectTrigger
-                    ),
-                }
-            ),
-            cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        BLEClientDisconnectTrigger
-                    ),
-                }
-            ),
-            cv.Optional(CONF_ON_PASSKEY_REQUEST): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        BLEClientPasskeyRequestTrigger
-                    ),
-                }
-            ),
-            cv.Optional(CONF_ON_PASSKEY_NOTIFICATION): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        BLEClientPasskeyNotificationTrigger
-                    ),
-                }
-            ),
-            cv.Optional(
-                CONF_ON_NUMERIC_COMPARISON_REQUEST
-            ): automation.validate_automation(
-                {
-                    cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
-                        BLEClientNumericComparisonRequestTrigger
-                    ),
-                }
-            ),
-        }
-    )
-    .extend(cv.COMPONENT_SCHEMA)
-    .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA),
-    esp32_ble.consume_connection_slots(1, "ble_client"),
+# Keys shared by both engines' schemas.
+_COMMON_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(): cv.declare_id(BLEClient),
+        cv.Required(CONF_MAC_ADDRESS): cv.mac_address,
+        cv.Optional(CONF_AUTO_CONNECT, default=True): cv.boolean,
+        cv.Optional(CONF_ON_CONNECT): automation.validate_automation({}),
+        cv.Optional(CONF_ON_DISCONNECT): automation.validate_automation({}),
+    }
+).extend(cv.COMPONENT_SCHEMA)
+
+# Both engines register these on the client; the Bluedroid-security triggers below stay trigger classes
+_CALLBACK_AUTOMATIONS = (
+    automation.CallbackAutomation(CONF_ON_CONNECT, "add_on_connect_callback"),
+    automation.CallbackAutomation(CONF_ON_DISCONNECT, "add_on_disconnect_callback"),
 )
 
+
+@functools.cache
+def _esp32_config_schema() -> cv.All:
+    """The legacy engine's schema, byte-compatible with what esp32 always had
+    (including the Bluedroid security triggers)."""
+    from esphome.components import esp32_ble_tracker
+
+    return cv.All(
+        _COMMON_SCHEMA.extend(
+            {
+                # Accepted-but-unused legacy key; not propagated to the
+                # neutral schema.
+                cv.Optional(CONF_NAME): cv.string,
+                cv.Optional(CONF_ON_PASSKEY_REQUEST): automation.validate_automation(
+                    {
+                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                            BLEClientPasskeyRequestTrigger
+                        ),
+                    }
+                ),
+                cv.Optional(
+                    CONF_ON_PASSKEY_NOTIFICATION
+                ): automation.validate_automation(
+                    {
+                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                            BLEClientPasskeyNotificationTrigger
+                        ),
+                    }
+                ),
+                cv.Optional(
+                    CONF_ON_NUMERIC_COMPARISON_REQUEST
+                ): automation.validate_automation(
+                    {
+                        cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id(
+                            BLEClientNumericComparisonRequestTrigger
+                        ),
+                    }
+                ),
+            }
+        ).extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA),
+        bluetooth_connection.consume_gatt_slot("ble_client"),
+    )
+
+
+@functools.cache
+def _gatt_config_schema(platform: str) -> cv.All:
+    """The neutral engine's schema: the shared keys plus the hub reference
+    (parsed-advertisement sightings) and the GATT backend declaration.
+    Keyed by platform - the backend fragment differs per platform."""
+    return cv.All(
+        _COMMON_SCHEMA.extend(ble_device_base.BLE_DEVICE_SCHEMA).extend(
+            bluetooth_connection.gatt_client_schema(platform)
+        ),
+        bluetooth_connection.consume_gatt_slot("ble_client"),
+    )
+
+
+@schema_extractor("schema")
+def _validate_platform(config: ConfigType) -> ConfigType:
+    if config is SCHEMA_EXTRACT:
+        # Deliberate gap (the bluetooth_proxy pattern): the dumper gets only
+        # this shape, so the neutral arm's ble_hub_id is absent from editor
+        # schemas and the esp32-only keys are advertised on every platform.
+        # The language-schema dumper runs without a platform; expose the
+        # esp32 (legacy-engine) shape.
+        return _esp32_config_schema()
+    if _legacy_engine():
+        return _esp32_config_schema()(config)
+    if CORE.target_platform in bluetooth_connection.GATT_CLIENT_PLATFORMS:
+        return _gatt_config_schema(CORE.target_platform)(config)
+    raise cv.Invalid(f"ble_client is not supported on {CORE.target_platform}")
+
+
+CONFIG_SCHEMA = _validate_platform
+
 CONF_BLE_CLIENT_ID = "ble_client_id"
 
+
+class BLEClientFeatures(StrEnum):
+    """Per-platform engine capabilities consumers declare against."""
+
+    # The platform-neutral node interface (on_connected/table + completion
+    # callbacks) - every platform with a ble_client engine.
+    GATT_NODE = "gatt_node"
+    # The raw esp32 GATT client event stream (gattc/gap handlers,
+    # node_state) - the legacy engine only.
+    RAW_GATTC = "raw_gattc"
+    # Pairing dialog replies and bond management (Bluedroid GAP/SMP).
+    SECURITY = "security"
+
+
+def _engine_features() -> set[BLEClientFeatures]:
+    """Features the validated platform's engine provides."""
+    if _legacy_engine():
+        return {
+            BLEClientFeatures.GATT_NODE,
+            BLEClientFeatures.RAW_GATTC,
+            BLEClientFeatures.SECURITY,
+        }
+    if CORE.target_platform in bluetooth_connection.GATT_CLIENT_PLATFORMS:
+        return {BLEClientFeatures.GATT_NODE}
+    return set()
+
+
+def requires_feature(
+    feature: BLEClientFeatures, description: str
+) -> Callable[[Any], Any]:
+    """Validator gating a consumer to platforms whose engine provides
+    `feature`, naming the missing capability in the error."""
+
+    def validator(value: Any) -> Any:
+        features = _engine_features()
+        if feature not in features:
+            available = (
+                f"; this platform's engine provides: {', '.join(sorted(features))}"
+                if features
+                else ""
+            )
+            raise cv.Invalid(
+                f"{description} requires the ble_client '{feature}' feature, "
+                f"which {CORE.target_platform} does not provide{available}"
+            )
+        return value
+
+    return validator
+
+
+# The one choke point for every node component still on the raw esp32 event
+# stream; migrating to the neutral interface (NODE_BLE_CLIENT_SCHEMA +
+# register_gatt_node) lifts it.
+_legacy_engine_only = requires_feature(
+    BLEClientFeatures.RAW_GATTC,
+    "This component drives the raw ESP32 GATT client events and has not "
+    "been migrated to the platform-neutral node interface yet; it",
+)
+
 BLE_CLIENT_SCHEMA = cv.Schema(
     {
-        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.use_id(BLEClient),
+        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.All(
+            cv.use_id(BLEClient), _legacy_engine_only
+        ),
+    }
+)
+
+# For node components on the neutral interface: valid wherever ble_client
+# itself is.
+NODE_BLE_CLIENT_SCHEMA = cv.Schema(
+    {
+        cv.GenerateID(CONF_BLE_CLIENT_ID): cv.All(
+            cv.use_id(BLEClient),
+            requires_feature(BLEClientFeatures.GATT_NODE, "This component"),
+        ),
     }
 )
 
@@ -173,6 +334,26 @@ async def register_ble_node(var, config):
     cg.add(parent.register_ble_node(var))
 
 
+def _request_gatt_node_build() -> None:
+    """Node storage and the one define meaning "the neutral node surface is
+    compiled in", plus the esp32 bridge/materializer defines."""
+    _request_node_slot()
+    cg.add_define("USE_BLE_CLIENT_GATT_NODES")
+    if _legacy_engine():
+        # Deliberately not ble_device_base.request_gatt_client(): that would
+        # claim a phantom backend slot on combined proxy builds.
+        cg.add_define("USE_BLE_GATT_CLIENT")
+        cg.add_define("USE_BLE_GATT_BACKEND_BLUEDROID")
+        cg.add_define("USE_BLUEDROID_GATT_SERVICE_TABLE")
+
+
+async def register_gatt_node(var, config):
+    """Register a node on the platform-neutral interface (both engines)."""
+    parent = await cg.get_variable(config[CONF_BLE_CLIENT_ID])
+    _request_gatt_node_build()
+    cg.add(parent.register_gatt_node(var))
+
+
 def new_ble_node_component(
     config: ConfigType, *args: Any
 ) -> Coroutine[Any, Any, cg.MockObj]:
@@ -183,8 +364,8 @@ def new_ble_node_component(
 BLE_WRITE_ACTION_SCHEMA = cv.Schema(
     {
         cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-        cv.Required(CONF_SERVICE_UUID): esp32_ble_tracker.bt_uuid,
-        cv.Required(CONF_CHARACTERISTIC_UUID): esp32_ble_tracker.bt_uuid,
+        cv.Required(CONF_SERVICE_UUID): bt_uuid,
+        cv.Required(CONF_CHARACTERISTIC_UUID): bt_uuid,
         cv.Required(CONF_VALUE): cv.templatable(cv.ensure_list(cv.hex_uint8_t)),
     }
 )
@@ -195,25 +376,34 @@ BLE_CONNECT_ACTION_SCHEMA = maybe_simple_id(
     }
 )
 
-BLE_NUMERIC_COMPARISON_REPLY_ACTION_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-        cv.Required(CONF_ACCEPT): cv.templatable(cv.boolean),
-    }
+BLE_NUMERIC_COMPARISON_REPLY_ACTION_SCHEMA = cv.All(
+    requires_feature(BLEClientFeatures.SECURITY, "This action"),
+    cv.Schema(
+        {
+            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+            cv.Required(CONF_ACCEPT): cv.templatable(cv.boolean),
+        }
+    ),
 )
 
-BLE_PASSKEY_REPLY_ACTION_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-        cv.Required(CONF_PASSKEY): cv.templatable(cv.int_range(min=0, max=999999)),
-    }
+BLE_PASSKEY_REPLY_ACTION_SCHEMA = cv.All(
+    requires_feature(BLEClientFeatures.SECURITY, "This action"),
+    cv.Schema(
+        {
+            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+            cv.Required(CONF_PASSKEY): cv.templatable(cv.int_range(min=0, max=999999)),
+        }
+    ),
 )
 
 
-BLE_REMOVE_BOND_ACTION_SCHEMA = cv.Schema(
-    {
-        cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
-    }
+BLE_REMOVE_BOND_ACTION_SCHEMA = cv.All(
+    requires_feature(BLEClientFeatures.SECURITY, "This action"),
+    cv.Schema(
+        {
+            cv.GenerateID(CONF_ID): cv.use_id(BLEClient),
+        }
+    ),
 )
 
 
@@ -241,6 +431,8 @@ automation.register_simple_action(
 )
 async def ble_write_to_code(config, action_id, template_arg, args):
     parent = await cg.get_variable(config[CONF_ID])
+    # The action registers itself as a neutral node in its constructor.
+    _request_gatt_node_build()
     var = cg.new_Pvariable(action_id, template_arg, parent)
 
     value = config[CONF_VALUE]
@@ -255,38 +447,20 @@ async def ble_write_to_code(config, action_id, template_arg, args):
         arr = cg.static_const_array(arr_id, cg.ArrayInitializer(*value))
         cg.add(var.set_value_simple(arr, len(value)))
 
-    if len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
-        cg.add(
-            var.set_service_uuid16(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
-        )
-    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid32_format):
-        cg.add(
-            var.set_service_uuid32(esp32_ble_tracker.as_hex(config[CONF_SERVICE_UUID]))
-        )
-    elif len(config[CONF_SERVICE_UUID]) == len(esp32_ble_tracker.bt_uuid128_format):
-        uuid128 = esp32_ble_tracker.as_reversed_hex_array(config[CONF_SERVICE_UUID])
+    if len(config[CONF_SERVICE_UUID]) == len(bt_uuid16_format):
+        cg.add(var.set_service_uuid16(as_hex(config[CONF_SERVICE_UUID])))
+    elif len(config[CONF_SERVICE_UUID]) == len(bt_uuid32_format):
+        cg.add(var.set_service_uuid32(as_hex(config[CONF_SERVICE_UUID])))
+    elif len(config[CONF_SERVICE_UUID]) == len(bt_uuid128_format):
+        uuid128 = as_reversed_hex_array(config[CONF_SERVICE_UUID])
         cg.add(var.set_service_uuid128(uuid128))
 
-    if len(config[CONF_CHARACTERISTIC_UUID]) == len(esp32_ble_tracker.bt_uuid16_format):
-        cg.add(
-            var.set_char_uuid16(
-                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
-            )
-        )
-    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
-        esp32_ble_tracker.bt_uuid32_format
-    ):
-        cg.add(
-            var.set_char_uuid32(
-                esp32_ble_tracker.as_hex(config[CONF_CHARACTERISTIC_UUID])
-            )
-        )
-    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(
-        esp32_ble_tracker.bt_uuid128_format
-    ):
-        uuid128 = esp32_ble_tracker.as_reversed_hex_array(
-            config[CONF_CHARACTERISTIC_UUID]
-        )
+    if len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid16_format):
+        cg.add(var.set_char_uuid16(as_hex(config[CONF_CHARACTERISTIC_UUID])))
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid32_format):
+        cg.add(var.set_char_uuid32(as_hex(config[CONF_CHARACTERISTIC_UUID])))
+    elif len(config[CONF_CHARACTERISTIC_UUID]) == len(bt_uuid128_format):
+        uuid128 = as_reversed_hex_array(config[CONF_CHARACTERISTIC_UUID])
         cg.add(var.set_char_uuid128(uuid128))
 
     return var
@@ -340,22 +514,48 @@ automation.register_simple_action(
 )
 
 
-async def to_code(config):
+async def _to_code_esp32(config: ConfigType) -> cg.MockObj:
+    from esphome.components import esp32_ble, esp32_ble_tracker
+    from esphome.components.esp32_ble import BTLoggers
+
     # Register the loggers this component needs
     esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.SMP)
     cg.add_define("USE_ESP32_BLE_UUID")
+    cg.add_define("USE_BLE_CLIENT_LEGACY_ENGINE")
 
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await esp32_ble_tracker.register_client(var, config)
+    return var
+
+
+# Sizes the neutral client's node storage; the client itself requests a
+# baseline slot so the define exists on every build that compiles the engine.
+_request_node_slot = cg.slot_counter("ESPHOME_BLE_CLIENT_MAX_NODES")
+
+
+async def _to_code_gatt(config: ConfigType) -> cg.MockObj:
+    # The engine always carries the node surface (the client itself owns the
+    # baseline slot).
+    _request_gatt_node_build()
+    backend = await bluetooth_connection.new_gatt_backend(config)
+    var = cg.new_Pvariable(config[CONF_ID])
+    await cg.register_component(var, config)
+    cg.add(var.set_backend(backend))
+    # Sighting-gated connects: the client listens for the peer's parsed
+    # advertisements through the hub.
+    await ble_device_base.register_ble_device(var, config)
+    return var
+
+
+async def to_code(config: ConfigType) -> None:
+    if _legacy_engine():
+        var = await _to_code_esp32(config)
+    else:
+        var = await _to_code_gatt(config)
     cg.add(var.set_address(config[CONF_MAC_ADDRESS].as_hex))
     cg.add(var.set_auto_connect(config[CONF_AUTO_CONNECT]))
-    for conf in config.get(CONF_ON_CONNECT, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [], conf)
-    for conf in config.get(CONF_ON_DISCONNECT, []):
-        trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
-        await automation.build_automation(trigger, [], conf)
+    await automation.build_callback_automations(var, config, _CALLBACK_AUTOMATIONS)
     for conf in config.get(CONF_ON_PASSKEY_REQUEST, []):
         trigger = cg.new_Pvariable(conf[CONF_TRIGGER_ID], var)
         await automation.build_automation(trigger, [], conf)

esphome/components/ble_client/automation.cpp

@@ -1,11 +0,0 @@
-#ifdef USE_ESP32
-
-#include "automation.h"
-
-namespace esphome::ble_client {
-
-const char *const Automation::TAG = "ble_client.automation";  // NOLINT: ble_client never builds for ESP8266
-
-}  // namespace esphome::ble_client
-
-#endif

esphome/components/ble_client/automation.h

@@ -1,27 +1,14 @@
 #pragma once
 
-#ifdef USE_ESP32
+#include "esphome/core/defines.h"
 
-#include <utility>
-#include <vector>
+#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
 
 #include "esphome/core/automation.h"
 #include "esphome/components/ble_client/ble_client.h"
-#include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
-
-// Maximum bytes to log in hex format for BLE writes (many logging buffers are 256 chars)
-static constexpr size_t BLE_WRITE_MAX_LOG_BYTES = 64;
 
 namespace esphome::ble_client {
 
-// placeholder class for static TAG .
-class Automation {
- public:
-  // could be made inline with C++17
-  static const char *const TAG;
-};
-
 // Base for nodes that never read the parent's services.
 // The parent releases its services only once every node reports Established, so a node that never
 // reports it keeps that memory allocated for the life of the connection.
@@ -39,45 +26,6 @@ class BLEClientServicelessNode : public BLEClientNode {
   virtual void on_gattc_event(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if, esp_ble_gattc_cb_param_t *param) {}
 };
 
-// implement on_connect automation.
-class BLEClientConnectTrigger final : public Trigger<>, public BLEClientNode {
- public:
-  explicit BLEClientConnectTrigger(BLEClient *parent) { parent->register_ble_node(this); }
-  void loop() override {}
-  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
-                           esp_ble_gattc_cb_param_t *param) override {
-    if (event == ESP_GATTC_SEARCH_CMPL_EVT) {
-      this->node_state = espbt::ClientState::ESTABLISHED;
-      this->trigger();
-    }
-  }
-};
-
-// on_disconnect automation
-class BLEClientDisconnectTrigger final : public Trigger<>, public BLEClientNode {
- public:
-  explicit BLEClientDisconnectTrigger(BLEClient *parent) { parent->register_ble_node(this); }
-  void loop() override {}
-  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
-                           esp_ble_gattc_cb_param_t *param) override {
-    // test for CLOSE and not DISCONNECT - DISCONNECT can occur even if no virtual connection (OPEN event) occurred.
-    // So this will not trigger unless a complete open has previously succeeded.
-    switch (event) {
-      case ESP_GATTC_SEARCH_CMPL_EVT: {
-        this->node_state = espbt::ClientState::ESTABLISHED;
-        break;
-      }
-      case ESP_GATTC_CLOSE_EVT: {
-        this->trigger();
-        break;
-      }
-      default: {
-        break;
-      }
-    }
-  }
-};
-
 class BLEClientPasskeyRequestTrigger final : public Trigger<>, public BLEClientServicelessNode {
  public:
   explicit BLEClientPasskeyRequestTrigger(BLEClient *parent) { parent->register_ble_node(this); }
@@ -110,144 +58,6 @@ class BLEClientNumericComparisonRequestTrigger final : public Trigger<uint32_t>,
   }
 };
 
-// implement the ble_client.ble_write action.
-template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>, public BLEClientNode {
- public:
-  BLEClientWriteAction(BLEClient *ble_client) {
-    ble_client->register_ble_node(this);
-    ble_client_ = ble_client;
-  }
-
-  void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
-  void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
-  void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
-
-  void set_char_uuid16(uint16_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint16(uuid); }
-  void set_char_uuid32(uint32_t uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_uint32(uuid); }
-  void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = espbt::ESPBTUUID::from_raw(uuid); }
-
-  void set_value_template(std::vector<uint8_t> (*func)(Ts...)) {
-    this->value_.func = func;
-    this->len_ = -1;  // Sentinel value indicates template mode
-  }
-
-  // Store pointer to static data in flash (no RAM copy)
-  void set_value_simple(const uint8_t *data, size_t len) {
-    this->value_.data = data;
-    this->len_ = len;  // Length >= 0 indicates static mode
-  }
-
-  void play(const Ts &...x) override {}
-
-  void play_complex(const Ts &...x) override {
-    this->num_running_++;
-    this->var_ = std::make_tuple(x...);
-
-    bool result;
-    if (this->len_ >= 0) {
-      // Static mode: write directly from flash pointer
-      result = this->write(this->value_.data, this->len_);
-    } else {
-      // Template mode: call function and write the vector
-      std::vector<uint8_t> value = this->value_.func(x...);
-      result = this->write(value);
-    }
-
-    // on write failure, continue the automation chain rather than stopping so that e.g. disconnect can work.
-    if (!result)
-      this->play_next_(x...);
-  }
-
-  /**
-   * Note about logging: the esph_log_X macros are used here because the CI checks complain about use of the ESP LOG
-   * macros in header files (Can't even write it in a comment!)
-   * Not sure why, because they seem to work just fine.
-   * The problem is that the implementation of a templated class can't be placed in a .cpp file when using C++ less than
-   * 17, so the methods have to be here.  The esph_log_X macros are equivalent in function, but don't trigger the CI
-   * errors.
-   */
-  // initiate the write. Return true if all went well, will be followed by a WRITE_CHAR event.
-  bool write(const uint8_t *data, size_t len) {
-    if (this->node_state != espbt::ClientState::ESTABLISHED) {
-      esph_log_w(Automation::TAG, "Cannot write to BLE characteristic - not connected");
-      return false;
-    }
-#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
-    char hex_buf[format_hex_pretty_size(BLE_WRITE_MAX_LOG_BYTES)];
-    esph_log_vv(Automation::TAG, "Will write %d bytes: %s", len, format_hex_pretty_to(hex_buf, data, len));
-#endif
-    esp_err_t err =
-        esp_ble_gattc_write_char(this->parent()->get_gattc_if(), this->parent()->get_conn_id(), this->char_handle_, len,
-                                 const_cast<uint8_t *>(data), this->write_type_, ESP_GATT_AUTH_REQ_NONE);
-    if (err != ESP_OK) {
-      esph_log_e(Automation::TAG, "Error writing to characteristic: %s!", esp_err_to_name(err));
-      return false;
-    }
-    return true;
-  }
-
-  bool write(const std::vector<uint8_t> &value) { return this->write(value.data(), value.size()); }
-
-  void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
-                           esp_ble_gattc_cb_param_t *param) override {
-    switch (event) {
-      case ESP_GATTC_WRITE_CHAR_EVT:
-        // upstream code checked the MAC address, verify the characteristic.
-        if (param->write.handle == this->char_handle_)
-          this->parent()->run_later([this]() { this->play_next_tuple_(this->var_); });
-        break;
-      case ESP_GATTC_DISCONNECT_EVT:
-        if (this->num_running_ != 0)
-          this->stop_complex();
-        break;
-      case ESP_GATTC_SEARCH_CMPL_EVT: {
-        auto *chr = this->parent()->get_characteristic(this->service_uuid_, this->char_uuid_);
-        if (chr == nullptr) {
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          char service_buf[esp32_ble::UUID_STR_LEN];
-          esph_log_w("ble_write_action", "Characteristic %s was not found in service %s",
-                     this->char_uuid_.to_str(char_buf), this->service_uuid_.to_str(service_buf));
-          break;
-        }
-        this->char_handle_ = chr->handle;
-        this->char_props_ = chr->properties;
-        if (this->char_props_ & ESP_GATT_CHAR_PROP_BIT_WRITE) {
-          this->write_type_ = ESP_GATT_WRITE_TYPE_RSP;
-          esph_log_d(Automation::TAG, "Write type: ESP_GATT_WRITE_TYPE_RSP");
-        } else if (this->char_props_ & ESP_GATT_CHAR_PROP_BIT_WRITE_NR) {
-          this->write_type_ = ESP_GATT_WRITE_TYPE_NO_RSP;
-          esph_log_d(Automation::TAG, "Write type: ESP_GATT_WRITE_TYPE_NO_RSP");
-        } else {
-          char char_buf[esp32_ble::UUID_STR_LEN];
-          esph_log_e(Automation::TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_str(char_buf));
-          break;
-        }
-        this->node_state = espbt::ClientState::ESTABLISHED;
-        char char_buf[esp32_ble::UUID_STR_LEN];
-        esph_log_d(Automation::TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
-                   ble_client_->address_str());
-        break;
-      }
-      default:
-        break;
-    }
-  }
-
- private:
-  BLEClient *ble_client_;
-  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
-  union Value {
-    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
-    const uint8_t *data;                  // Pointer to static data in flash
-  } value_;
-  espbt::ESPBTUUID service_uuid_;
-  espbt::ESPBTUUID char_uuid_;
-  std::tuple<Ts...> var_{};
-  uint16_t char_handle_{};
-  esp_gatt_char_prop_t char_props_{};
-  esp_gatt_write_type_t write_type_{};
-};
-
 template<typename... Ts> class BLEClientPasskeyReplyAction final : public Action<Ts...> {
  public:
   BLEClientPasskeyReplyAction(BLEClient *ble_client) { parent_ = ble_client; }

esphome/components/ble_client/automation_gatt.h

@@ -0,0 +1,103 @@
+// Neutral twins of the shared ble_client automations. Class names, namespace,
+// and codegen-visible signatures are IDENTICAL to automation.h so generated
+// main.cpp compiles against whichever engine the build gates in; only the
+// internals differ (client callbacks and the neutral node interface instead
+// of raw gattc events). The Bluedroid-security automations (passkey, numeric
+// comparison, remove bond) have no neutral equivalent and stay esp32-only.
+
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#if defined(USE_BLE_CLIENT_GATT_NODES) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
+
+#include <tuple>
+
+#include "ble_client_gatt.h"
+#include "esphome/core/automation.h"
+
+namespace esphome::ble_client {
+
+template<typename... Ts> class BLEClientConnectAction final : public Action<Ts...> {
+ public:
+  BLEClientConnectAction(BLEClient *ble_client) {
+    ble_client_ = ble_client;
+    ble_client->add_on_connect_callback([this]() {
+      if (this->num_running_ != 0)
+        this->play_next_tuple_(this->var_);
+    });
+    // A connect attempt that dies (or a later disconnect) terminates the
+    // chain - unless a fresh attempt is already in flight, meaning a user
+    // trigger on this same list started this action (an on_disconnect that
+    // reconnects) and the wait belongs to that attempt. Legacy split these:
+    // it aborted on DISCONNECT_EVT, the trigger fired on the later CLOSE_EVT.
+    auto terminate = [this]() {
+      if (this->num_running_ != 0 && this->ble_client_->idle())
+        this->stop_complex();
+    };
+    ble_client->add_on_connect_failed_callback(terminate);
+    ble_client->add_on_disconnect_callback(terminate);
+  }
+
+  // not used since we override play_complex_
+  void play(const Ts &...x) override {}
+
+  void play_complex(const Ts &...x) override {
+    // it makes no sense to have multiple instances of this running at the
+    // same time; cancel a re-trigger while still running.
+    if (this->num_running_ != 0) {
+      this->stop_complex();
+      return;
+    }
+    this->num_running_++;
+    if (this->ble_client_->connected()) {
+      this->play_next_(x...);
+    } else {
+      this->var_ = std::make_tuple(x...);
+      // No-op while already connecting; the callback resolves the wait.
+      this->ble_client_->connect();
+    }
+  }
+
+ private:
+  BLEClient *ble_client_;
+  std::tuple<Ts...> var_{};
+};
+
+template<typename... Ts> class BLEClientDisconnectAction final : public Action<Ts...> {
+ public:
+  BLEClientDisconnectAction(BLEClient *ble_client) {
+    ble_client_ = ble_client;
+    // Both terminal outcomes resolve the wait: a completed teardown and a
+    // connect attempt that died on the way down.
+    ble_client->add_on_disconnect_callback([this]() {
+      if (this->num_running_ != 0)
+        this->play_next_tuple_(this->var_);
+    });
+    ble_client->add_on_connect_failed_callback([this]() {
+      if (this->num_running_ != 0)
+        this->play_next_tuple_(this->var_);
+    });
+  }
+
+  // not used since we override play_complex_
+  void play(const Ts &...x) override {}
+
+  void play_complex(const Ts &...x) override {
+    this->num_running_++;
+    if (this->ble_client_->idle()) {
+      this->play_next_(x...);
+    } else {
+      this->var_ = std::make_tuple(x...);
+      this->ble_client_->disconnect();
+    }
+  }
+
+ private:
+  BLEClient *ble_client_;
+  std::tuple<Ts...> var_{};
+};
+
+}  // namespace esphome::ble_client
+
+#endif  // USE_BLE_CLIENT_GATT_NODES && !USE_BLE_CLIENT_LEGACY_ENGINE

esphome/components/ble_client/ble_client.cpp

@@ -2,10 +2,16 @@
 #include "esphome/components/esp32_ble_client/ble_client_base.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/application.h"
+#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-#ifdef USE_ESP32
+#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
+
+#ifdef USE_BLE_CLIENT_GATT_NODES
+#include "esphome/components/bluetooth_connection/bluetooth_connection.h"
+#include "esphome/components/bluetooth_connection/gatt_service_table_bluedroid.h"
+#endif
 
 namespace esphome::ble_client {
 
@@ -30,6 +36,10 @@ void BLEClient::dump_config() {
 bool BLEClient::parse_device(const espbt::ESPBTDevice &device) {
   if (!this->enabled)
     return false;
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  if (device.address_uint64() == this->address_ && this->gatt_backoff_.holding_off())
+    return false;
+#endif
   return BLEClientBase::parse_device(device);
 }
 
@@ -40,24 +50,65 @@ void BLEClient::set_enabled(bool enabled) {
   if (!enabled) {
     ESP_LOGI(TAG, "[%s] Disabling BLE client.", this->address_str());
     this->disconnect();
+    return;
   }
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // A re-enable clears the backoff (neutral-engine parity).
+  this->gatt_backoff_.reset();
+#endif
 }
 
 bool BLEClient::gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t esp_gattc_if,
                                     esp_ble_gattc_cb_param_t *param) {
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // Bridge-initiated registrations bypass the base's REG_FOR_NOTIFY handling:
+  // its automatic CCCD write would double the node's own.
+  // Handle-keyed: mixed legacy/neutral subscriptions to one characteristic
+  // are unsupported during the migration window.
+  if (event == ESP_GATTC_REG_FOR_NOTIFY_EVT && esp_gattc_if == this->gattc_if_ &&
+      this->take_pending_gatt_reg_(param->reg_for_notify.handle)) {
+    if (this->pending_notify_regs_ > 0)
+      this->pending_notify_regs_--;
+    int err = param->reg_for_notify.status == ESP_GATT_OK ? 0 : param->reg_for_notify.status;
+    this->notify_state_to_gatt_nodes_(param->reg_for_notify.handle, true, err);
+    // A retiring last registration must still release the cache.
+    this->maybe_release_services_();
+    return true;
+  }
+#endif
   if (!BLEClientBase::gattc_event_handler(event, esp_gattc_if, param))
     return false;
 
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // Before the legacy fan-out so gatt nodes resolve before any trigger fires.
+  if (!this->gatt_nodes_.empty()) {
+    if (event == ESP_GATTC_SEARCH_CMPL_EVT) {
+      // A failed discovery tears the link down; the on_connect trigger must
+      // not fire into the teardown.
+      if (!this->handle_gatt_search_cmpl_(param->search_cmpl.status))
+        return true;
+    } else {
+      this->dispatch_gatt_event_(event, param);
+    }
+  }
+#endif
   for (auto *node : this->nodes_)
     node->gattc_event_handler(event, esp_gattc_if, param);
+  // The automations run after the nodes; on_connect runs before the release so it can still use the services
+  if (event == ESP_GATTC_SEARCH_CMPL_EVT)
+    this->connect_callbacks_.call();
+  this->maybe_release_services_();
+  if (event == ESP_GATTC_CLOSE_EVT)
+    this->disconnect_callbacks_.call();
+  return true;
+}
 
+void BLEClient::maybe_release_services_() {
   // The release frees the GATT cache that BLEClientBase's CCCD lookup still needs.
-  // The last REG_FOR_NOTIFY event clears the counter before node dispatch, so the release still runs here.
   if (!this->services_.empty() && !this->notify_registration_pending() && this->all_nodes_established_()) {
     this->release_services();
     ESP_LOGD(TAG, "All clients established, services released");
   }
-  return true;
 }
 
 void BLEClient::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {
@@ -65,10 +116,19 @@ void BLEClient::gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_p
 
   for (auto *node : this->nodes_)
     node->gap_event_handler(event, param);
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  if (event == ESP_GAP_BLE_AUTH_CMPL_EVT && this->check_addr(param->ble_security.auth_cmpl.bd_addr)) {
+    int status = param->ble_security.auth_cmpl.success ? 0 : param->ble_security.auth_cmpl.fail_reason;
+    for (auto *node : this->gatt_nodes_)
+      node->on_pairing_result(status);
+  }
+#endif
 }
 
 void BLEClient::set_state(espbt::ClientState state) {
   BLEClientBase::set_state(state);
+  // ESTABLISHED never flows through here; gatt nodes are promoted after the
+  // on_connected fan-out.
   for (auto &node : nodes_)
     node->node_state = state;
 }
@@ -83,6 +143,221 @@ bool BLEClient::all_nodes_established_() {
   return true;
 }
 
+#ifdef USE_BLE_CLIENT_GATT_NODES
+
+void BLEClient::register_gatt_node(BLEClientNode *node) {
+  // Parent before the capacity check so a dropped node still has a usable
+  // parent() (neutral-engine parity).
+  node->set_ble_client_parent(this);
+  if (this->gatt_nodes_.size() == ESPHOME_BLE_CLIENT_MAX_NODES) {
+    // push_back past capacity is a silent no-op; an undersized slot count
+    // must be loud at boot, not an unresolvable node at runtime.
+    ESP_LOGE(TAG, "[%s] Node capacity exceeded; node dropped", this->address_str());
+    this->status_set_error(LOG_STR("node capacity exceeded"));
+    return;
+  }
+  this->gatt_nodes_.push_back(node);
+  // nodes_ covers the shared state bookkeeping; gatt_nodes_ is the neutral
+  // fan-out subset.
+  this->register_ble_node(node);
+}
+
+int BLEClient::find_pending_gatt_reg_(uint16_t handle) const {
+  for (uint8_t i = 0; i < this->pending_gatt_reg_count_; i++) {
+    if (this->pending_gatt_regs_[i] == handle)
+      return i;
+  }
+  return -1;
+}
+
+bool BLEClient::take_pending_gatt_reg_(uint16_t handle) {
+  int i = this->find_pending_gatt_reg_(handle);
+  if (i < 0)
+    return false;
+  // No duplicates (notify_characteristic refuses a re-push); swap-with-last.
+  this->pending_gatt_regs_[i] = this->pending_gatt_regs_[--this->pending_gatt_reg_count_];
+  return true;
+}
+
+void BLEClient::notify_state_to_gatt_nodes_(uint16_t handle, bool enabled, int error) {
+  if (error != 0) {
+    ESP_LOGW(TAG, "[%s] Notify %s on handle 0x%04x failed, status=%d", this->address_str(),
+             enabled ? "enable" : "disable", handle, error);
+  }
+  for (auto *node : this->gatt_nodes_)
+    node->on_notify_state(handle, enabled, error);
+}
+
+void BLEClient::dispatch_gatt_event_(esp_gattc_cb_event_t event, esp_ble_gattc_cb_param_t *param) {
+  switch (event) {
+    case ESP_GATTC_READ_CHAR_EVT:
+    case ESP_GATTC_READ_DESCR_EVT: {
+      bool ok = param->read.status == ESP_GATT_OK;
+      if (!ok) {
+        // Breadcrumb even when no node claims the handle.
+        ESP_LOGD(TAG, "[%s] Read on handle 0x%04x completed with status %d", this->address_str(), param->read.handle,
+                 param->read.status);
+      }
+      for (auto *node : this->gatt_nodes_) {
+        node->on_read_result(param->read.handle, ok ? param->read.value : nullptr, ok ? param->read.value_len : 0,
+                             ok ? 0 : param->read.status);
+      }
+      break;
+    }
+    case ESP_GATTC_WRITE_CHAR_EVT:
+    case ESP_GATTC_WRITE_DESCR_EVT:
+      if (param->write.status != ESP_GATT_OK) {
+        // Breadcrumb even when no node claims the handle.
+        ESP_LOGD(TAG, "[%s] Write on handle 0x%04x completed with status %d", this->address_str(), param->write.handle,
+                 param->write.status);
+      }
+      for (auto *node : this->gatt_nodes_) {
+        node->on_write_result(param->write.handle, param->write.status == ESP_GATT_OK ? 0 : param->write.status);
+      }
+      break;
+    case ESP_GATTC_NOTIFY_EVT:
+      for (auto *node : this->gatt_nodes_) {
+        node->on_notify(param->notify.handle, param->notify.value, param->notify.value_len);
+      }
+      break;
+    case ESP_GATTC_UNREG_FOR_NOTIFY_EVT:
+      // The base does no CCCD work for unregister; no interception needed.
+      this->notify_state_to_gatt_nodes_(
+          param->unreg_for_notify.handle, false,
+          param->unreg_for_notify.status == ESP_GATT_OK ? 0 : param->unreg_for_notify.status);
+      break;
+    default:
+      break;
+  }
+}
+
+bool BLEClient::handle_gatt_search_cmpl_(esp_gatt_status_t status) {
+  // The base ignores the search status; the neutral contract must not.
+  uint16_t service_total = 0;
+  bool counted = status == ESP_GATT_OK && bluetooth_connection::BluedroidServiceTable::count_services(
+                                              this->gattc_if_, this->conn_id_, &service_total);
+  if (!counted || service_total == 0) {
+    // A failed search poisons the whole discovery, legacy nodes included.
+    ESP_LOGW(TAG, "[%s] Discovery failed (status=%d, services=%u)", this->address_str(), status, service_total);
+    this->gatt_backoff_.register_failure(this->address_str());
+    this->disconnect();
+    return false;
+  }
+  // Stack-owned; nodes copy their handles during on_connected().
+  bluetooth_connection::BluedroidServiceTable table;
+  if (!table.build(this->gattc_if_, this->conn_id_, service_total, this->connection_index_)) {
+    if (!this->has_legacy_nodes_()) {
+      ESP_LOGW(TAG, "[%s] Service table build failed; treating as failed discovery", this->address_str());
+      this->gatt_backoff_.register_failure(this->address_str());
+      this->disconnect();
+      return false;
+    }
+    // Only the table build failed; legacy nodes read the base's services_
+    // and keep the link. Gatt nodes catch the next connection.
+    ESP_LOGW(TAG, "[%s] Service table build failed; gatt nodes skip this connection", this->address_str());
+    this->status_set_warning(LOG_STR("gatt nodes inactive: service table build failed"));
+    // A peer whose database never walks must not retry the build at
+    // advertisement cadence once the legacy nodes drop the link.
+    this->gatt_backoff_.register_failure(this->address_str());
+  } else {
+    this->gatt_connected_ = true;
+    auto view = table.view();
+    for (auto *node : this->gatt_nodes_) {
+      node->on_connected(view);
+      if (this->state() != espbt::ClientState::ESTABLISHED) {
+        // The node tore the link down; remaining nodes get on_disconnected
+        // with no preceding on_connected, so leave a trace of why.
+        ESP_LOGW(TAG, "[%s] A node aborted the connection during setup", this->address_str());
+        return false;
+      }
+    }
+    this->gatt_backoff_.reset();
+    this->status_clear_warning();
+  }
+  // Promote so the legacy release condition can fire.
+  for (auto *node : this->gatt_nodes_)
+    node->node_state = espbt::ClientState::ESTABLISHED;
+  return true;
+}
+
+void BLEClient::on_disconnect_complete(esp_err_t reason) {
+  this->pending_gatt_reg_count_ = 0;
+  if (!this->gatt_connected_)
+    return;  // Never-established links report nothing (neutral parity).
+  this->gatt_connected_ = false;
+  for (auto *node : this->gatt_nodes_)
+    node->on_disconnected();
+}
+
+int BLEClient::check_and_log_error_(const char *operation, esp_err_t err) {
+  if (err != ESP_OK)
+    this->log_gattc_warning_(operation, err);
+  return err;
+}
+
+int BLEClient::write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response) {
+  if (this->conn_id_ == UNSET_CONN_ID)
+    return ble_device_base::GATT_ERR_NOT_CONNECTED;
+  return this->check_and_log_error_(
+      "esp_ble_gattc_write_char",
+      esp_ble_gattc_write_char(this->gattc_if_, this->conn_id_, handle, len, const_cast<uint8_t *>(data),
+                               response ? ESP_GATT_WRITE_TYPE_RSP : ESP_GATT_WRITE_TYPE_NO_RSP,
+                               ESP_GATT_AUTH_REQ_NONE));
+}
+
+int BLEClient::read_characteristic(uint16_t handle) {
+  if (this->conn_id_ == UNSET_CONN_ID)
+    return ble_device_base::GATT_ERR_NOT_CONNECTED;
+  return this->check_and_log_error_("esp_ble_gattc_read_char", esp_ble_gattc_read_char(this->gattc_if_, this->conn_id_,
+                                                                                       handle, ESP_GATT_AUTH_REQ_NONE));
+}
+
+int BLEClient::read_descriptor(uint16_t handle) {
+  if (this->conn_id_ == UNSET_CONN_ID)
+    return ble_device_base::GATT_ERR_NOT_CONNECTED;
+  return this->check_and_log_error_(
+      "esp_ble_gattc_read_char_descr",
+      esp_ble_gattc_read_char_descr(this->gattc_if_, this->conn_id_, handle, ESP_GATT_AUTH_REQ_NONE));
+}
+
+int BLEClient::write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len) {
+  if (this->conn_id_ == UNSET_CONN_ID)
+    return ble_device_base::GATT_ERR_NOT_CONNECTED;
+  return this->check_and_log_error_(
+      "esp_ble_gattc_write_char_descr",
+      esp_ble_gattc_write_char_descr(this->gattc_if_, this->conn_id_, handle, len, const_cast<uint8_t *>(data),
+                                     ESP_GATT_WRITE_TYPE_RSP, ESP_GATT_AUTH_REQ_NONE));
+}
+
+int BLEClient::notify_characteristic(uint16_t handle, bool enable) {
+  if (this->conn_id_ == UNSET_CONN_ID)
+    return ble_device_base::GATT_ERR_NOT_CONNECTED;
+  if (enable) {
+    if (this->find_pending_gatt_reg_(handle) >= 0) {
+      // ESP_OK: the in-flight registration's completion fans out to all nodes.
+      ESP_LOGW(TAG, "[%s] Notify registration already pending for handle 0x%04x", this->address_str(), handle);
+      return ESP_OK;
+    }
+    if (this->pending_gatt_reg_count_ == MAX_PENDING_NOTIFY_REGS) {
+      // An untracked registration would let the base's auto-CCCD through.
+      ESP_LOGE(TAG, "[%s] Too many pending notify registrations", this->address_str());
+      return ble_device_base::GATT_ERR_NO_MEMORY;
+    }
+    // The base helper's pending count holds the service-release until the
+    // (intercepted) completion.
+    esp_err_t err = this->register_for_notify(handle);
+    if (err == ESP_OK)
+      this->pending_gatt_regs_[this->pending_gatt_reg_count_++] = handle;
+    return this->check_and_log_error_("esp_ble_gattc_register_for_notify", err);
+  }
+  return this->check_and_log_error_("esp_ble_gattc_unregister_for_notify",
+                                    esp_ble_gattc_unregister_for_notify(this->gattc_if_, this->remote_bda_, handle));
+}
+
+int BLEClient::unpair() { return bluetooth_connection::unpair_device(this->get_address()); }
+
+#endif  // USE_BLE_CLIENT_GATT_NODES
+
 }  // namespace esphome::ble_client
 
 #endif

esphome/components/ble_client/ble_client.h

@@ -1,18 +1,20 @@
 #pragma once
 
+#include "esphome/core/defines.h"
+
+#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
+
+#include "ble_client_node.h"
+#include "connect_backoff.h"
 #include "esphome/components/esp32_ble_client/ble_client_base.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
 
-#ifdef USE_ESP32
-
 #include <esp_bt_defs.h>
 #include <esp_gap_ble_api.h>
 #include <esp_gatt_common_api.h>
 #include <esp_gattc_api.h>
-#include <array>
-#include <string>
 #include <vector>
 
 namespace esphome::ble_client {
@@ -21,34 +23,6 @@ namespace espbt = esphome::esp32_ble_tracker;
 
 using namespace esp32_ble_client;
 
-class BLEClient;
-
-class BLEClientNode {
- public:
-  virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
-                                   esp_ble_gattc_cb_param_t *param) {};
-  virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {}
-  virtual void loop() {}
-  void set_address(uint64_t address) { address_ = address; }
-  espbt::ESPBTClient *client;
-  // This should be transitioned to Established once the node no longer needs
-  // the services/descriptors/characteristics of the parent client. This will
-  // allow some memory to be freed.
-  // The parent frees the peer's GATT cache once every node reports Established.
-  // Never report Established while an operation that reads that cache is outstanding.
-  // - esp_ble_gattc_register_for_notify() completes asynchronously.
-  // - Register from ESP_GATTC_SEARCH_CMPL_EVT, then set this from ESP_GATTC_REG_FOR_NOTIFY_EVT.
-  // - BLEClientBase::register_for_notify() holds the release until the registration completes.
-  espbt::ClientState node_state;
-
-  BLEClient *parent() { return this->parent_; }
-  void set_ble_client_parent(BLEClient *parent) { this->parent_ = parent; }
-
- protected:
-  BLEClient *parent_;
-  uint64_t address_;
-};
-
 class BLEClient final : public BLEClientBase {
  public:
   void setup() override;
@@ -64,19 +38,75 @@ class BLEClient final : public BLEClientBase {
   void set_enabled(bool enabled);
 
   void register_ble_node(BLEClientNode *node) {
-    node->client = this;
     node->set_ble_client_parent(this);
     this->nodes_.push_back(node);
   }
 
+  // on_connect fires once discovery completes; on_disconnect on CLOSE_EVT, so only after a completed open
+  template<typename F> void add_on_connect_callback(F &&callback) {
+    this->connect_callbacks_.add(std::forward<F>(callback));
+  }
+  template<typename F> void add_on_disconnect_callback(F &&callback) {
+    this->disconnect_callbacks_.add(std::forward<F>(callback));
+  }
+
   bool enabled;
 
   void set_state(espbt::ClientState state) override;
 
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // ---- the neutral node surface (signatures shared with the non-esp32
+  // engine, so nodes on the neutral interface compile against either) ----
+  void register_gatt_node(BLEClientNode *node);
+
+  bool idle() const { return this->state() == espbt::ClientState::IDLE; }
+
+  int write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response);
+  int read_characteristic(uint16_t handle);
+  int read_descriptor(uint16_t handle);
+  int write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len);
+  /// Local registration only; per the neutral contract the CCCD write is the
+  /// node's job (the legacy auto-CCCD is suppressed for these handles).
+  int notify_characteristic(uint16_t handle, bool enable);
+  // pair() comes from BLEClientBase, matching the neutral engine's.
+  int unpair();
+#endif
+
  protected:
   bool all_nodes_established_();
+  void maybe_release_services_();
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  int check_and_log_error_(const char *operation, esp_err_t err);
+  int find_pending_gatt_reg_(uint16_t handle) const;
+  void notify_state_to_gatt_nodes_(uint16_t handle, bool enabled, int error);
+  void dispatch_gatt_event_(esp_gattc_cb_event_t event, esp_ble_gattc_cb_param_t *param);
+  // False = failed discovery: the link comes down and the caller suppresses
+  // the legacy fan-out.
+  bool handle_gatt_search_cmpl_(esp_gatt_status_t status);
+  bool take_pending_gatt_reg_(uint16_t handle);
+  void on_disconnect_complete(esp_err_t reason) override;
+#endif
 
   std::vector<BLEClientNode *> nodes_;
+  LazyCallbackManager<void()> connect_callbacks_;
+  LazyCallbackManager<void()> disconnect_callbacks_;
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // Raise if a migrated node needs more concurrent registrations.
+  static constexpr uint8_t MAX_PENDING_NOTIFY_REGS = 4;
+
+  // Nodes on the neutral surface; fed the translated callbacks and
+  // auto-established after the on_connected fan-out. Every gatt node is
+  // also in nodes_ (registration pushes into both).
+  StaticVector<BLEClientNode *, ESPHOME_BLE_CLIENT_MAX_NODES> gatt_nodes_;
+  bool has_legacy_nodes_() const { return this->nodes_.size() > this->gatt_nodes_.size(); }
+  // Reconnect backoff after materializer failures.
+  ConnectBackoff gatt_backoff_;
+  // Bridge-initiated notify registrations awaiting REG_FOR_NOTIFY_EVT.
+  uint16_t pending_gatt_regs_[MAX_PENDING_NOTIFY_REGS];
+  uint8_t pending_gatt_reg_count_{0};
+  // on_connected fan-out started; on_disconnected is owed at teardown.
+  bool gatt_connected_{false};
+#endif
 };
 
 }  // namespace esphome::ble_client

esphome/components/ble_client/ble_client_gatt.cpp

@@ -0,0 +1,261 @@
+#include "ble_client_gatt.h"
+
+#if defined(USE_BLE_CLIENT_GATT_NODES) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
+
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+namespace esphome::ble_client {
+
+ESPHOME_LOG_TAG(TAG, "ble_client");
+
+void BLEClient::register_ble_node(BLEClientNode *node) {
+  node->set_ble_client_parent(this);
+  if (this->nodes_.size() == ESPHOME_BLE_CLIENT_MAX_NODES) {
+    // push_back past capacity is a silent no-op; an undersized slot count
+    // must be loud at boot, not an unresolvable node at runtime.
+    ESP_LOGE(TAG, "[%s] Node capacity exceeded; node dropped", this->address_str_);
+    this->status_set_error(LOG_STR("node capacity exceeded"));
+    return;
+  }
+  this->nodes_.push_back(node);
+}
+
+void BLEClient::set_address(uint64_t address) {
+  this->address_ = address;
+  uint8_t mac[6];
+  ble_device_base::uint64_to_mac_msb_first(address, mac);
+  format_mac_addr_upper(mac, this->address_str_);
+}
+
+void BLEClient::set_enabled(bool enabled) {
+  if (enabled == this->enabled)
+    return;
+  ESP_LOGI(TAG, "[%s] %s", this->address_str_, enabled ? "Enabled" : "Disabled");
+  this->enabled = enabled;
+  if (!enabled) {
+    this->disconnect();
+    return;
+  }
+  // A re-enable clears the backoff; the next sighting connects (legacy
+  // parity: enabling does not itself connect).
+  this->backoff_.reset();
+}
+
+bool BLEClient::parse_device(const ble_device_base::ESPBTDevice &device) {
+  if (device.address_uint64() != this->address_)
+    return false;
+  // The sighting is the source of truth for the address type.
+  this->address_type_ = device.get_address_type();
+  this->address_type_known_ = true;
+  if (!this->enabled || !this->auto_connect_ || this->state_ != State::IDLE)
+    return true;
+  if (this->backoff_.holding_off())
+    return true;
+  this->attempt_connect_();
+  return true;
+}
+
+void BLEClient::connect() {
+  if (this->state_ != State::IDLE) {
+    ESP_LOGD(TAG, "[%s] Connect requested while busy, ignoring", this->address_str_);
+    return;
+  }
+  // An absent peer can inhibit scanning for the backend's full connect
+  // timeout, so this is worth a breadcrumb - but it is a supported action.
+  ESP_LOGI(TAG, "[%s] Connecting on request", this->address_str_);
+  if (!this->address_type_known_) {
+    // Legacy parity: without a sighting the address type defaults to
+    // public, which never matches a random-static peer.
+    ESP_LOGW(TAG, "[%s] No sighting yet; assuming a public address type", this->address_str_);
+  }
+  this->attempt_connect_();
+}
+
+void BLEClient::attempt_connect_() {
+  int err = this->backend_->connect(this->address_, this->address_type_);
+  if (err != 0) {
+    // A refused connect never produces a callback: stay idle, charge the
+    // backoff, and resolve any waiting connect action through the failure
+    // path so its chain terminates.
+    ESP_LOGW(TAG, "[%s] Connect refused, err=%d", this->address_str_, err);
+    this->backoff_.register_failure(this->address_str_);
+    this->defer([this]() { this->connect_failed_callbacks_.call(); });
+    return;
+  }
+  ESP_LOGD(TAG, "[%s] Connecting", this->address_str_);
+  this->state_ = State::CONNECTING;
+}
+
+void BLEClient::disconnect() {
+  if (this->state_ == State::IDLE) {
+    ESP_LOGD(TAG, "[%s] Disconnect requested while idle, ignoring", this->address_str_);
+    return;
+  }
+  if (this->cancel_requested_) {
+    // The accepted teardown still reports; a refused second gatt_disconnect()
+    // would settle the link twice (phantom connect failure, backoff charge).
+    ESP_LOGD(TAG, "[%s] Disconnect already in flight, ignoring", this->address_str_);
+    return;
+  }
+  // A deliberate teardown's failure report must not feed the backoff.
+  this->cancel_requested_ = true;
+  int err = this->backend_->gatt_disconnect();
+  if (err != 0) {
+    // Refused synchronously: backend and client disagree about the link
+    // state. Warn, then settle through the deliberate-cancel path.
+    ESP_LOGW(TAG, "[%s] Disconnect refused, err=%d; settling locally", this->address_str_, err);
+    this->on_connection_state(false, 0, err);
+  }
+}
+
+void BLEClient::on_connection_state(bool connected, uint16_t mtu, int error) {
+  if (connected) {
+    this->state_ = State::DISCOVERING;
+    int discover_err = this->backend_->discover_services();
+    if (discover_err != 0) {
+      // Synchronous refusal: no discovery completion will follow.
+      ESP_LOGW(TAG, "[%s] Service discovery refused, err=%d", this->address_str_, discover_err);
+      this->backoff_.register_failure(this->address_str_);
+      // Deliberate teardown: its report must not charge the backoff again.
+      this->disconnect();
+    }
+    return;
+  }
+  bool was_connected = this->state_ == State::CONNECTED;
+  bool cancelled = this->cancel_requested_;
+  this->cancel_requested_ = false;
+  this->state_ = State::IDLE;
+  if (was_connected) {
+    ESP_LOGI(TAG, "[%s] Disconnected, status=%d", this->address_str_, error);
+    for (auto *node : this->nodes_) {
+      node->on_disconnected();
+    }
+    // Continuations leave the backend's event-drain stack first.
+    this->defer([this]() { this->disconnect_callbacks_.call(); });
+  } else {
+    if (cancelled) {
+      // status carries the refusal code when the teardown settled
+      // synchronously; 0 on a backend-completed cancel.
+      ESP_LOGD(TAG, "[%s] Connect attempt cancelled, status=%d", this->address_str_, error);
+    } else {
+      ESP_LOGW(TAG, "[%s] Connect failed, status=%d", this->address_str_, error);
+      this->backoff_.register_failure(this->address_str_);
+    }
+    this->defer([this]() { this->connect_failed_callbacks_.call(); });
+  }
+}
+
+void BLEClient::on_service_discovery_done(int error) {
+  if (this->state_ != State::DISCOVERING || this->cancel_requested_) {
+    // Raced a teardown; the terminal report settles the link.
+    ESP_LOGD(TAG, "[%s] Discovery completed during teardown, ignoring", this->address_str_);
+    this->backend_->release_services();
+    return;
+  }
+  if (error != 0) {
+    ESP_LOGW(TAG, "[%s] Service discovery failed, status=%d", this->address_str_, error);
+    this->backoff_.register_failure(this->address_str_);
+    // The teardown is deliberate: do not charge the backoff again for its
+    // connection report.
+    this->disconnect();
+    return;
+  }
+  ble_device_base::GattServiceTable table{};
+  if (!this->nodes_.empty()) {
+    // Materialize only when a node will read it: a client with no nodes
+    // would pay the build/free cycle on every (re)connect for nothing.
+    table = this->backend_->get_service_table();
+    if (table.service_count == 0) {
+      // A failed materialization is indistinguishable from a service-less
+      // peer, and a real GATT peer always exposes at least GAP/GATT: fail
+      // the discovery before CONNECTED so the teardown resolves through
+      // connect_failed, never a spurious on_disconnect.
+      ESP_LOGW(TAG, "[%s] Service table is empty; treating as failed discovery", this->address_str_);
+      this->backend_->release_services();
+      this->backoff_.register_failure(this->address_str_);
+      this->disconnect();
+      return;
+    }
+  }
+  // CONNECTED before the fan-out so nodes may consult connected() from
+  // their own on_connected().
+  this->state_ = State::CONNECTED;
+  for (auto *node : this->nodes_) {
+    node->on_connected(table);
+    if (this->state_ != State::CONNECTED || this->cancel_requested_) {
+      // A node tore the link down mid-fan-out: on_disconnect fires with no
+      // preceding on_connect, so leave a trace of why.
+      ESP_LOGW(TAG, "[%s] A node aborted the connection during setup", this->address_str_);
+      this->backend_->release_services();
+      return;
+    }
+  }
+  this->backend_->release_services();
+  this->backoff_.reset();
+  ESP_LOGI(TAG, "[%s] Connected", this->address_str_);
+  this->defer([this]() { this->connect_callbacks_.call(); });
+}
+
+void BLEClient::on_write_result(uint16_t handle, int error) {
+  if (error != 0) {
+    // Breadcrumb even when no node claims the handle.
+    ESP_LOGD(TAG, "[%s] Write on handle 0x%04x completed with status %d", this->address_str_, handle, error);
+  }
+  for (auto *node : this->nodes_) {
+    node->on_write_result(handle, error);
+  }
+}
+
+void BLEClient::on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) {
+  if (error != 0) {
+    // Breadcrumb even when no node claims the handle.
+    ESP_LOGD(TAG, "[%s] Read on handle 0x%04x completed with status %d", this->address_str_, handle, error);
+  }
+  for (auto *node : this->nodes_) {
+    node->on_read_result(handle, data, len, error);
+  }
+}
+
+void BLEClient::on_notify_data(uint16_t handle, const uint8_t *data, uint16_t len) {
+  // Every node sees every notification and filters by handle (legacy parity).
+  for (auto *node : this->nodes_) {
+    node->on_notify(handle, data, len);
+  }
+}
+
+void BLEClient::on_notify_state(uint16_t handle, bool enabled, int error) {
+  if (error != 0) {
+    ESP_LOGW(TAG, "[%s] Notify %s on handle 0x%04x failed, status=%d", this->address_str_,
+             enabled ? "enable" : "disable", handle, error);
+  }
+  for (auto *node : this->nodes_) {
+    node->on_notify_state(handle, enabled, error);
+  }
+}
+
+void BLEClient::on_pairing_result(int status) {
+  if (status != 0) {
+    ESP_LOGW(TAG, "[%s] Pairing failed, status=%d", this->address_str_, status);
+  } else {
+    ESP_LOGI(TAG, "[%s] Paired", this->address_str_);
+  }
+  for (auto *node : this->nodes_) {
+    node->on_pairing_result(status);
+  }
+}
+
+void BLEClient::dump_config() {
+  ESP_LOGCONFIG(TAG,
+                "BLE Client:\n"
+                "  Address: %s\n"
+                "  Auto connect: %s",
+                this->address_str_, YESNO(this->auto_connect_));
+  if (this->enabled && this->state_ == State::IDLE) {
+    ESP_LOGCONFIG(TAG, "  Waiting for an advertisement from the device");
+  }
+}
+
+}  // namespace esphome::ble_client
+
+#endif  // USE_BLE_CLIENT_GATT_NODES && !USE_BLE_CLIENT_LEGACY_ENGINE

esphome/components/ble_client/ble_client_gatt.h

@@ -0,0 +1,151 @@
+// Platform-neutral ble_client engine on the ble_device_base GATT contract.
+//
+// Compiled on every platform with a GATT backend except esp32, which keeps
+// the legacy BLEClientBase engine (ble_client.h) until its raw-gattc node
+// family migrates - the exclusive gates make the same class names resolve to
+// exactly one definition per build, so codegen is shared.
+//
+// Connects are sighting-gated like the legacy engine: the client is a parsed
+// advertisement listener, captures the peer's address type from the sighting,
+// and asks the backend to connect only when enabled and idle.
+
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#if defined(USE_BLE_CLIENT_GATT_NODES) && !defined(USE_BLE_CLIENT_LEGACY_ENGINE)
+
+#include "ble_client_node.h"
+#include "connect_backoff.h"
+#include "esphome/components/ble_device_base/ble_device.h"
+#include "esphome/components/ble_device_base/ble_gatt_client.h"
+#include "esphome/components/bluetooth_connection/bluetooth_connection.h"
+#include "esphome/components/bluetooth_connection/bluetooth_connection_gatt_backend.h"
+#include "esphome/core/component.h"
+#include "esphome/core/helpers.h"
+
+#include <cstdint>
+#include <functional>
+
+namespace esphome::ble_client {
+
+class BLEClient : public Component,
+                  public ble_device_base::ESPBTDeviceListener,
+                  public ble_device_base::GattClientListener {
+ public:
+  void dump_config() override;
+
+  // Public field for legacy parity (the switch platform republishes it).
+  bool enabled{true};
+
+  void set_backend(ble_device_base::BLEGattConnection *backend) {
+    this->backend_ = backend;
+    backend->set_listener(this);
+  }
+  void set_address(uint64_t address);
+  void set_auto_connect(bool auto_connect) { this->auto_connect_ = auto_connect; }
+  void set_enabled(bool enabled);
+  const char *address_str() const { return this->address_str_; }
+
+  void register_ble_node(BLEClientNode *node);
+  // One registration spelling shared with the esp32 engine's bridge.
+  void register_gatt_node(BLEClientNode *node) { this->register_ble_node(node); }
+
+  // An accepted teardown already owns the link: the pending report cannot be
+  // a connect. state_ stays put so that report still fires on_disconnect.
+  bool connected() const { return this->state_ == State::CONNECTED && !this->cancel_requested_; }
+  bool idle() const { return this->state_ == State::IDLE; }
+
+  /// Action-initiated connect (no sighting needed; uses the last captured
+  /// address type, public until a sighting arrives). No-op unless idle.
+  void connect();
+  void disconnect();
+
+  /// Legacy-named deferral used by the automation twins: neutral listener
+  /// callbacks run inside the backend's event drain, so automation chain
+  /// continuations must leave that stack first.
+  void run_later(std::function<void()> &&f) { this->defer(std::move(f)); }  // NOLINT
+
+  // Backend ops for nodes and actions - the frozen node-facing surface.
+  // Only write_characteristic has an in-tree caller; subscribing means
+  // notify_characteristic plus a CCCD write_descriptor (the caller's job
+  // per the contract).
+  int write_characteristic(uint16_t handle, const uint8_t *data, uint16_t len, bool response) {
+    return this->backend_->write_characteristic(handle, data, len, response);
+  }
+  int read_characteristic(uint16_t handle) { return this->backend_->read_characteristic(handle); }
+  int read_descriptor(uint16_t handle) { return this->backend_->read_descriptor(handle); }
+  int write_descriptor(uint16_t handle, const uint8_t *data, uint16_t len) {
+    return this->backend_->write_descriptor(handle, data, len);
+  }
+  int notify_characteristic(uint16_t handle, bool enable) {
+    return this->backend_->notify_characteristic(handle, enable);
+  }
+  int pair() { return this->backend_->pair(); }
+  int unpair() { return bluetooth_connection::unpair_device(this->address_); }
+
+  // Automation callback registration.
+  template<typename F> void add_on_connect_callback(F &&callback) {
+    this->connect_callbacks_.add(std::forward<F>(callback));
+  }
+  template<typename F> void add_on_disconnect_callback(F &&callback) {
+    this->disconnect_callbacks_.add(std::forward<F>(callback));
+  }
+  // Fired when a connect attempt dies before being established; the user
+  // on_disconnect trigger deliberately does NOT fire here (legacy parity).
+  template<typename F> void add_on_connect_failed_callback(F &&callback) {
+    this->connect_failed_callbacks_.add(std::forward<F>(callback));
+  }
+
+  // ---- ble_device_base::ESPBTDeviceListener ----
+  bool parse_device(const ble_device_base::ESPBTDevice &device) override;
+
+  // ---- ble_device_base::GattClientListener ----
+  void on_connection_state(bool connected, uint16_t mtu, int error) override;
+  void on_service_discovery_done(int error) override;
+  void on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) override;
+  void on_write_result(uint16_t handle, int error) override;
+  void on_notify_data(uint16_t handle, const uint8_t *data, uint16_t len) override;
+  void on_notify_state(uint16_t handle, bool enabled, int error) override;
+  void on_pairing_result(int status) override;
+
+ protected:
+  enum class State : uint8_t { IDLE, CONNECTING, DISCOVERING, CONNECTED };
+
+  void attempt_connect_();
+
+  // Group 1: pointers / containers
+  ble_device_base::BLEGattConnection *backend_{nullptr};
+  // Codegen-sized (ESPHOME_BLE_CLIENT_MAX_NODES); filled during setup.
+  StaticVector<BLEClientNode *, ESPHOME_BLE_CLIENT_MAX_NODES> nodes_;
+
+  // Group 2: 8-byte types
+  uint64_t address_{0};
+
+  // Group 3: callback managers (pointer-sized when empty)
+  LazyCallbackManager<void()> connect_callbacks_;
+  LazyCallbackManager<void()> disconnect_callbacks_;
+  LazyCallbackManager<void()> connect_failed_callbacks_;
+
+  // Group 4: 4-byte types
+  // Backoff so an undiscoverable database or a dead peer cannot produce a
+  // battery-draining connect loop.
+  ConnectBackoff backoff_;
+
+  // Group 5: arrays
+  char address_str_[MAC_ADDRESS_PRETTY_BUFFER_SIZE]{};
+
+  // Group 6: 1-byte types
+  State state_{State::IDLE};
+  uint8_t address_type_{0};  // BLE_ADDR_TYPE_*, captured from the sighting
+  // Distinguishes a captured public type from the never-sighted default.
+  bool address_type_known_{false};
+  bool auto_connect_{true};
+  // A user-initiated teardown in flight; its failure report is not a
+  // connect failure and must not feed the backoff.
+  bool cancel_requested_{false};
+};
+
+}  // namespace esphome::ble_client
+
+#endif  // USE_BLE_CLIENT_GATT_NODES && !USE_BLE_CLIENT_LEGACY_ENGINE

esphome/components/ble_client/ble_client_node.h

@@ -0,0 +1,68 @@
+// The single BLEClientNode both ble_client engines share. The neutral
+// callback surface is the one interface node components build on; the raw
+// esp32 surface below it remains for components that have not migrated yet.
+
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_BLE_GATT_CLIENT
+#include "esphome/components/ble_device_base/ble_gatt_client.h"
+#endif
+#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
+#include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
+
+#include <esp_gap_ble_api.h>
+#include <esp_gattc_api.h>
+#endif
+
+#include <cstdint>
+
+namespace esphome::ble_client {
+
+class BLEClient;
+
+class BLEClientNode {
+ public:
+#ifdef USE_BLE_CLIENT_GATT_NODES
+  // Neutral surface, delivered by both engines. The table is borrowed: copy
+  // handles during on_connected(). All nodes see all completions; filter by
+  // handle.
+  // A node that disconnects from inside on_connected() aborts the fan-out;
+  // the user's on_disconnect may then fire without a preceding on_connect.
+  virtual void on_connected(const ble_device_base::GattServiceTable &table) {}
+  virtual void on_disconnected() {}
+  virtual void on_notify(uint16_t handle, const uint8_t *data, uint16_t len) {}
+  // One in-flight registration per handle; its completion fans out to every
+  // node, so a refused duplicate request still sees on_notify_state.
+  virtual void on_notify_state(uint16_t handle, bool enabled, int error) {}
+  virtual void on_read_result(uint16_t handle, const uint8_t *data, uint16_t len, int error) {}
+  virtual void on_write_result(uint16_t handle, int error) {}
+  virtual void on_pairing_result(int status) {}
+#endif
+#ifdef USE_BLE_CLIENT_LEGACY_ENGINE
+  // Legacy raw surface; components overriding these need the legacy engine
+  // until migrated to the neutral surface above.
+  virtual void gattc_event_handler(esp_gattc_cb_event_t event, esp_gatt_if_t gattc_if,
+                                   esp_ble_gattc_cb_param_t *param) {}
+  virtual void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) {}
+  virtual void loop() {}
+  // This should be transitioned to Established once the node no longer needs
+  // the services/descriptors/characteristics of the parent client. This will
+  // allow some memory to be freed.
+  // The parent frees the peer's GATT cache once every node reports Established.
+  // Never report Established while an operation that reads that cache is outstanding.
+  // - esp_ble_gattc_register_for_notify() completes asynchronously.
+  // - Register from ESP_GATTC_SEARCH_CMPL_EVT, then set this from ESP_GATTC_REG_FOR_NOTIFY_EVT.
+  // - BLEClientBase::register_for_notify() holds the release until the registration completes.
+  esp32_ble_tracker::ClientState node_state;
+#endif
+
+  BLEClient *parent() const { return this->parent_; }
+  void set_ble_client_parent(BLEClient *parent) { this->parent_ = parent; }
+
+ protected:
+  BLEClient *parent_{nullptr};
+};
+
+}  // namespace esphome::ble_client

esphome/components/ble_client/ble_write_action.h

@@ -0,0 +1,172 @@
+// The ble_client.ble_write action: a node on the platform-neutral interface,
+// so one implementation serves both engines (the esp32 bridge and the
+// neutral engine).
+
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_BLE_CLIENT_GATT_NODES
+
+#include <tuple>
+#include <vector>
+
+// One of the two engine headers resolves per build.
+#include "ble_client.h"
+#include "ble_client_gatt.h"
+#include "ble_client_node.h"
+#include "esphome/core/automation.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome::ble_client {
+
+static const char *const BLE_WRITE_TAG = "ble_client.automation";
+
+// Maximum bytes to log in hex format for BLE writes (many logging buffers are 256 chars)
+static constexpr size_t BLE_WRITE_MAX_LOG_BYTES = 64;
+
+template<typename... Ts> class BLEClientWriteAction final : public Action<Ts...>, public BLEClientNode {
+ public:
+  BLEClientWriteAction(BLEClient *ble_client) {
+    ble_client->register_gatt_node(this);
+    ble_client_ = ble_client;
+  }
+
+  void set_service_uuid16(uint16_t uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_uint16(uuid); }
+  void set_service_uuid32(uint32_t uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_uint32(uuid); }
+  void set_service_uuid128(uint8_t *uuid) { this->service_uuid_ = ble_device_base::ESPBTUUID::from_raw(uuid); }
+
+  void set_char_uuid16(uint16_t uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_uint16(uuid); }
+  void set_char_uuid32(uint32_t uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_uint32(uuid); }
+  void set_char_uuid128(uint8_t *uuid) { this->char_uuid_ = ble_device_base::ESPBTUUID::from_raw(uuid); }
+
+  void set_value_template(std::vector<uint8_t> (*func)(Ts...)) {
+    this->value_.func = func;
+    this->len_ = -1;  // Sentinel value indicates template mode
+  }
+
+  // Store pointer to static data in flash (no RAM copy)
+  void set_value_simple(const uint8_t *data, size_t len) {
+    this->value_.data = data;
+    this->len_ = len;  // Length >= 0 indicates static mode
+  }
+
+  void play(const Ts &...x) override {}
+
+  void play_complex(const Ts &...x) override {
+    this->num_running_++;
+    this->var_ = std::make_tuple(x...);
+
+    bool result;
+    if (this->len_ >= 0) {
+      result = this->write(this->value_.data, this->len_);
+    } else {
+      std::vector<uint8_t> value = this->value_.func(x...);
+      result = this->write(value.data(), value.size());
+    }
+
+    // on write failure, continue the automation chain rather than stopping so
+    // that e.g. disconnect can work.
+    if (!result)
+      this->play_next_(x...);
+  }
+
+  // Initiate the write; the completion arrives in on_write_result. The
+  // response-less path can complete synchronously inside the call, so the
+  // handle is armed before the backend is touched.
+  bool write(const uint8_t *data, size_t len) {
+    if (!this->ble_client_->connected()) {
+      esph_log_w(BLE_WRITE_TAG, "Cannot write to BLE characteristic - not connected");
+      return false;
+    }
+    if (!this->resolved_) {
+      esph_log_w(BLE_WRITE_TAG, "Cannot write to BLE characteristic - characteristic was not resolved");
+      return false;
+    }
+#if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERY_VERBOSE
+    char hex_buf[format_hex_pretty_size(BLE_WRITE_MAX_LOG_BYTES)];
+    esph_log_vv(BLE_WRITE_TAG, "Will write %d bytes: %s", len, format_hex_pretty_to(hex_buf, data, len));
+#endif
+    int err = this->ble_client_->write_characteristic(this->char_handle_, data, len, this->write_response_);
+    if (err != 0) {
+      esph_log_e(BLE_WRITE_TAG, "Error writing to characteristic: %d!", err);
+      return false;
+    }
+    return true;
+  }
+
+  void on_connected(const ble_device_base::GattServiceTable &table) override {
+    // Resolution comes from this table only; a re-discovery must not keep a
+    // stale handle.
+    this->resolved_ = false;
+    this->char_handle_ = 0;
+    const auto *service = ble_device_base::find_service(table, this->service_uuid_);
+    const auto *chr =
+        service == nullptr ? nullptr : ble_device_base::find_characteristic(table, *service, this->char_uuid_);
+    if (chr == nullptr) {
+      char char_buf[ble_device_base::UUID_STR_LEN];
+      char service_buf[ble_device_base::UUID_STR_LEN];
+      esph_log_w(BLE_WRITE_TAG, "Characteristic %s was not found in service %s", this->char_uuid_.to_str(char_buf),
+                 this->service_uuid_.to_str(service_buf));
+      return;
+    }
+    if (chr->properties & ble_device_base::GATT_CHAR_PROP_WRITE) {
+      this->write_response_ = true;
+    } else if (chr->properties & ble_device_base::GATT_CHAR_PROP_WRITE_NO_RSP) {
+      this->write_response_ = false;
+    } else {
+      char char_buf[ble_device_base::UUID_STR_LEN];
+      esph_log_e(BLE_WRITE_TAG, "Characteristic %s does not allow writing", this->char_uuid_.to_str(char_buf));
+      return;
+    }
+    this->char_handle_ = chr->value_handle;
+    this->resolved_ = true;
+    char char_buf[ble_device_base::UUID_STR_LEN];
+    esph_log_d(BLE_WRITE_TAG, "Found characteristic %s on device %s", this->char_uuid_.to_str(char_buf),
+               this->ble_client_->address_str());
+  }
+
+  void on_disconnected() override {
+    this->resolved_ = false;
+    this->char_handle_ = 0;
+    if (this->num_running_ != 0)
+      this->stop_complex();
+  }
+
+  void on_write_result(uint16_t handle, int error) override {
+    if (this->num_running_ == 0) {
+      return;
+    }
+    if (!this->resolved_ || handle != this->char_handle_) {
+      // A parked chain waiting on a completion that never matches would
+      // otherwise stall silently until disconnect.
+      esph_log_d(BLE_WRITE_TAG, "Write result for handle 0x%04x ignored, waiting on 0x%04x", handle,
+                 this->char_handle_);
+      return;
+    }
+    if (error != 0) {
+      // Continue the chain (legacy parity) but leave a breadcrumb.
+      esph_log_w(BLE_WRITE_TAG, "Write completed with status %d", error);
+    }
+    this->ble_client_->run_later([this]() { this->play_next_tuple_(this->var_); });
+  }
+
+ private:
+  BLEClient *ble_client_;
+  ssize_t len_{-1};  // -1 = template mode, >=0 = static mode with length
+  union Value {
+    std::vector<uint8_t> (*func)(Ts...);  // Function pointer (stateless lambdas)
+    const uint8_t *data;                  // Pointer to static data in flash
+  } value_;
+  ble_device_base::ESPBTUUID service_uuid_;
+  ble_device_base::ESPBTUUID char_uuid_;
+  std::tuple<Ts...> var_{};
+  uint16_t char_handle_{};
+  bool write_response_{false};
+  bool resolved_{false};
+};
+
+}  // namespace esphome::ble_client
+
+#endif  // USE_BLE_CLIENT_GATT_NODES

esphome/components/ble_client/connect_backoff.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#ifdef USE_BLE_GATT_CLIENT
+
+#include "esphome/core/hal.h"
+#include "esphome/core/log.h"
+
+#include <cstdint>
+
+namespace esphome::ble_client {
+
+/// Reconnect backoff after repeated connect/discovery failures, shared by
+/// both engines. 256 ms ticks in a uint16_t keep it 4 bytes; the ~4.7 h tick
+/// wrap can at worst reinstate one stale hold-off of a minute.
+class ConnectBackoff {
+ public:
+  bool holding_off() const {
+    return this->failures_ != 0 && static_cast<uint16_t>(now() - this->start_) < this->failures_ * STEP_TICKS;
+  }
+  void register_failure(const char *address_str) {
+    if (this->failures_ < MAX_STEPS)
+      this->failures_++;
+    this->start_ = now();
+    esph_log_w("ble_client", "[%s] Holding off reconnect for %u s", address_str, this->failures_ * 10u);
+  }
+  void reset() { this->failures_ = 0; }
+
+ private:
+  // ~10 s per consecutive failure, capped so a flapping peer retries within
+  // a minute at worst.
+  static constexpr uint16_t STEP_TICKS = 40;  // x 256 ms
+  static constexpr uint8_t MAX_STEPS = 6;
+  static uint16_t now() { return static_cast<uint16_t>(millis() >> 8); }
+
+  uint16_t start_{0};
+  uint8_t failures_{0};
+};
+
+}  // namespace esphome::ble_client
+
+#endif  // USE_BLE_GATT_CLIENT

esphome/components/ble_device_base/ble_gatt_client.cpp

@@ -0,0 +1,48 @@
+#include "ble_gatt_client.h"
+
+#ifdef USE_BLE_GATT_CLIENT
+
+#include "esphome/core/log.h"
+
+namespace esphome::ble_device_base {
+
+ESPHOME_LOG_TAG(TAG, "ble_device_base");
+
+const GattCharacteristic *find_characteristic(const GattServiceTable &table, const GattService &service,
+                                              const ESPBTUUID &uuid) {
+  // 32-bit range math: a corrupt first/count pair cannot wrap past the check.
+  uint32_t end = uint32_t(service.first_characteristic) + service.characteristic_count;
+  if (end > table.characteristic_count) {
+    ESP_LOGW(TAG, "characteristic range out of bounds");
+    return nullptr;
+  }
+  for (uint32_t i = service.first_characteristic; i < end; i++) {
+    if (table.characteristics[i].uuid == uuid)
+      return &table.characteristics[i];
+  }
+  return nullptr;
+}
+
+const GattDescriptor *find_descriptor(const GattServiceTable &table, const GattCharacteristic &characteristic,
+                                      const ESPBTUUID &uuid) {
+  uint32_t end = uint32_t(characteristic.first_descriptor) + characteristic.descriptor_count;
+  if (end > table.descriptor_count) {
+    // Corrupt range, not a missing descriptor.
+    ESP_LOGW(TAG, "descriptor range out of bounds");
+    return nullptr;
+  }
+  for (uint32_t i = characteristic.first_descriptor; i < end; i++) {
+    if (table.descriptors[i].uuid == uuid)
+      return &table.descriptors[i];
+  }
+  return nullptr;
+}
+
+uint16_t find_cccd(const GattServiceTable &table, const GattCharacteristic &characteristic) {
+  const GattDescriptor *desc = find_descriptor(table, characteristic, ESPBTUUID::from_uint16(CCCD_UUID));
+  return desc != nullptr ? desc->handle : 0;
+}
+
+}  // namespace esphome::ble_device_base
+
+#endif  // USE_BLE_GATT_CLIENT

esphome/components/ble_device_base/ble_gatt_client.h

@@ -11,13 +11,16 @@
 // interface. All listener calls are delivered on the ESPHome main loop;
 // borrowed data pointers are valid only for the duration of the call.
 //
-// Error domain (plain int, forwarded to the API without translation):
+// Error domain (plain int, forwarded to the API without translation, so the
+// values are wire-frozen - API clients interpret them):
 //   0            success
-//   1..0x11      ATT error codes (Bluetooth spec; BTstack and Bluedroid agree)
+//   1..0x11      ATT error codes (Bluetooth spec) - reserved; a backend whose
+//                native error codes land in this window must remap them out
 //   GATT_ERR_NOT_CONNECTED (-1)  no connection to the peer (on esp32 a raw
 //                ESP_FAIL from the stack shares this value; both read as a
 //                failed, unusable connection on the client side)
 //   GATT_ERR_NO_MEMORY (-2)      backend storage exhausted
+//   -1..-15      reserved for future contract sentinels
 //   anything else: platform stack error/status code, surfaced opaquely.
 // Connection events carry HCI status/disconnect reason codes (same code
 // space on every controller).
@@ -99,9 +102,23 @@ class GattClientListener {
 // The BLEGattConnection op surface, asserted where the alias binds
 // (bluetooth_connection_gatt_backend.h). Operations return 0 when accepted (completion arrives
 // through the listener) or a synchronous error (busy, not connected, stack
-// rejection); one operation may be outstanding at a time. Semantics beyond
-// the signatures:
+// rejection); one operation may be outstanding at a time. A connection-state
+// or discovery completion always arrives from the event loop, never
+// synchronously from inside the op call - a synchronous terminal
+// on_connection_state from within gatt_disconnect() would re-enter the
+// consumer mid-teardown. A local-only completion may instead report inline,
+// before the op returns: notify_characteristic (a subscription-list edit on
+// the rp2 backend) and a write without response whose payload the stack took
+// immediately. Consumers must therefore arm whatever state their
+// on_write_result/on_notify_state reads before issuing the op, never after
+// the call returns. Semantics beyond the signatures:
 // - connect: addr_type is a BLE_ADDR_TYPE_* constant (ble_device.h).
+//   Returning 0 means the request is accepted, not that the radio acted: the
+//   backend owns integration with its platform's scan/connect arbitration
+//   (Bluedroid parks the request for the tracker's promote loop, which owns
+//   scan-stop/coex/one-connect-at-a-time; the rp2 backend opens immediately
+//   and relies on sighting-gated consumers). Consumers must not assume
+//   connect timing.
 // - gatt_disconnect: also cancels a connect in progress (named to coexist
 //   with a platform stack's own void disconnect() on one backend class).
 //   Nonzero means nothing to tear down and no completion will follow; an
@@ -143,6 +160,41 @@ concept BLEGattConnectionContract = requires(T conn, GattClientListener *listene
   { conn.set_connection_type(ConnectionType{}) } -> std::same_as<void>;
 };
 
+// ---- service table lookup helpers ----
+//
+// Neutral, bounds-checked walks over a materialized GattServiceTable for
+// direct consumers that resolve a known device's handles by UUID (streaming
+// consumers forward the raw database and never need these). Linear search:
+// the table exists only between discovery and release_services(), for one
+// small known device.
+
+/// Client Characteristic Configuration descriptor UUID (Bluetooth spec).
+static constexpr uint16_t CCCD_UUID = 0x2902;
+
+// Characteristic property bits (the Bluetooth-spec declaration byte carried
+// in GattCharacteristic::properties; the ESP-IDF macros for these do not
+// exist on the other platforms).
+static constexpr uint8_t GATT_CHAR_PROP_WRITE_NO_RSP = 0x04;
+static constexpr uint8_t GATT_CHAR_PROP_WRITE = 0x08;
+
+inline const GattService *find_service(const GattServiceTable &table, const ESPBTUUID &uuid) {
+  for (uint16_t i = 0; i < table.service_count; i++) {
+    if (table.services[i].uuid == uuid)
+      return &table.services[i];
+  }
+  return nullptr;
+}
+
+const GattCharacteristic *find_characteristic(const GattServiceTable &table, const GattService &service,
+                                              const ESPBTUUID &uuid);
+
+const GattDescriptor *find_descriptor(const GattServiceTable &table, const GattCharacteristic &characteristic,
+                                      const ESPBTUUID &uuid);
+
+/// Handle of the characteristic's Client Characteristic Configuration
+/// descriptor (0x2902), or 0 when it has none.
+uint16_t find_cccd(const GattServiceTable &table, const GattCharacteristic &characteristic);
+
 }  // namespace esphome::ble_device_base
 
 #endif  // USE_BLE_GATT_CLIENT

esphome/components/bluetooth_connection/__init__.py

@@ -1,12 +1,14 @@
 """Per-platform GATT connection backends and the helpers to embed one.
 
-Backends: esp32 Bluedroid, rp2 BTstack. No user-facing configuration; the
-Bluetooth proxy's codegen declares and registers the backend instances
-through gatt_client_schema()/hub_connection_schema() + new_gatt_backend().
+Backends: esp32 Bluedroid, rp2 BTstack. No user-facing configuration; a
+consumer's codegen declares and registers the backend instances — the
+Bluetooth proxy through its per-slot connection wrappers (a streaming
+consumer), and the neutral ble_client through gatt_client_schema() +
+new_gatt_backend().
 """
 
 from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 import esphome.codegen as cg
 from esphome.components import rp2040_ble
@@ -23,7 +25,8 @@ from esphome.types import ConfigType
 def AUTO_LOAD() -> list[str]:
     """ble_device_base plus the platform BLE stack the build's backend
     registers with (the Bluedroid header includes the tracker's), so
-    consumers need not know. The platform-less arm serves manifest tooling."""
+    consumers stay platform-blind. The platform-less arm serves tooling that
+    resolves the manifest without a target."""
     if CORE.is_esp32:
         return ["ble_device_base", "esp32_ble_tracker"]
     if CORE.is_rp2:
@@ -63,6 +66,8 @@ DOMAIN = "bluetooth_connection"
 @dataclass
 class _ConnectionData:
     rp2_backend_count: int = 0
+    # GATT connection slots claimed this run, for the platform cap check.
+    slot_consumers: list[str] = field(default_factory=list)
 
 
 def _get_data() -> _ConnectionData:
@@ -119,6 +124,10 @@ class _PlatformBackend:
     backend_class: cg.MockObjClass
     schema_fragment: Callable[[], cv.Schema]
     register: Callable[[cg.MockObj, ConfigType], Awaitable[None]]
+    # Selects the backend's alias-ladder arm (order-independent arms).
+    define: str
+    # The backend's on-demand materializer gate, when it has one.
+    materializer_define: str | None = None
 
 
 # The single registry of platforms with a GATT client backend; a platform
@@ -126,11 +135,20 @@ class _PlatformBackend:
 # platform's arm.
 _PLATFORM_BACKENDS: dict[str, _PlatformBackend] = {
     PLATFORM_ESP32: _PlatformBackend(
-        BluedroidGattClient, _esp32_schema_fragment, _esp32_register
+        BluedroidGattClient,
+        _esp32_schema_fragment,
+        _esp32_register,
+        "USE_BLE_GATT_BACKEND_BLUEDROID",
+        materializer_define="USE_BLUEDROID_GATT_SERVICE_TABLE",
+    ),
+    PLATFORM_RP2: _PlatformBackend(
+        RP2GattClient, _rp2_schema_fragment, _rp2_register, "USE_BLE_GATT_BACKEND_RP2"
     ),
-    PLATFORM_RP2: _PlatformBackend(RP2GattClient, _rp2_schema_fragment, _rp2_register),
 }
 
+# Gates dedicated-backend consumers (cv.only_on).
+GATT_CLIENT_PLATFORMS = list(_PLATFORM_BACKENDS)
+
 
 def _backend_entry(platform: str | None = None) -> _PlatformBackend:
     key = platform if platform is not None else CORE.target_platform
@@ -165,21 +183,97 @@ def hub_connection_schema(platform: str | None = None) -> cv.Schema:
     )
 
 
-async def new_gatt_backend(config: ConfigType) -> cg.MockObj:
+def _charge_esp32_budget(count: int, consumer: str, config: ConfigType) -> None:
+    from esphome.components import esp32_ble
+
+    esp32_ble.consume_connection_slots(count, consumer)(config)
+
+
+def _charge_rp2_budget(count: int, consumer: str, config: ConfigType) -> None:
+    rp2040_ble.consume_connection_slots(count, consumer)(config)
+
+
+# Platforms whose BLE stack owns its own connection budget: the claim is
+# charged there and that stack's final validation is the one place an
+# overcommit is reported (never two messages for one misconfiguration). One
+# mapping drives both, so a platform can never be skipped without a charge.
+_STACK_BUDGETS: dict[str, Callable[[int, str, ConfigType], None]] = {
+    PLATFORM_ESP32: _charge_esp32_budget,
+    PLATFORM_RP2: _charge_rp2_budget,
+}
+
+
+def consume_gatt_slot(
+    consumer: str, count: int = 1
+) -> Callable[[ConfigType], ConfigType]:
+    """Validator claiming GATT connection slots - the one spelling for every
+    claimant. The neutral ledger covers backend platforms without a stack
+    budget (the cap check in FINAL_VALIDATE_SCHEMA)."""
+
+    def validator(config: ConfigType) -> ConfigType:
+        _get_data().slot_consumers.extend([consumer] * count)
+        if (charge := _STACK_BUDGETS.get(CORE.target_platform)) is not None:
+            charge(count, consumer, config)
+        return config
+
+    return validator
+
+
+def _validate_slot_totals(config: ConfigType) -> ConfigType:
+    # Skipped in testing mode so grouped component builds can co-exist
+    # (mirrors esp32_ble.validate_connection_slots).
+    if CORE.testing_mode:
+        return config
+    if CORE.target_platform in _STACK_BUDGETS:
+        return config
+    if (cap := HUB_MAX_CONNECTIONS.get(CORE.target_platform)) is None:
+        # Any backend platform without a stack budget must carry a cap here
+        # or fail loudly, never fail open.
+        if CORE.target_platform in _PLATFORM_BACKENDS:
+            raise cv.Invalid(
+                f"{CORE.target_platform} has a GATT backend but no slot cap "
+                "in HUB_MAX_CONNECTIONS"
+            )
+        return config
+    claimed = _get_data().slot_consumers
+    if len(claimed) > cap:
+        raise cv.Invalid(
+            f"{CORE.target_platform} supports at most {cap} GATT client "
+            f"connection(s); {len(claimed)} requested by: {', '.join(claimed)}"
+        )
+    return config
+
+
+FINAL_VALIDATE_SCHEMA = _validate_slot_totals
+
+
+async def new_gatt_backend(
+    config: ConfigType, *, service_table: bool = True
+) -> cg.MockObj:
     """Instantiate the backend declared by gatt_client_schema() and register
     it with its platform stack. The connection slot is claimed at validation
-    (the proxy's slot validators), not here.
+    (the consume_gatt_slot validators), not here.
+
+    service_table is honored by the Bluedroid backend only: forward
+    scaffolding for the first esp32 direct consumer, load-bearing on no
+    current build (rp2 ignores the define and always materializes - its
+    proxy hub streams through get_service_table(), so it must keep the
+    materializer regardless of the flag).
     """
     from esphome.components import ble_device_base
 
+    entry = _backend_entry()
     ble_device_base.request_gatt_client()
+    cg.add_define(entry.define)
+    if service_table and entry.materializer_define is not None:
+        cg.add_define(entry.materializer_define)
     backend = cg.new_Pvariable(config[CONF_BACKEND_ID])
     # The backend is the slot's real Component: component keys from the
     # connection entry (setup_priority, ...) apply to it. Consumers whose own
     # schema carries keys that register_component would misapply to the
     # backend (e.g. a polling interval) must not put them in this config.
     await cg.register_component(backend, config)
-    await _backend_entry().register(backend, config)
+    await entry.register(backend, config)
     return backend
 
 
@@ -187,6 +281,7 @@ async def new_gatt_backend(config: ConfigType) -> cg.MockObj:
 # list (this module cannot import bluetooth_proxy to derive it).
 SOURCE_FILE_FRAMEWORKS: dict[str, set[PlatformFramework]] = {
     "bluetooth_connection_bluedroid.cpp": frameworks_for_platforms([PLATFORM_ESP32]),
+    "gatt_service_table_bluedroid.cpp": frameworks_for_platforms([PLATFORM_ESP32]),
     # Every hub platform the proxy admits (the file compiles empty where
     # USE_BLE_GATT_CLIENT is not defined), so a platform gaining a backend
     # cannot hit a missing-symbol trap here.

esphome/components/bluetooth_connection/bluetooth_connection.cpp

@@ -46,7 +46,7 @@ BatchClose close_service_batch(api::BluetoothGATTGetServicesResponse &resp, size
 
 #endif  // USE_BLUETOOTH_PROXY_CONNECTIONS
 
-#if defined(USE_ESP32) && defined(USE_BLE_GATT_CLIENT)
+#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
 namespace esphome::bluetooth_connection {
 
 // Address-scoped Bluedroid maintenance. Gated with the connection surface:
@@ -65,4 +65,4 @@ conn_err_t clear_gatt_cache(uint64_t address) {
 }
 
 }  // namespace esphome::bluetooth_connection
-#endif  // USE_ESP32 && USE_BLE_GATT_CLIENT
+#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT

esphome/components/bluetooth_connection/bluetooth_connection.h

@@ -49,15 +49,16 @@ static constexpr conn_err_t CONN_OK = 0;
 // GATT contract so backend and wrapper cannot drift.
 static constexpr conn_err_t GATT_NOT_CONNECTED = ble_device_base::GATT_ERR_NOT_CONNECTED;
 
-// What the platform's connection backend supports beyond GATT operations;
-// the proxy derives its feature flags and legacy version from these.
-#if defined(USE_ESP32)
+// What the build's connection backend supports beyond GATT operations; the
+// proxy derives its feature flags and legacy version from these. Keyed on
+// the backend define, never the platform, so a second backend on one
+// platform carries its own facts.
+#if defined(USE_BLE_GATT_BACKEND_BLUEDROID)
 static constexpr bool SUPPORTS_PAIRING = true;
 static constexpr bool SUPPORTS_CACHE_CLEARING = true;
-#elif defined(USE_RP2040_BLE) && defined(USE_BLE_GATT_CLIENT)
+#elif defined(USE_BLE_GATT_BACKEND_RP2)
 // The rp2 BTstack backend pairs (just works + bonding); it has no service
-// cache to clear. Keyed on the backend, not the generic client define, so a
-// future backend without pairing keeps the stub arm below.
+// cache to clear.
 static constexpr bool SUPPORTS_PAIRING = true;
 static constexpr bool SUPPORTS_CACHE_CLEARING = false;
 #else
@@ -65,13 +66,14 @@ static constexpr bool SUPPORTS_PAIRING = false;
 static constexpr bool SUPPORTS_CACHE_CLEARING = false;
 #endif
 
-// Address-scoped (not connection-scoped) maintenance requests.
-#if (defined(USE_ESP32) || defined(USE_RP2040_BLE)) && defined(USE_BLE_GATT_CLIENT)
+// Address-scoped (not connection-scoped) maintenance requests; keyed on the
+// stack (the calls need no backend instance).
+#if (defined(USE_ESP32_BLE) || defined(USE_RP2040_BLE)) && defined(USE_BLE_GATT_CLIENT)
 conn_err_t unpair_device(uint64_t address);
 #else
 inline conn_err_t unpair_device(uint64_t) { return GATT_NOT_CONNECTED; }
 #endif
-#if defined(USE_ESP32) && defined(USE_BLE_GATT_CLIENT)
+#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
 conn_err_t clear_gatt_cache(uint64_t address);
 #else
 inline conn_err_t clear_gatt_cache(uint64_t) { return GATT_NOT_CONNECTED; }

esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.cpp

@@ -2,10 +2,11 @@
 
 #if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
 
+#include "bluetooth_connection.h"
+
 // The in-place streamer serves the proxy's service-discovery API; backend-only
 // builds compile without the proxy headers or the streamer.
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
-#include "bluetooth_connection.h"
 #include "bluetooth_connection_hub.h"
 
 #include "esphome/components/bluetooth_proxy/bluetooth_proxy.h"
@@ -345,6 +346,9 @@ int BluedroidGattClient::update_connection_params(uint16_t min_interval, uint16_
 
 void BluedroidGattClient::release_services() {
   this->service_total_ = 0;
+#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
+  this->table_.free();
+#endif
   // Always set: terminates any in-flight stream on every cache config.
   this->services_released_ = true;
 #ifndef CONFIG_BT_GATTC_CACHE_NVS_FLASH
@@ -357,6 +361,24 @@ void BluedroidGattClient::release_services() {
 #endif
 }
 
+#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
+ble_device_base::GattServiceTable BluedroidGattClient::get_service_table() {
+  // Lifetime: every teardown path (CLOSE_EVT, the safety timeout, stack-down,
+  // passive DISCONNECT) routes through release_services(), so a materialized
+  // table cannot outlive its link.
+  if (this->table_.empty() &&
+      (this->services_released_ || this->service_total_ == 0 ||
+       !this->table_.build(this->gattc_if_, this->conn_id_, this->service_total_, this->connection_index_))) {
+    // Released / no services / failed build all collapse to empty; the
+    // build failures warned above, log the quiet two.
+    ESP_LOGD(TAG, "[%d] No service table (released=%d, services=%u)", this->connection_index_, this->services_released_,
+             this->service_total_);
+    return {};
+  }
+  return this->table_.view();
+}
+#endif  // USE_BLUEDROID_GATT_SERVICE_TABLE
+
 // ---- internals ----
 
 bool BluedroidGattClient::check_addr_(const esp_bd_addr_t &addr) const {
@@ -403,6 +425,11 @@ void BluedroidGattClient::log_gattc_warning_(const char *operation, int code) {
 // ---- service streaming ----
 
 int BluedroidGattClient::handle_search_cmpl_(esp_gatt_status_t status) {
+#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
+  // Re-discovery moves the counts the table view derives offsets from; free
+  // the stale table.
+  this->table_.free();
+#endif
   // Step down from the fast discovery params.
   this->update_conn_params_(MEDIUM_MIN_CONN_INTERVAL, MEDIUM_MAX_CONN_INTERVAL, 0, MEDIUM_CONN_TIMEOUT, "medium");
   if (status != ESP_GATT_OK) {

esphome/components/bluetooth_connection/bluetooth_connection_bluedroid.h

@@ -11,6 +11,9 @@
 
 #if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT)
 
+#include "bluetooth_connection.h"
+#include "gatt_service_table_bluedroid.h"
+
 #include "esphome/components/ble_device_base/ble_gatt_client.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 #include "esphome/core/component.h"
@@ -76,11 +79,16 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public
   int notify_characteristic(uint16_t handle, bool enable);
   int pair();
   int update_connection_params(uint16_t min_interval, uint16_t max_interval, uint16_t latency, uint16_t timeout);
-  // Contract stub: the proxy streams in place; the on-demand materializer
-  // for direct consumers lands with #18205. NOTE: a direct consumer reaching
-  // this stub gets an empty table indistinguishable from a service-less
-  // peer - do not ship one against this backend before the materializer.
+  // On-demand table for direct consumers; the proxy streams instead, so the
+  // materializer compiles only under USE_BLUEDROID_GATT_SERVICE_TABLE (emitted by
+  // direct-consumer codegen, never by the proxy).
+#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
+  ble_device_base::GattServiceTable get_service_table();
+#else
+  // A direct consumer reaching this stub misconfigured its codegen
+  // (service_table=False): the empty table reads as a service-less peer.
   ble_device_base::GattServiceTable get_service_table() { return {}; }
+#endif
   void release_services();
 
 #ifdef USE_BLUETOOTH_PROXY_CONNECTIONS
@@ -110,6 +118,9 @@ class BluedroidGattClient final : public esp32_ble_tracker::ESPBTClient, public
 
   // Group 1: pointers / composed objects
   ble_device_base::GattClientListener *listener_{nullptr};
+#ifdef USE_BLUEDROID_GATT_SERVICE_TABLE
+  BluedroidServiceTable table_;
+#endif
   // Group 2: 4-byte types
   uint32_t disconnecting_started_{0};
 

esphome/components/bluetooth_connection/bluetooth_connection_gatt_backend.h

@@ -12,10 +12,12 @@
 
 #include "esphome/components/ble_device_base/ble_gatt_client.h"
 
-#if defined(USE_RP2040_BLE)
+// Arms are keyed on codegen-emitted per-backend defines (_PLATFORM_BACKENDS
+// in __init__.py), so they are order-independent.
+#if defined(USE_BLE_GATT_BACKEND_RP2)
 #include "bluetooth_connection_rp2.h"
 #define ESPHOME_BLE_GATT_CONNECTION_TYPE bluetooth_connection::RP2GattClient
-#elif defined(USE_ESP32_BLE)
+#elif defined(USE_BLE_GATT_BACKEND_BLUEDROID)
 #include "bluetooth_connection_bluedroid.h"
 #define ESPHOME_BLE_GATT_CONNECTION_TYPE bluetooth_connection::BluedroidGattClient
 #elif defined(USE_BLE_GATT_CLIENT_STUB_BACKEND)

esphome/components/bluetooth_connection/gatt_service_table_bluedroid.cpp

@@ -0,0 +1,198 @@
+#include "gatt_service_table_bluedroid.h"
+
+#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT) && defined(USE_BLUEDROID_GATT_SERVICE_TABLE)
+
+#include "esphome/core/log.h"
+
+namespace esphome::bluetooth_connection {
+
+ESPHOME_LOG_TAG(TAG, "bluetooth_connection");
+
+// A stack that never reports end-of-range would otherwise walk forever.
+static constexpr uint16_t MAX_DESCRIPTORS_PER_CHARACTERISTIC = 64;
+
+// Shared enumeration for both build passes: an identical walk order is what
+// lets the counting pass size the block the filling pass fills.
+// INVALID_OFFSET/NOT_FOUND mean end-of-range; anything else is a failure.
+template<typename ServiceFn, typename CharFn, typename DescFn>
+bool BluedroidServiceTable::walk_(ServiceFn &&on_service, CharFn &&on_char, DescFn &&on_desc) {
+  for (uint16_t s = 0; s < this->service_total_; s++) {
+    esp_gattc_service_elem_t svc;
+    uint16_t svc_count = 1;
+    auto svc_status = esp_ble_gattc_get_service(this->gattc_if_, this->conn_id_, nullptr, &svc, &svc_count, s);
+    if (svc_status != ESP_GATT_OK || svc_count == 0) {
+      this->log_walk_warning_("esp_ble_gattc_get_service", svc_status);
+      return false;
+    }
+    if (!on_service(s, svc)) {
+      return false;
+    }
+    uint16_t svc_chars = 0;
+    auto count_status = esp_ble_gattc_get_attr_count(this->gattc_if_, this->conn_id_, ESP_GATT_DB_CHARACTERISTIC,
+                                                     svc.start_handle, svc.end_handle, 0, &svc_chars);
+    if (count_status != ESP_GATT_OK) {
+      this->log_walk_warning_("esp_ble_gattc_get_attr_count", count_status);
+      return false;
+    }
+    for (uint16_t c = 0; c < svc_chars; c++) {
+      esp_gattc_char_elem_t chr;
+      uint16_t char_count = 1;
+      auto status = esp_ble_gattc_get_all_char(this->gattc_if_, this->conn_id_, svc.start_handle, svc.end_handle, &chr,
+                                               &char_count, c);
+      if (status != ESP_GATT_OK || char_count == 0) {
+        // An early terminator contradicts svc_chars from the same cache;
+        // never build a silently truncated table.
+        this->log_walk_warning_("esp_ble_gattc_get_all_char", status);
+        return false;
+      }
+      if (!on_char(svc, chr)) {
+        return false;
+      }
+      for (uint16_t d = 0;; d++) {
+        if (d == MAX_DESCRIPTORS_PER_CHARACTERISTIC) {
+          // A stack that never reports end-of-range; fail like every other
+          // inconsistency instead of truncating the table silently.
+          ESP_LOGW(TAG, "[%d] Descriptor walk exceeded %u entries", this->log_index_,
+                   MAX_DESCRIPTORS_PER_CHARACTERISTIC);
+          return false;
+        }
+        esp_gattc_descr_elem_t desc;
+        uint16_t desc_count = 1;
+        auto desc_status =
+            esp_ble_gattc_get_all_descr(this->gattc_if_, this->conn_id_, chr.char_handle, &desc, &desc_count, d);
+        if (desc_status == ESP_GATT_INVALID_OFFSET || desc_status == ESP_GATT_NOT_FOUND) {
+          break;
+        }
+        if (desc_status != ESP_GATT_OK || desc_count == 0) {
+          this->log_walk_warning_("esp_ble_gattc_get_all_descr", desc_status);
+          return false;
+        }
+        if (!on_desc(chr, desc)) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool BluedroidServiceTable::count_services(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t *total) {
+  uint16_t primary = 0;
+  uint16_t secondary = 0;
+  if (esp_ble_gattc_get_attr_count(gattc_if, conn_id, ESP_GATT_DB_PRIMARY_SERVICE, 0x0001, 0xFFFF, 0, &primary) !=
+          ESP_GATT_OK ||
+      esp_ble_gattc_get_attr_count(gattc_if, conn_id, ESP_GATT_DB_SECONDARY_SERVICE, 0x0001, 0xFFFF, 0, &secondary) !=
+          ESP_GATT_OK) {
+    // A failed count must not read as an authoritative empty database.
+    return false;
+  }
+  *total = primary + secondary;
+  return true;
+}
+
+bool BluedroidServiceTable::build(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t service_total, uint8_t log_index) {
+  this->free();
+  this->gattc_if_ = gattc_if;
+  this->conn_id_ = conn_id;
+  this->service_total_ = service_total;
+  this->log_index_ = log_index;
+
+  // Pass 1: count, so one exact-size block holds the whole table.
+  uint16_t char_total = 0;
+  uint16_t desc_total = 0;
+  bool counted = this->walk_([](uint16_t, const esp_gattc_service_elem_t &) { return true; },
+                             [&](const esp_gattc_service_elem_t &, const esp_gattc_char_elem_t &) {
+                               char_total++;
+                               return true;
+                             },
+                             [&](const esp_gattc_char_elem_t &, const esp_gattc_descr_elem_t &) {
+                               desc_total++;
+                               return true;
+                             });
+  if (!counted) {
+    ESP_LOGW(TAG, "[%d] Service table walk failed during count", this->log_index_);
+    this->free();
+    return false;
+  }
+
+  // The arrays share one block; carving stays aligned because each struct's
+  // strictest member is the UUID and array sizes are multiples of it.
+  static_assert(alignof(ble_device_base::GattService) >= alignof(ble_device_base::GattCharacteristic) &&
+                alignof(ble_device_base::GattCharacteristic) >= alignof(ble_device_base::GattDescriptor));
+  size_t svc_bytes = this->service_total_ * sizeof(ble_device_base::GattService);
+  size_t char_bytes = char_total * sizeof(ble_device_base::GattCharacteristic);
+  size_t total_bytes = svc_bytes + char_bytes + desc_total * sizeof(ble_device_base::GattDescriptor);
+  RAMAllocator<uint8_t> allocator(RAMAllocator<uint8_t>::ALLOC_INTERNAL);
+  this->storage_ = allocator.allocate(total_bytes);
+  if (this->storage_ == nullptr) {
+    ESP_LOGW(TAG, "[%d] Service table allocation failed (%u bytes)", this->log_index_,
+             static_cast<unsigned>(total_bytes));
+    this->free();
+    return false;
+  }
+  auto *services = reinterpret_cast<ble_device_base::GattService *>(this->storage_);
+  auto *characteristics = reinterpret_cast<ble_device_base::GattCharacteristic *>(this->storage_ + svc_bytes);
+  auto *descriptors = reinterpret_cast<ble_device_base::GattDescriptor *>(this->storage_ + svc_bytes + char_bytes);
+
+  // Pass 2: fill, bounded by the pass-1 totals. A bound trip or a shortfall
+  // means the cached database changed between the passes; fail the build
+  // rather than serve an inconsistent table (the consumer retries).
+  uint16_t char_index = 0;
+  uint16_t desc_index = 0;
+  ble_device_base::GattService *cur_service = nullptr;
+  ble_device_base::GattCharacteristic *cur_char = nullptr;
+  bool filled = this->walk_(
+      [&](uint16_t s, const esp_gattc_service_elem_t &svc) {
+        cur_service = &services[s];
+        cur_service->uuid = ble_device_base::ESPBTUUID::from_uuid(svc.uuid);
+        cur_service->start_handle = svc.start_handle;
+        cur_service->end_handle = svc.end_handle;
+        cur_service->first_characteristic = char_index;
+        cur_service->characteristic_count = 0;
+        return true;
+      },
+      [&](const esp_gattc_service_elem_t &svc, const esp_gattc_char_elem_t &chr) {
+        if (char_index >= char_total) {
+          return false;
+        }
+        cur_char = &characteristics[char_index++];
+        cur_char->uuid = ble_device_base::ESPBTUUID::from_uuid(chr.uuid);
+        cur_char->value_handle = chr.char_handle;
+        // Bluedroid addresses descriptors by characteristic handle, so the
+        // table's end_handle only needs the service-bounded upper bound.
+        cur_char->end_handle = svc.end_handle;
+        cur_char->properties = chr.properties;
+        cur_char->first_descriptor = desc_index;
+        cur_char->descriptor_count = 0;
+        cur_service->characteristic_count++;
+        return true;
+      },
+      [&](const esp_gattc_char_elem_t &, const esp_gattc_descr_elem_t &desc) {
+        if (desc_index >= desc_total) {
+          return false;
+        }
+        descriptors[desc_index].uuid = ble_device_base::ESPBTUUID::from_uuid(desc.uuid);
+        descriptors[desc_index].handle = desc.handle;
+        desc_index++;
+        cur_char->descriptor_count++;
+        return true;
+      });
+  if (!filled || char_index != char_total || desc_index != desc_total) {
+    // Walk error or the database changed between passes; better an empty
+    // table than a corrupt one.
+    ESP_LOGW(TAG, "[%d] Service table walk mismatch, discarding", this->log_index_);
+    this->free();
+    return false;
+  }
+  this->char_total_ = char_total;
+  this->desc_total_ = desc_total;
+  return true;
+}
+
+void BluedroidServiceTable::log_walk_warning_(const char *operation, int code) {
+  ESP_LOGW(TAG, "[%d] %s failed, status=%d", this->log_index_, operation, code);
+}
+
+}  // namespace esphome::bluetooth_connection
+
+#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT && USE_BLUEDROID_GATT_SERVICE_TABLE

esphome/components/bluetooth_connection/gatt_service_table_bluedroid.h

@@ -0,0 +1,82 @@
+// Owning two-pass materializer of one Bluedroid GATT database snapshot into
+// the neutral GattServiceTable layout, shared by the BluedroidGattClient
+// backend and ble_client's esp32 engine.
+
+#pragma once
+
+#include "esphome/core/defines.h"
+
+#if defined(USE_ESP32_BLE) && defined(USE_BLE_GATT_CLIENT) && defined(USE_BLUEDROID_GATT_SERVICE_TABLE)
+
+#include "esphome/components/ble_device_base/ble_gatt_client.h"
+#include "esphome/core/helpers.h"
+
+#include <esp_gattc_api.h>
+
+namespace esphome::bluetooth_connection {
+
+class BluedroidServiceTable {
+ public:
+  ~BluedroidServiceTable() { this->free(); }
+  // Owns storage_; a copy would double-free. The default constructor is user
+  // provided, not "= default", so value-initializing the enclosing backend
+  // cannot zero-fill .bss that is already zero.
+  BluedroidServiceTable() {}
+  BluedroidServiceTable(const BluedroidServiceTable &) = delete;
+  BluedroidServiceTable &operator=(const BluedroidServiceTable &) = delete;
+
+  /// The service count build() requires: the stack's PRIMARY+SECONDARY
+  /// attribute totals, never the SEARCH_RES event count.
+  static bool count_services(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t *total);
+
+  /// Two-pass build from the stack's cached database (service_total from
+  /// count_services()). log_index labels warnings. Frees any previous table
+  /// first; on failure the table is left empty.
+  bool build(esp_gatt_if_t gattc_if, uint16_t conn_id, uint16_t service_total, uint8_t log_index);
+
+  // The view is carved from the storage block and the counts on each call
+  // (a cold path) rather than cached, saving a per-instance table member.
+  ble_device_base::GattServiceTable view() const {
+    size_t svc_bytes = this->service_total_ * sizeof(ble_device_base::GattService);
+    size_t char_bytes = this->char_total_ * sizeof(ble_device_base::GattCharacteristic);
+    return {reinterpret_cast<const ble_device_base::GattService *>(this->storage_),
+            reinterpret_cast<const ble_device_base::GattCharacteristic *>(this->storage_ + svc_bytes),
+            reinterpret_cast<const ble_device_base::GattDescriptor *>(this->storage_ + svc_bytes + char_bytes),
+            this->service_total_,
+            this->char_total_,
+            this->desc_total_};
+  }
+
+  // Always resets the counts: a failed build must never leave a non-zero
+  // service_total_ behind a null table.
+  void free() {
+    if (this->storage_ != nullptr) {
+      RAMAllocator<uint8_t> allocator(RAMAllocator<uint8_t>::ALLOC_INTERNAL);
+      allocator.deallocate(this->storage_, 0);
+      this->storage_ = nullptr;
+    }
+    this->service_total_ = 0;
+    this->char_total_ = 0;
+    this->desc_total_ = 0;
+  }
+
+  bool empty() const { return this->storage_ == nullptr; }
+
+ private:
+  template<typename ServiceFn, typename CharFn, typename DescFn>
+  bool walk_(ServiceFn &&on_service, CharFn &&on_char, DescFn &&on_desc);
+  void log_walk_warning_(const char *operation, int code);
+
+  uint8_t *storage_{nullptr};
+  uint16_t service_total_{0};
+  uint16_t char_total_{0};
+  uint16_t desc_total_{0};
+  // Walk context, set by build().
+  uint16_t conn_id_{0};
+  esp_gatt_if_t gattc_if_{};  // uint8_t width
+  uint8_t log_index_{0};
+};
+
+}  // namespace esphome::bluetooth_connection
+
+#endif  // USE_ESP32_BLE && USE_BLE_GATT_CLIENT && USE_BLUEDROID_GATT_SERVICE_TABLE

esphome/components/bluetooth_proxy/__init__.py

@@ -94,10 +94,20 @@ def _esp32_config_schema() -> cv.All:
     CONNECTION_SCHEMA = bluetooth_connection.hub_connection_schema(PLATFORM_ESP32)
 
     def validate_connections(config: ConfigType) -> ConfigType:
-        if CONF_CONNECTIONS in config or not config[CONF_ACTIVE]:
+        if CONF_CONNECTIONS in config:
+            # Explicit entries claim slots like the generated ones; dev
+            # historically skipped this, letting an explicit-connections
+            # config evade the controller budget.
+            bluetooth_connection.consume_gatt_slot(
+                "bluetooth_proxy", len(config[CONF_CONNECTIONS])
+            )(config)
+            return config
+        if not config[CONF_ACTIVE]:
             return config
         connection_slots: int = config[CONF_CONNECTION_SLOTS]
-        esp32_ble.consume_connection_slots(connection_slots, "bluetooth_proxy")(config)
+        bluetooth_connection.consume_gatt_slot("bluetooth_proxy", connection_slots)(
+            config
+        )
         return {
             **config,
             CONF_CONNECTIONS: [CONNECTION_SCHEMA({}) for _ in range(connection_slots)],
@@ -149,14 +159,14 @@ def _rp2_config_schema() -> cv.All:
     connection_schema = bluetooth_connection.hub_connection_schema(PLATFORM_RP2)
 
     def populate_connections(config: ConfigType) -> ConfigType:
-        from esphome.components import rp2040_ble
-
         # One wrapper + backend pair per slot, declared during validation so
         # their ids exist for codegen (the esp32 arm's `connections` pattern).
         if not config[CONF_ACTIVE]:
             return config
         connection_slots: int = config[CONF_CONNECTION_SLOTS]
-        rp2040_ble.consume_connection_slots(connection_slots, "bluetooth_proxy")(config)
+        bluetooth_connection.consume_gatt_slot("bluetooth_proxy", connection_slots)(
+            config
+        )
         return {
             **config,
             CONF_CONNECTIONS: [connection_schema({}) for _ in range(connection_slots)],
@@ -206,7 +216,9 @@ async def _connections_to_code(var: cg.MockObj, config: ConfigType) -> None:
         # sends those requests and their handlers and encoders are dead.
         cg.add_define("USE_BLUETOOTH_PROXY_CONNECTIONS")
     for connection_conf in connections:
-        backend = await bluetooth_connection.new_gatt_backend(connection_conf)
+        backend = await bluetooth_connection.new_gatt_backend(
+            connection_conf, service_table=False
+        )
         connection = cg.new_Pvariable(connection_conf[CONF_ID])
         cg.add(connection.set_backend(backend))
         cg.add(var.register_connection(connection))

esphome/components/bq25186/bq25186_switch.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "esphome/core/defines.h"
+#ifdef USE_BQ25186_PG_GPO
+
+#include "bq25186.h"
+#include "esphome/components/switch/switch.h"
+
+namespace esphome::bq25186 {
+
+class BQ25186PgGpoSwitch final : public switch_::Switch, public Parented<BQ25186Component> {
+ protected:
+  void write_state(bool state) override {
+    if (this->parent_->write_pg_gpo_level(state))
+      this->publish_state(state);
+  }
+};
+
+}  // namespace esphome::bq25186
+
+#endif  // USE_BQ25186_PG_GPO

esphome/components/bq25186/switch.py

@@ -3,16 +3,18 @@ from esphome.components import switch
 import esphome.config_validation as cv
 from esphome.types import ConfigType
 
-from . import BQ25186_CHILD_SCHEMA, CONF_BQ25186_ID
+from . import BQ25186_CHILD_SCHEMA, CONF_BQ25186_ID, bq25186_ns
 
 DEPENDENCIES = ["bq25186"]
 
 CONF_PG_GPO = "pg_gpo"
 
+BQ25186PgGpoSwitch = bq25186_ns.class_("BQ25186PgGpoSwitch", switch.Switch)
+
 CONFIG_SCHEMA = BQ25186_CHILD_SCHEMA.extend(
     {
         cv.Required(CONF_PG_GPO): switch.switch_schema(
-            switch.ApplySwitch, default_restore_mode="DISABLED"
+            BQ25186PgGpoSwitch, default_restore_mode="DISABLED"
         ),
     }
 )
@@ -22,9 +24,4 @@ async def to_code(config: ConfigType) -> None:
     cg.add_define("USE_BQ25186_PG_GPO")
     hub = await cg.get_variable(config[CONF_BQ25186_ID])
     switches = switch.sub_switches(config, parent=hub)
-    await switches(
-        CONF_PG_GPO,
-        hub.set_pg_gpo_switch,
-        apply="write_pg_gpo_level(state)",
-        publish="on_success",
-    )
+    await switches(CONF_PG_GPO, hub.set_pg_gpo_switch)

esphome/components/debug/__init__.py

@@ -1,5 +1,4 @@
 import esphome.codegen as cg
-from esphome.components import logger
 from esphome.components.nrf52.framework import include_west_project
 from esphome.components.zephyr import zephyr_add_prj_conf
 from esphome.config_helpers import filter_source_files_from_platform
@@ -10,8 +9,6 @@ from esphome.const import (
     CONF_FRAGMENTATION,
     CONF_FREE,
     CONF_ID,
-    CONF_LEVEL,
-    CONF_LOGGER,
     CONF_LOOP_TIME,
     PlatformFramework,
 )
@@ -65,13 +62,6 @@ async def to_code(config: ConfigType) -> None:
         zephyr_add_prj_conf("LOG_BUFFER_SIZE", 4096)
         zephyr_add_prj_conf("SEGGER_RTT_MODE_BLOCK_IF_FIFO_FULL", True)
         zephyr_add_prj_conf("PRINTK", True)
-        # per-thread CPU usage, logged by update_platform_() at verbose level
-        level = CORE.config[CONF_LOGGER][CONF_LEVEL]
-        if logger.LOG_LEVEL_SEVERITY.index(level) >= logger.LOG_LEVEL_SEVERITY.index(
-            "VERBOSE"
-        ):
-            zephyr_add_prj_conf("THREAD_RUNTIME_STATS", True)
-            zephyr_add_prj_conf("SCHED_THREAD_USAGE_ANALYSIS", True)
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     cg.add_define("USE_DEBUG")

esphome/components/debug/debug_zephyr.cpp

@@ -6,7 +6,6 @@
 #include "esphome/core/log.h"
 #include <esphome/components/zephyr/reset_reason.h>
 #include <zephyr/drivers/hwinfo.h>
-#include <zephyr/kernel.h>
 #include <hal/nrf_power.h>
 #include <cstdint>
 #include <zephyr/storage/flash_map.h>
@@ -423,34 +422,7 @@ size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE>
   return pos;
 }
 
-// The Python side enables the statistics only for a verbose logger
-#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
-static void log_thread_usage(const struct k_thread *thread, void *user_data) {
-  const auto cpu_cycles = *static_cast<const uint64_t *>(user_data);
-  auto *tid = const_cast<k_tid_t>(thread);  // NOLINT(cppcoreguidelines-pro-type-const-cast)
-  k_thread_runtime_stats_t stats;
-  if (k_thread_runtime_stats_get(tid, &stats) != 0)
-    return;
-  char state[32];
-  const char *name = k_thread_name_get(tid);
-  ESP_LOGV(TAG, "  %-16s prio %3d %-10s %3u%% peak %" PRIu32 " avg %" PRIu32, name != nullptr ? name : "?",
-           thread->base.prio, k_thread_state_str(tid, state, sizeof(state)),
-           static_cast<unsigned>(stats.execution_cycles * 100 / cpu_cycles),
-           static_cast<uint32_t>(k_cyc_to_us_floor64(stats.peak_cycles)),
-           static_cast<uint32_t>(k_cyc_to_us_floor64(stats.average_cycles)));
-}
-#endif
-
-void DebugComponent::update_platform_() {
-#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
-  k_thread_runtime_stats_t cpu;
-  if (k_thread_runtime_stats_all_get(&cpu) != 0 || cpu.execution_cycles == 0)
-    return;
-  ESP_LOGV(TAG, "Thread CPU usage since boot (peak and average us per time slice):");
-  // The unlocked walk lets the log output inside the callback block
-  k_thread_foreach_unlocked(log_thread_usage, &cpu.execution_cycles);
-#endif
-}
+void DebugComponent::update_platform_() {}
 
 }  // namespace esphome::debug
 #endif

esphome/components/gree/climate.py

@@ -1,5 +1,5 @@
 import esphome.codegen as cg
-from esphome.components import climate_ir, remote_base
+from esphome.components import climate_ir
 import esphome.config_validation as cv
 from esphome.const import CONF_MODEL, CONF_USE_FAHRENHEIT
 from esphome.types import ConfigType
@@ -13,16 +13,7 @@ GreeClimate = gree_ns.class_("GreeClimate", climate_ir.ClimateIR)
 
 Model = gree_ns.enum("Model")
 MODELS = Model.options(
-    "generic",
-    "yan",
-    "yaa",
-    "yac",
-    "yac1fb9",
-    "yb1fa",
-    "yx1ff",
-    "yag",
-    "yaw1f",
-    prefix="GREE_",
+    "generic", "yan", "yaa", "yac", "yac1fb9", "yx1ff", "yag", "yaw1f", prefix="GREE_"
 )
 
 CONFIG_SCHEMA = climate_ir.climate_ir_with_receiver_schema(GreeClimate).extend(
@@ -41,5 +32,3 @@ async def to_code(config: ConfigType) -> None:
         cg.add(var.set_use_fahrenheit(True))
     if config[CONF_MODEL] == "yaw1f":
         cg.add_define("USE_GREE_YAW1F")
-    if remote_base.CONF_RECEIVER_ID in config:
-        cg.add_define("USE_GREE_RECEIVER")

esphome/components/gree/gree.cpp

@@ -4,6 +4,8 @@
 #include "esphome/components/remote_base/remote_base.h"
 #include "esphome/core/helpers.h"
 
+#include <algorithm>
+
 namespace esphome::gree {
 
 ESPHOME_LOG_TAG(TAG, "gree.climate");
@@ -11,25 +13,27 @@ ESPHOME_LOG_TAG(TAG, "gree.climate");
 static constexpr remote_base::BitTimings GREE_BIT_TIMINGS{
     .bit_mark = GREE_BIT_MARK, .one_space = GREE_ONE_SPACE, .zero_space = GREE_ZERO_SPACE};
 
-static constexpr uint8_t GREE_SWING_AUTO_MASK = 0x40;
-#ifdef USE_GREE_YAW1F
-// The YAW1F second message is 00 00 00 A0 | 00 00 00 A0.
-static constexpr uint8_t GREE_YAW1F_FOLLOWUP_BYTE = 0xA0;
-#endif
+void GreeClimate::set_model(Model model) {
+  if (model == GREE_YAN || model == GREE_YX1FF) {
+    // These models only expose vertical swing; horizontal swing is not encoded on the wire.
+    this->swing_modes_.erase(climate::CLIMATE_SWING_HORIZONTAL);
+    this->swing_modes_.erase(climate::CLIMATE_SWING_BOTH);
+  }
+  if (model == GREE_YX1FF) {
+    this->fan_modes_.insert(climate::CLIMATE_FAN_QUIET);  // YX1FF 4 speed
+  }
+  // Models with a sleep preset
+  if (model == GREE_YX1FF || model == GREE_YAC1FB9) {
+    this->presets_.insert(climate::CLIMATE_PRESET_NONE);
+    this->presets_.insert(climate::CLIMATE_PRESET_SLEEP);
+  }
 
-// The mode, fan and feature mappings use if-else: a switch becomes a lookup table in RAM on ESP8266.
-static constexpr uint8_t supported_feature_mask(Model model) {
-  if (model == GREE_YB1FA)
-    return GREE_MODE_BIT_TURBO | GREE_MODE_BIT_LIGHT | GREE_MODE_BIT_XFAN;
-  if (model == GREE_YX1FF)
-    return GREE_MODE_BIT_LIGHT;
-  if (model == GREE_GENERIC || model == GREE_YAG || model == GREE_YAW1F)
-    return 0;
-  return GREE_MODE_BIT_TURBO | GREE_MODE_BIT_LIGHT | GREE_MODE_BIT_HEALTH | GREE_MODE_BIT_XFAN;
+  this->model_ = model;
 }
 
-static constexpr uint8_t default_feature_bits(Model model) {
-  return supported_feature_mask(model) & GREE_MODE_BIT_LIGHT;
+void GreeClimate::set_mode_bit(uint8_t bit_mask, bool enabled) {
+  assign_bits(this->mode_bits_, bit_mask, enabled);
+  this->transmit_state();
 }
 
 #ifdef USE_GREE_FAHRENHEIT
@@ -47,292 +51,190 @@ uint8_t fahrenheit_half_steps(float target_celsius) {
 }
 #endif
 
-struct GreeFrameSpaces {
-  uint32_t header;
-  uint32_t message;
-};
+void GreeClimate::transmit_state() {
+  uint8_t remote_state[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00};
+  const Model model = this->model_;
+  // YAW1F uses the YAG byte layout with different framing (see below)
+  const bool yag_layout = model == GREE_YAG || model == GREE_YAW1F;
 
-static GreeFrameSpaces frame_spaces(Model model) {
-  if (model == GREE_YAC1FB9 || model == GREE_YAW1F)
-    return {GREE_YAC1FB9_HEADER_SPACE, GREE_YAC1FB9_MESSAGE_SPACE};
-  return {GREE_HEADER_SPACE, GREE_MESSAGE_SPACE};
-}
-
-static void write_frame(remote_base::RemoteTransmitData *data, const GreeState &frame, const GreeFrameSpaces &spaces) {
-  data->item(GREE_HEADER_MARK, spaces.header);
-  data->item_bytes<GREE_BIT_TIMINGS>(frame.data(), 4);
-  // Fixed 010 between the two halves, then the message gap
-  data->item(GREE_BIT_MARK, GREE_ZERO_SPACE);
-  data->item(GREE_BIT_MARK, GREE_ONE_SPACE);
-  data->item(GREE_BIT_MARK, GREE_ZERO_SPACE);
-  data->item(GREE_BIT_MARK, spaces.message);
-  data->item_bytes<GREE_BIT_TIMINGS>(frame.data() + 4, 4);
-  data->mark(GREE_BIT_MARK);
-}
-
-#ifdef USE_GREE_RECEIVER
-static constexpr uint8_t GREE_MODE_MASK = 0x07;
-static constexpr uint8_t GREE_POWER_MASK = 0x08;
-static constexpr uint8_t GREE_FAN_MASK = 0x30;
-static constexpr uint8_t GREE_SLEEP_MASK = 0x80;
-static constexpr uint8_t GREE_TEMP_MASK = 0x0F;
-static constexpr uint8_t GREE_TIMER_HALF_HOUR_MASK = 0x10;
-static constexpr uint8_t GREE_TIMER_TENS_HOUR_MASK = 0x60;
-static constexpr uint8_t GREE_TIMER_HOURS_MASK = 0x0F;
-static constexpr uint8_t GREE_BYTE5_FIXED_MASK = 0xB8;
-static constexpr uint8_t GREE_BYTE5_FIXED_VALUE = 0x20;
-
-static bool read_frame(remote_base::RemoteReceiveData &data, GreeState &frame, const GreeFrameSpaces &spaces) {
-  return data.expect_item(GREE_HEADER_MARK, spaces.header) && data.expect_bytes<GREE_BIT_TIMINGS>(frame.data(), 4) &&
-         data.expect_item(GREE_BIT_MARK, GREE_ZERO_SPACE) && data.expect_item(GREE_BIT_MARK, GREE_ONE_SPACE) &&
-         data.expect_item(GREE_BIT_MARK, GREE_ZERO_SPACE) && data.expect_item(GREE_BIT_MARK, spaces.message) &&
-         data.expect_bytes<GREE_BIT_TIMINGS>(frame.data() + 4, 4) && data.expect_mark(GREE_BIT_MARK);
-}
-
-#ifdef USE_GREE_YAW1F
-static bool is_yaw1f_followup(const GreeState &state) {
-  return state[3] == GREE_YAW1F_FOLLOWUP_BYTE && state[7] == GREE_YAW1F_FOLLOWUP_BYTE &&
-         (state[0] | state[1] | state[2] | state[4] | state[5] | state[6]) == 0;
-}
+  remote_state[0] = this->fan_speed_() | this->operation_mode_();
+#ifdef USE_GREE_FAHRENHEIT
+  const uint8_t half_steps = this->use_fahrenheit_ ? fahrenheit_half_steps(this->target_temperature) : 0;
+  remote_state[1] = this->use_fahrenheit_ ? half_steps >> 1 : this->temperature_();
+#else
+  remote_state[1] = this->temperature_();
 #endif
 
-// YAC sends a 0x70 follow-up frame and YAW1F a fixed second message; neither carries climate state.
-static bool is_auxiliary_frame(Model model, const GreeState &state) {
-#ifdef USE_GREE_YAW1F
-  if (model == GREE_YAW1F && is_yaw1f_followup(state))
-    return true;
-#endif
-  return model == GREE_YAC && (state[3] & 0xF0) == 0x70;
-}
-
-static bool is_valid_timer(const GreeState &state) {
-  const uint8_t timer_hours = state[2] & GREE_TIMER_HOURS_MASK;
-  const uint8_t timer_tens_hours = (state[1] & GREE_TIMER_TENS_HOUR_MASK) >> 5;
-  const bool timer_half_hour = state[1] & GREE_TIMER_HALF_HOUR_MASK;
-
-  if (timer_hours > 9 || timer_tens_hours > 2)
-    return false;
-  if (timer_tens_hours < 2)
-    return true;
-  return timer_hours < 4 || (timer_hours == 4 && !timer_half_hour);
-}
-
-static bool is_valid_vertical_swing(bool automatic, uint8_t position) {
-  if (automatic) {
-    return position == GREE_VDIR_SWING || position == GREE_VDIR_SWING_DOWN || position == GREE_VDIR_SWING_MIDDLE ||
-           position == GREE_VDIR_SWING_UP;
+  if (model == GREE_YAN) {
+    remote_state[3] = 0x50;  // bits 4..7 always 0101
+    remote_state[4] = this->vertical_swing_();
   }
-  return position == GREE_VDIR_MANUAL || (position >= GREE_VDIR_UP && position <= GREE_VDIR_DOWN);
-}
 
-static bool is_valid_swing(Model model, const GreeState &state) {
-  const bool automatic = state[0] & GREE_SWING_AUTO_MASK;
-  const uint8_t vertical = state[4] & 0x0F;
-  const uint8_t horizontal = state[4] >> 4;
+  if (model == GREE_YX1FF || yag_layout) {
+    remote_state[2] = 0x60;
+    remote_state[3] = 0x50;
+    remote_state[4] = this->vertical_swing_();
 
-  if (!is_valid_vertical_swing(automatic, vertical))
-    return false;
-  if (model == GREE_YX1FF)
-    return horizontal == (automatic ? GREE_HDIR_SWING : GREE_HDIR_MANUAL);
-  return horizontal == GREE_HDIR_MANUAL;
-}
+    if (model == GREE_YX1FF) {
+      // ModelA is set only when powered on.
+      if (this->mode == climate::CLIMATE_MODE_OFF)
+        remote_state[2] &= ~0x40;
+      // YX1FF needs the swing flag as well as its own vane-position value
+      if (this->vertical_swing_() == GREE_VDIR_SWING) {
+        remote_state[0] |= (1 << 6);
+        remote_state[4] = GREE_YX1FF_VANE_SWING;
+      }
+    }
+  }
 
-static climate::ClimateMode decode_operation_mode(uint8_t mode) {
-  if (mode == GREE_MODE_COOL)
-    return climate::CLIMATE_MODE_COOL;
-  if (mode == GREE_MODE_DRY)
-    return climate::CLIMATE_MODE_DRY;
-  if (mode == GREE_MODE_FAN)
-    return climate::CLIMATE_MODE_FAN_ONLY;
-  if (mode == GREE_MODE_HEAT)
-    return climate::CLIMATE_MODE_HEAT;
-  return climate::CLIMATE_MODE_HEAT_COOL;
-}
+  if (yag_layout) {
+    remote_state[5] = model == GREE_YAW1F ? 0x80 : 0x40;
+
+    if (this->vertical_swing_() == GREE_VDIR_SWING || this->horizontal_swing_() == GREE_HDIR_SWING) {
+      remote_state[0] |= (1 << 6);
+    }
+  }
+
+  if (model == GREE_YAC)
+    remote_state[4] = this->vertical_swing_();
+
+  if (model == GREE_YAC || yag_layout) {
+    remote_state[4] |= (this->horizontal_swing_() << 4);
+  }
+
+  if (model == GREE_YAA || model == GREE_YAC || model == GREE_YAC1FB9) {
+    remote_state[3] = 0x50;  // bits 4..7 always 0101
+    remote_state[6] = 0x20;  // YAA1FB, FAA1FB1, YB1F2 bits 4..7 always 0010
+
+    if (this->vertical_swing_() == GREE_VDIR_SWING) {
+      remote_state[0] |= (1 << 6);  // Enable swing by setting bit 6
+    } else if (this->vertical_swing_() != GREE_VDIR_AUTO) {
+      remote_state[5] = this->vertical_swing_();
+    }
+  }
+
+  if (model == GREE_YAN || model == GREE_YAA || model == GREE_YAC || model == GREE_YAC1FB9) {
+    // Merge the mode bits into remote_state[2]
+    // Clear the mode bits (bits 4-7) and OR in the current mode_bits_
+    remote_state[2] = (remote_state[2] & 0x0F) | this->mode_bits_;
+  }
 
-// Use if-else rather than lookup tables to avoid RAM usage on ESP8266.
-static climate::ClimateFanMode decode_fan_mode(Model model, uint8_t fan) {
-  if (fan == GREE_FAN_AUTO)
-    return climate::CLIMATE_FAN_AUTO;
   if (model == GREE_YX1FF) {
-    if (fan == GREE_FAN_1)
-      return climate::CLIMATE_FAN_QUIET;
-    if (fan == GREE_FAN_2)
-      return climate::CLIMATE_FAN_LOW;
-    return climate::CLIMATE_FAN_MEDIUM;
+    if (this->fan_mode.value_or(climate::CLIMATE_FAN_AUTO) == climate::CLIMATE_FAN_HIGH) {
+      remote_state[2] |= GREE_FAN_TURBO_BIT;
+    }
   }
-  if (fan == GREE_FAN_1)
-    return climate::CLIMATE_FAN_LOW;
-  if (fan == GREE_FAN_2)
-    return climate::CLIMATE_FAN_MEDIUM;
-  return climate::CLIMATE_FAN_HIGH;
-}
-#endif  // USE_GREE_RECEIVER
 
-void GreeProtocol::encode(remote_base::RemoteTransmitData *data, const GreeState &state) const {
-  const GreeFrameSpaces spaces = frame_spaces(this->model_);
-  data->reserve(this->model_ == GREE_YAW1F ? 280 : 140);
+  if (this->preset_() == GREE_PRESET_SLEEP) {
+    remote_state[0] |= GREE_PRESET_SLEEP_BIT;
+  }
+
+#ifdef USE_GREE_FAHRENHEIT
+  if (this->use_fahrenheit_) {
+    remote_state[3] |= GREE_FAHRENHEIT_BIT;
+    if (half_steps & 1)
+      remote_state[3] |= GREE_TEMP_HALF_DEGREE_BIT;
+  }
+#endif
+
+  remote_state[7] = frame_checksum(remote_state);
+
+  auto transmit = this->transmitter_->transmit();
+  auto *data = transmit.get_data();
   data->set_carrier_frequency(GREE_IR_FREQUENCY);
 
-  write_frame(data, state, spaces);
+  const bool long_gaps = model == GREE_YAC1FB9 || model == GREE_YAW1F;
+  const uint32_t header_space = long_gaps ? GREE_YAC1FB9_HEADER_SPACE : GREE_HEADER_SPACE;
+  const uint32_t message_space = long_gaps ? GREE_YAC1FB9_MESSAGE_SPACE : GREE_MESSAGE_SPACE;
+  auto encode = [&](const uint8_t *state) {
+    data->item(GREE_HEADER_MARK, header_space);
+    data->item_bytes<GREE_BIT_TIMINGS>(state, 4);
+    // Fixed 010 between the two halves, then the message gap
+    data->item(GREE_BIT_MARK, GREE_ZERO_SPACE);
+    data->item(GREE_BIT_MARK, GREE_ONE_SPACE);
+    data->item(GREE_BIT_MARK, GREE_ZERO_SPACE);
+    data->item(GREE_BIT_MARK, message_space);
+    data->item_bytes<GREE_BIT_TIMINGS>(state + 4, 4);
+    data->mark(GREE_BIT_MARK);
+  };
+
+  encode(remote_state);
 #ifdef USE_GREE_YAW1F
-  if (this->model_ == GREE_YAW1F) {
-    // The YAW1F remote follows every command with a fixed second message.
-    GreeState followup{};
-    followup[3] = followup[7] = GREE_YAW1F_FOLLOWUP_BYTE;
+  if (model == GREE_YAW1F) {
+    // The YAW1F remote follows every command with a second message, 00 00 00 A0 | 00 00 00 A0.
+    // The command buffer is reused so the payload takes no RAM on ESP8266.
+    std::fill_n(remote_state, sizeof(remote_state), 0);
+    remote_state[3] = remote_state[7] = 0xA0;
     data->space(GREE_YAW1F_FOLLOWUP_SPACE);
-    write_frame(data, followup, spaces);
+    encode(remote_state);
   }
 #endif
   data->space(0);
+
+  transmit.perform();
 }
 
-#ifdef USE_GREE_RECEIVER
-optional<GreeState> GreeProtocol::decode(remote_base::RemoteReceiveData data) const {
-  const GreeFrameSpaces spaces = frame_spaces(this->model_);
-  GreeState state{};
-  if (!read_frame(data, state, spaces) || !GreeProtocol::valid_checksum(state))
-    return {};
+uint8_t GreeClimate::operation_mode_() {
+  uint8_t operating_mode = GREE_MODE_ON;
 
-#ifdef USE_GREE_YAW1F
-  // Depending on receiver idle settings, YAW1F's ~40 ms second message may arrive in
-  // the same capture. Validate it completely; never treat it as climate state.
-  if (this->model_ == GREE_YAW1F && data.is_valid(1)) {
-    GreeState followup{};
-    if (!data.expect_space(GREE_YAW1F_FOLLOWUP_SPACE) || !read_frame(data, followup, spaces) ||
-        !is_yaw1f_followup(followup)) {
-      ESP_LOGV(TAG, "YAW1F frame dropped: second message invalid");
-      return {};
-    }
-  }
-#endif
-
-  // A receiver normally appends one final idle space. Reject any extra pulses.
-  if (data.is_valid(1) || (data.is_valid() && data.peek() > 0)) {
-    ESP_LOGV(TAG, "Frame dropped: extra pulses follow it (receiver idle may be too long)");
-    return {};
+  switch (this->mode) {
+    case climate::CLIMATE_MODE_COOL:
+      operating_mode |= GREE_MODE_COOL;
+      break;
+    case climate::CLIMATE_MODE_DRY:
+      operating_mode |= GREE_MODE_DRY;
+      break;
+    case climate::CLIMATE_MODE_HEAT:
+      operating_mode |= GREE_MODE_HEAT;
+      break;
+    case climate::CLIMATE_MODE_HEAT_COOL:
+      operating_mode |= GREE_MODE_AUTO;
+      break;
+    case climate::CLIMATE_MODE_FAN_ONLY:
+      operating_mode |= GREE_MODE_FAN;
+      break;
+    case climate::CLIMATE_MODE_OFF:
+    default:
+      operating_mode = GREE_MODE_OFF;
+      break;
   }
 
-  return state;
-}
-#endif  // USE_GREE_RECEIVER
-
-uint8_t GreeProtocol::calculate_checksum(const GreeState &state) {
-  uint8_t sum = 0x0A;
-  for (uint8_t pos = 0; pos < 4; pos++)
-    sum += state[pos] & 0x0F;
-  for (uint8_t pos = 4; pos < GREE_STATE_FRAME_SIZE - 1; pos++)
-    sum += state[pos] >> 4;
-  return (sum & 0x0F) << 4;
+  return operating_mode;
 }
 
-#ifdef USE_GREE_RECEIVER
-bool GreeProtocol::valid_checksum(const GreeState &state) {
-  return (state[GREE_STATE_FRAME_SIZE - 1] & 0xF0) == GreeProtocol::calculate_checksum(state);
-}
-#endif
-
-GreeState GreeClimateCodec::encode(Model model, const GreeClimateData &data) {
-  GreeState state{0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00};
-  const uint8_t vertical_swing = GreeClimateCodec::encode_vertical_swing(data.swing_mode);
-  const uint8_t horizontal_swing = GreeClimateCodec::encode_horizontal_swing(data.swing_mode);
-
-  state[0] =
-      GreeClimateCodec::encode_fan_mode(model, data.fan_mode) | GreeClimateCodec::encode_operation_mode(data.mode);
-  const uint8_t target_temperature = clamp<uint8_t>(data.target_temperature, GREE_TEMP_MIN, GREE_TEMP_MAX);
-  state[1] = target_temperature - GREE_TEMP_MIN;
-  state[2] = data.feature_bits & supported_feature_mask(model);
-  if (model != GREE_GENERIC)
-    state[3] = 0x50;
-
-  if (model == GREE_YAN)
-    state[4] = vertical_swing;
-
-  if (model == GREE_YB1FA || model == GREE_YX1FF) {
-    if (data.mode != climate::CLIMATE_MODE_OFF)
-      state[2] |= GREE_MODEL_A_BIT;
-    if (model == GREE_YX1FF && data.fan_mode == climate::CLIMATE_FAN_HIGH)
-      state[2] |= GREE_FAN_TURBO_BIT;
-    if (vertical_swing == GREE_VDIR_SWING) {
-      state[0] |= GREE_SWING_AUTO_MASK;
-      // YX1FF repeats the automatic swing value in both nibbles, while YB1FA only uses the vertical field.
-      state[4] = model == GREE_YX1FF ? GREE_YX1FF_VANE_SWING : GREE_VDIR_SWING;
+uint8_t GreeClimate::fan_speed_() {
+  // YX1FF has 4 fan speeds -- we treat low as quiet and turbo as high
+  if (this->model_ == GREE_YX1FF) {
+    switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
+      case climate::CLIMATE_FAN_QUIET:
+        return GREE_FAN_1;
+      case climate::CLIMATE_FAN_LOW:
+        return GREE_FAN_2;
+      case climate::CLIMATE_FAN_MEDIUM:
+      case climate::CLIMATE_FAN_HIGH:
+        // HIGH additionally sets the separate Turbo bit in byte 2.
+        return GREE_FAN_3;
+      case climate::CLIMATE_FAN_AUTO:
+      default:
+        return GREE_FAN_AUTO;
     }
   }
 
-  if (model == GREE_YAG || model == GREE_YAW1F) {
-    state[2] |= 0x60;
-    state[5] = model == GREE_YAW1F ? 0x80 : 0x40;
-    if (vertical_swing == GREE_VDIR_SWING || horizontal_swing == GREE_HDIR_SWING)
-      state[0] |= GREE_SWING_AUTO_MASK;
-  }
-
-  // YAC, like YAG, keeps vertical swing in the low nibble of byte 4; the byte 0 swing flag alone is not enough.
-  if (model == GREE_YAC || model == GREE_YAG || model == GREE_YAW1F)
-    state[4] = vertical_swing | (horizontal_swing << 4);
-
-  if (model == GREE_YAA || model == GREE_YAC || model == GREE_YAC1FB9) {
-    state[6] = 0x20;
-    if (vertical_swing == GREE_VDIR_SWING)
-      state[0] |= GREE_SWING_AUTO_MASK;
-  }
-
-  if ((model == GREE_YX1FF || model == GREE_YAC1FB9) && data.preset == climate::CLIMATE_PRESET_SLEEP)
-    state[0] |= GREE_PRESET_SLEEP_BIT;
-
-  if (data.fahrenheit) {
-    state[3] |= GREE_FAHRENHEIT_BIT;
-    if (data.half_degree)
-      state[3] |= GREE_TEMP_HALF_DEGREE_BIT;
-  }
-
-  state[GREE_STATE_FRAME_SIZE - 1] = GreeProtocol::calculate_checksum(state);
-  return state;
-}
-
-#ifdef USE_GREE_RECEIVER
-optional<GreeClimateData> GreeClimateCodec::decode(Model model, const GreeState &state) {
-  if (model == GREE_YB1FA || model == GREE_YX1FF)
-    return GreeClimateCodec::decode_model_a(model, state);
-  return GreeClimateCodec::decode_legacy(model, state);
-}
-#endif  // USE_GREE_RECEIVER
-
-uint8_t GreeClimateCodec::encode_operation_mode(climate::ClimateMode mode) {
-  if (mode == climate::CLIMATE_MODE_COOL)
-    return GREE_MODE_ON | GREE_MODE_COOL;
-  if (mode == climate::CLIMATE_MODE_DRY)
-    return GREE_MODE_ON | GREE_MODE_DRY;
-  if (mode == climate::CLIMATE_MODE_HEAT)
-    return GREE_MODE_ON | GREE_MODE_HEAT;
-  if (mode == climate::CLIMATE_MODE_HEAT_COOL)
-    return GREE_MODE_ON | GREE_MODE_AUTO;
-  if (mode == climate::CLIMATE_MODE_FAN_ONLY)
-    return GREE_MODE_ON | GREE_MODE_FAN;
-  return GREE_MODE_OFF;
-}
-
-uint8_t GreeClimateCodec::encode_fan_mode(Model model, climate::ClimateFanMode fan_mode) {
-  if (model == GREE_YX1FF) {
-    if (fan_mode == climate::CLIMATE_FAN_QUIET)
+  switch (this->fan_mode.value_or(climate::CLIMATE_FAN_ON)) {
+    case climate::CLIMATE_FAN_LOW:
       return GREE_FAN_1;
-    if (fan_mode == climate::CLIMATE_FAN_LOW)
+    case climate::CLIMATE_FAN_MEDIUM:
       return GREE_FAN_2;
-    if (fan_mode == climate::CLIMATE_FAN_MEDIUM || fan_mode == climate::CLIMATE_FAN_HIGH)
+    case climate::CLIMATE_FAN_HIGH:
       return GREE_FAN_3;
-    return GREE_FAN_AUTO;
+    case climate::CLIMATE_FAN_AUTO:
+    default:
+      return GREE_FAN_AUTO;
   }
-
-  if (fan_mode == climate::CLIMATE_FAN_LOW)
-    return GREE_FAN_1;
-  if (fan_mode == climate::CLIMATE_FAN_MEDIUM)
-    return GREE_FAN_2;
-  if (fan_mode == climate::CLIMATE_FAN_HIGH)
-    return GREE_FAN_3;
-  return GREE_FAN_AUTO;
 }
 
-uint8_t GreeClimateCodec::encode_horizontal_swing(climate::ClimateSwingMode swing_mode) {
-  switch (swing_mode) {
+uint8_t GreeClimate::horizontal_swing_() {
+  switch (this->swing_mode) {
     case climate::CLIMATE_SWING_HORIZONTAL:
     case climate::CLIMATE_SWING_BOTH:
       return GREE_HDIR_SWING;
@@ -341,8 +243,8 @@ uint8_t GreeClimateCodec::encode_horizontal_swing(climate::ClimateSwingMode swin
   }
 }
 
-uint8_t GreeClimateCodec::encode_vertical_swing(climate::ClimateSwingMode swing_mode) {
-  switch (swing_mode) {
+uint8_t GreeClimate::vertical_swing_() {
+  switch (this->swing_mode) {
     case climate::CLIMATE_SWING_VERTICAL:
     case climate::CLIMATE_SWING_BOTH:
       return GREE_VDIR_SWING;
@@ -351,273 +253,24 @@ uint8_t GreeClimateCodec::encode_vertical_swing(climate::ClimateSwingMode swing_
   }
 }
 
-#ifdef USE_GREE_RECEIVER
-optional<GreeClimateData> GreeClimateCodec::decode_legacy(Model model, const GreeState &state) {
-  if (is_auxiliary_frame(model, state))
-    return {};
-
-  const uint8_t mode = state[0] & GREE_MODE_MASK;
-  const bool power = state[0] & GREE_POWER_MASK;
-  const uint8_t fan = state[0] & GREE_FAN_MASK;
-  const uint8_t temperature = state[1] & GREE_TEMP_MASK;
-
-  // Legacy GREE-branded remotes have several model and OEM variants. Decode the fields that are stable across the
-  // protocol, but do not require the transmitter-side fixed bytes: physical Tadiran/Tosot/GREE remotes may populate
-  // timer, display-temperature, I-Feel, WiFi, vane-position, or otherwise unused fields differently.
-  if (mode > GREE_MODE_HEAT || temperature > GREE_TEMP_MAX - GREE_TEMP_MIN)
-    return {};
-
-  const uint8_t vertical = state[4] & 0x0F;
-  const uint8_t horizontal = (state[4] >> 4) & 0x07;
-  bool swing_vertical = false;
-  bool swing_horizontal = false;
-
-  switch (model) {
-    case GREE_YAG:
-    case GREE_YAW1F:
-    case GREE_YAC:
-      // On YAC1FB bit 6 does not reliably identify vertical swing; use vane fields for both axes.
-      swing_vertical = is_valid_vertical_swing(true, vertical);
-      swing_horizontal = horizontal == GREE_HDIR_SWING;
-      break;
-    case GREE_GENERIC:
-    case GREE_YAN:
-    case GREE_YAA:
-    case GREE_YAC1FB9:
-    default:
-      // ESPHome's YAN transmitter stores automatic vertical swing in byte 4, while YAA/YAC1FB9 use bit 6.
-      // Accept either representation so branded remotes using the standard GREE layout are handled as well.
-      swing_vertical = (state[0] & GREE_SWING_AUTO_MASK) || is_valid_vertical_swing(true, vertical);
-      break;
-  }
-
-  GreeClimateData data{
-      .mode = climate::CLIMATE_MODE_OFF,
-      .target_temperature = static_cast<uint8_t>(GREE_TEMP_MIN + temperature),
-      .fan_mode = climate::CLIMATE_FAN_AUTO,
-      .swing_mode = climate::CLIMATE_SWING_OFF,
-      .preset = model == GREE_YAC1FB9 && (state[0] & GREE_SLEEP_MASK) ? climate::CLIMATE_PRESET_SLEEP
-                                                                      : climate::CLIMATE_PRESET_NONE,
-      .feature_bits = static_cast<uint8_t>(state[2] & supported_feature_mask(model)),
-      .fahrenheit = static_cast<bool>(state[3] & GREE_FAHRENHEIT_BIT),
-      .half_degree = static_cast<bool>(state[3] & GREE_TEMP_HALF_DEGREE_BIT),
-  };
-
-  if (swing_vertical && swing_horizontal) {
-    data.swing_mode = climate::CLIMATE_SWING_BOTH;
-  } else if (swing_vertical) {
-    data.swing_mode = climate::CLIMATE_SWING_VERTICAL;
-  } else if (swing_horizontal) {
-    data.swing_mode = climate::CLIMATE_SWING_HORIZONTAL;
-  }
-
-  if (power)
-    data.mode = decode_operation_mode(mode);
-
-  data.fan_mode = decode_fan_mode(model, fan);
-
-  return data;
+uint8_t GreeClimate::temperature_() {
+  return (uint8_t) roundf(clamp<float>(this->target_temperature, GREE_TEMP_MIN, GREE_TEMP_MAX)) - GREE_TEMP_MIN;
 }
 
-optional<GreeClimateData> GreeClimateCodec::decode_model_a(Model model, const GreeState &state) {
-  const uint8_t mode = state[0] & GREE_MODE_MASK;
-  const bool power = state[0] & GREE_POWER_MASK;
-  const uint8_t fan = state[0] & GREE_FAN_MASK;
-  const bool swing = state[0] & GREE_SWING_AUTO_MASK;
-  const bool turbo = state[2] & GREE_FAN_TURBO_BIT;
-  const uint8_t temperature = state[1] & GREE_TEMP_MASK;
-
-  // Validate fields that are not represented by Climate where possible. Supported independent feature state is
-  // returned separately so the parent can synchronize its feature switches.
-  if (mode > GREE_MODE_HEAT || temperature > GREE_TEMP_MAX - GREE_TEMP_MIN || !is_valid_timer(state) ||
-      static_cast<bool>(state[2] & GREE_MODEL_A_BIT) != power ||
-      (state[3] & ~(GREE_FAHRENHEIT_BIT | GREE_TEMP_HALF_DEGREE_BIT)) != 0x50 || !is_valid_swing(model, state) ||
-      (state[5] & GREE_BYTE5_FIXED_MASK) != GREE_BYTE5_FIXED_VALUE || state[6] != 0x00 || (state[7] & 0x0F) != 0x00 ||
-      (model == GREE_YX1FF && turbo && fan != GREE_FAN_3)) {
-    return {};
-  }
-
-  GreeClimateData data{
-      .mode = climate::CLIMATE_MODE_OFF,
-      .target_temperature = static_cast<uint8_t>(GREE_TEMP_MIN + temperature),
-      .fan_mode = climate::CLIMATE_FAN_AUTO,
-      .swing_mode = swing ? climate::CLIMATE_SWING_VERTICAL : climate::CLIMATE_SWING_OFF,
-      .preset = model == GREE_YX1FF && state[0] & GREE_SLEEP_MASK ? climate::CLIMATE_PRESET_SLEEP
-                                                                  : climate::CLIMATE_PRESET_NONE,
-      .feature_bits = static_cast<uint8_t>(state[2] & supported_feature_mask(model)),
-      .fahrenheit = static_cast<bool>(state[3] & GREE_FAHRENHEIT_BIT),
-      .half_degree = static_cast<bool>(state[3] & GREE_TEMP_HALF_DEGREE_BIT),
-  };
-
-  if (power)
-    data.mode = decode_operation_mode(mode);
-
-  data.fan_mode = turbo ? climate::CLIMATE_FAN_HIGH : decode_fan_mode(model, fan);
-
-  return data;
-}
-#endif  // USE_GREE_RECEIVER
-
-void GreeClimate::set_model(Model model) {
-  if (model == GREE_YAN || model == GREE_YB1FA || model == GREE_YX1FF) {
-    // These remotes only expose a vertical swing control.
-    this->swing_modes_.erase(climate::CLIMATE_SWING_HORIZONTAL);
-    this->swing_modes_.erase(climate::CLIMATE_SWING_BOTH);
-  }
-  if (model == GREE_YX1FF)
-    this->fan_modes_.insert(climate::CLIMATE_FAN_QUIET);
-  if (model == GREE_YX1FF || model == GREE_YAC1FB9) {
-    this->presets_.insert(climate::CLIMATE_PRESET_NONE);
-    this->presets_.insert(climate::CLIMATE_PRESET_SLEEP);
-  }
-
-  this->model_ = model;
-  this->feature_bits_ = default_feature_bits(model);
-}
-
-void GreeClimate::set_feature_state(GreeFeature feature, bool enabled) {
-  const uint8_t bit = gree_feature_bit(feature);
-  if (!(supported_feature_mask(this->model_) & bit)) {
-    ESP_LOGW(TAG, "GREE model %u does not support feature %u", static_cast<unsigned>(this->model_),
-             static_cast<unsigned>(feature));
-#ifdef USE_GREE_FEATURE_SWITCH
-    this->publish_feature_state_(feature);
-#endif
-    return;
-  }
-
-  // YB1FA reports Turbo as effective HIGH fan. Keep the Climate and feature entities consistent when Turbo is enabled.
-  const bool fan_changed = this->model_ == GREE_YB1FA && feature == GREE_FEATURE_TURBO && enabled &&
-                           this->fan_mode.value_or(climate::CLIMATE_FAN_AUTO) != climate::CLIMATE_FAN_HIGH;
-  if (fan_changed)
-    this->fan_mode = climate::CLIMATE_FAN_HIGH;
-
-  assign_bits(this->feature_bits_, bit, enabled);
-  this->transmit_state();
-#ifdef USE_GREE_FEATURE_SWITCH
-  this->publish_feature_state_(feature);
-#endif
-  if (fan_changed)
-    this->publish_state();
-}
-
-bool GreeClimate::get_feature_state(GreeFeature feature) const {
-  return this->feature_bits_ & gree_feature_bit(feature);
-}
-
-#ifdef USE_GREE_FEATURE_SWITCH
-void GreeClimate::setup() {
-  climate_ir::ClimateIR::setup();
-  // Apply every restored switch, then send one frame. Models that receive feature state have restoring disabled,
-  // so their switches show the current feature bits instead.
-  bool restored = false;
-  for (size_t feature = 0; feature < this->feature_switches_.size(); feature++) {
-    auto *feature_switch = this->feature_switches_[feature];
-    if (feature_switch == nullptr)
-      continue;
-    if (auto initial = feature_switch->get_initial_state_with_restore_mode()) {
-      // What control() would hand the switch's apply body
-      assign_bits(this->feature_bits_, gree_feature_bit(static_cast<GreeFeature>(feature)),
-                  *initial != feature_switch->is_inverted());
-      restored = true;
+uint8_t GreeClimate::preset_() {
+  // YX1FF and YAC1FB9 have sleep preset
+  if (this->model_ == GREE_YX1FF || this->model_ == GREE_YAC1FB9) {
+    switch (this->preset.value_or(climate::CLIMATE_PRESET_NONE)) {
+      case climate::CLIMATE_PRESET_NONE:
+        return GREE_PRESET_NONE;
+      case climate::CLIMATE_PRESET_SLEEP:
+        return GREE_PRESET_SLEEP;
+      default:
+        return GREE_PRESET_NONE;
     }
-    this->publish_feature_state_(static_cast<GreeFeature>(feature));
-  }
-  if (restored)
-    this->transmit_state();
-}
-
-void GreeClimate::register_feature_switch(GreeFeature feature, switch_::Switch *feature_switch) {
-  this->feature_switches_[static_cast<uint8_t>(feature)] = feature_switch;
-}
-
-void GreeClimate::publish_feature_state_(GreeFeature feature) {
-  auto *feature_switch = this->feature_switches_[static_cast<uint8_t>(feature)];
-  if (feature_switch != nullptr)
-    feature_switch->publish_state(this->get_feature_state(feature));
-}
-
-#ifdef USE_GREE_RECEIVER
-void GreeClimate::publish_feature_states_() {
-  for (size_t feature = 0; feature < this->feature_switches_.size(); feature++)
-    this->publish_feature_state_(static_cast<GreeFeature>(feature));
-}
-#endif
-#endif  // USE_GREE_FEATURE_SWITCH
-
-void GreeClimate::control(const climate::ClimateCall &call) {
-  // An explicit fan selection exits YB1FA Turbo. Disabling Turbo itself leaves the effective HIGH fan selected.
-  const bool clear_turbo =
-      this->model_ == GREE_YB1FA && call.get_fan_mode().has_value() && this->get_feature_state(GREE_FEATURE_TURBO);
-  if (clear_turbo) {
-    this->feature_bits_ &= ~GREE_MODE_BIT_TURBO;
-#ifdef USE_GREE_FEATURE_SWITCH
-    this->publish_feature_state_(GREE_FEATURE_TURBO);
-#endif
-  }
-  climate_ir::ClimateIR::control(call);
-}
-
-void GreeClimate::transmit_state() {
-  GreeClimateData climate_data{
-      .mode = this->mode,
-      .target_temperature =
-          static_cast<uint8_t>(roundf(clamp<float>(this->target_temperature, GREE_TEMP_MIN, GREE_TEMP_MAX))),
-      .fan_mode = this->fan_mode.value_or(climate::CLIMATE_FAN_AUTO),
-      .swing_mode = this->swing_mode,
-      .preset = this->preset.value_or(climate::CLIMATE_PRESET_NONE),
-      .feature_bits = this->feature_bits_,
-  };
-#ifdef USE_GREE_FAHRENHEIT
-  if (this->use_fahrenheit_) {
-    const uint8_t half_steps = fahrenheit_half_steps(this->target_temperature);
-    climate_data.target_temperature = GREE_TEMP_MIN + (half_steps >> 1);
-    climate_data.fahrenheit = true;
-    climate_data.half_degree = half_steps & 1;
-  }
-#endif
-  const GreeState state = GreeClimateCodec::encode(this->model_, climate_data);
-
-  auto transmit = this->transmitter_->transmit();
-  GreeProtocol(this->model_).encode(transmit.get_data(), state);
-  transmit.perform();
-}
-
-#ifdef USE_GREE_RECEIVER
-bool GreeClimate::on_receive(remote_base::RemoteReceiveData data) {
-  auto state = GreeProtocol(this->model_).decode(data);
-  if (!state.has_value())
-    return false;
-
-  auto decoded = GreeClimateCodec::decode(this->model_, *state);
-  if (!decoded.has_value()) {
-    ESP_LOGD(TAG, "GREE frame rejected for model %u: %02X %02X %02X %02X %02X %02X %02X %02X",
-             static_cast<unsigned>(this->model_), (*state)[0], (*state)[1], (*state)[2], (*state)[3], (*state)[4],
-             (*state)[5], (*state)[6], (*state)[7]);
-    return false;
   }
 
-  this->mode = decoded->mode;
-  const int half_steps = 2 * (decoded->target_temperature - GREE_TEMP_MIN) + decoded->half_degree;
-  float target = GREE_TEMP_MIN + 0.5f * half_steps;
-  // The panel shows (10 * 32 + 18 * GREE_TEMP_MIN + 9 * k) / 10 F; store that degree so it is sent back unchanged
-  if (decoded->fahrenheit) {
-    // The remote truncates the displayed Fahrenheit degree; retain that exact integer
-    // through subsequent feature-only and fan-only transmissions.
-    const int fahrenheit_degree = (10 * 32 + 18 * GREE_TEMP_MIN + 9 * half_steps) / 10;
-    target = fahrenheit_to_celsius(static_cast<float>(fahrenheit_degree));
-  }
-  this->target_temperature = target;
-  this->fan_mode = decoded->fan_mode;
-  this->swing_mode = decoded->swing_mode;
-  this->preset = decoded->preset;
-  this->feature_bits_ = decoded->feature_bits;
-#ifdef USE_GREE_FEATURE_SWITCH
-  this->publish_feature_states_();
-#endif
-  this->publish_state();
-  return true;
+  return GREE_PRESET_NONE;
 }
-#endif  // USE_GREE_RECEIVER
 
 }  // namespace esphome::gree

esphome/components/gree/gree.h

@@ -1,12 +1,7 @@
 #pragma once
 
-#include <array>
-
 #include "esphome/components/climate_ir/climate_ir.h"
 #include "esphome/core/defines.h"
-#ifdef USE_GREE_FEATURE_SWITCH
-#include "esphome/components/switch/switch.h"
-#endif
 
 namespace esphome::gree {
 
@@ -45,15 +40,18 @@ static constexpr uint32_t GREE_YAC_HEADER_MARK = 6000;
 static constexpr uint32_t GREE_YAC_HEADER_SPACE = 3000;
 static constexpr uint32_t GREE_YAC_BIT_MARK = 650;
 
-// YAW1F shares the longer YAC1FB9 header and inter-block gap.
+// Timing specific to YAC1FB9
+// Also used by YAW1F
 static constexpr uint32_t GREE_YAC1FB9_HEADER_SPACE = 4500;
 static constexpr uint32_t GREE_YAC1FB9_MESSAGE_SPACE = 19980;
-// Gap between the YAW1F primary command and its fixed second message.
+
+// YAW1F: every command is followed by a second 8-byte message after this gap
 static constexpr uint32_t GREE_YAW1F_FOLLOWUP_SPACE = 40000;
 
 // State Frame size
 static constexpr uint8_t GREE_STATE_FRAME_SIZE = 8;
 
+// Only available on YAN
 // Vertical air directions. Note that these cannot be set on all heat pumps
 static constexpr uint8_t GREE_VDIR_AUTO = 0x00;
 static constexpr uint8_t GREE_VDIR_MANUAL = 0x00;
@@ -65,9 +63,6 @@ static constexpr uint8_t GREE_VDIR_MDOWN = 0x05;
 static constexpr uint8_t GREE_VDIR_DOWN = 0x06;
 // YX1FF vane-position byte while swinging
 static constexpr uint8_t GREE_YX1FF_VANE_SWING = 0x11;
-static constexpr uint8_t GREE_VDIR_SWING_DOWN = 0x07;
-static constexpr uint8_t GREE_VDIR_SWING_MIDDLE = 0x09;
-static constexpr uint8_t GREE_VDIR_SWING_UP = 0x0B;
 
 // Only available on YAC/YAG
 // Horizontal air directions. Note that these cannot be set on all heat pumps
@@ -80,7 +75,17 @@ static constexpr uint8_t GREE_HDIR_MIDDLE = 0x04;
 static constexpr uint8_t GREE_HDIR_MRIGHT = 0x05;
 static constexpr uint8_t GREE_HDIR_RIGHT = 0x06;
 
-// Feature bits in byte 2
+// Only available on YX1FF
+// Turbo (high) fan mode
+static constexpr uint8_t GREE_FAN_TURBO_BIT = 0x10;
+
+// Available on YX1FF and YAC1FB9
+// Sleep preset mode
+static constexpr uint8_t GREE_PRESET_NONE = 0x00;
+static constexpr uint8_t GREE_PRESET_SLEEP = 0x01;
+static constexpr uint8_t GREE_PRESET_SLEEP_BIT = 0x80;
+
+// Mode bits stored in remote_state[2] bits 4..7 for YAN/YAA/YAC/YAC1FB9.
 static constexpr uint8_t GREE_MODE_BIT_TURBO = 0x10;
 static constexpr uint8_t GREE_MODE_BIT_LIGHT = 0x20;
 static constexpr uint8_t GREE_MODE_BIT_HEALTH = 0x40;
@@ -90,94 +95,24 @@ static constexpr uint8_t GREE_MODE_BIT_XFAN = 0x80;
 static constexpr uint8_t GREE_FAHRENHEIT_BIT = 0x08;
 static constexpr uint8_t GREE_TEMP_HALF_DEGREE_BIT = 0x04;  // Half a degree Celsius added to the temperature
 
+/// Checksum of a state frame: the low nibbles of bytes 0-3 plus the high nibbles of bytes 4-6 plus 0x0A, in the high
+/// nibble.
+inline uint8_t frame_checksum(const uint8_t *remote_state) {
+  return (
+      (((remote_state[0] & 0x0F) + (remote_state[1] & 0x0F) + (remote_state[2] & 0x0F) + (remote_state[3] & 0x0F) +
+        ((remote_state[4] & 0xF0) >> 4) + ((remote_state[5] & 0xF0) >> 4) + ((remote_state[6] & 0xF0) >> 4) + 0x0A) &
+       0x0F)
+      << 4);
+}
+
 #ifdef USE_GREE_FAHRENHEIT
 /// Return k = 2 * temp_field + half_degree_bit (0..28) for a Celsius target. The unit displays
 /// trunc(celsius_to_fahrenheit(GREE_TEMP_MIN + k / 2)), so k is the smallest value that shows the target in F.
 uint8_t fahrenheit_half_steps(float target_celsius);
 #endif
 
-// Model-specific meanings for the same bit positions on YB1FA/YX1FF.
-static constexpr uint8_t GREE_FAN_TURBO_BIT = 0x10;
-static constexpr uint8_t GREE_MODEL_A_BIT = 0x40;
-
-// Only available on YX1FF
-// Sleep preset mode
-static constexpr uint8_t GREE_PRESET_NONE = 0x00;
-static constexpr uint8_t GREE_PRESET_SLEEP = 0x01;
-static constexpr uint8_t GREE_PRESET_SLEEP_BIT = 0x80;
-
 // Model codes
-enum Model : uint8_t {
-  GREE_GENERIC,
-  GREE_YAN,
-  GREE_YAA,
-  GREE_YAC,
-  GREE_YAC1FB9,
-  GREE_YB1FA,
-  GREE_YX1FF,
-  GREE_YAG,
-  GREE_YAW1F
-};
-
-enum GreeFeature : uint8_t {
-  GREE_FEATURE_TURBO = 0,
-  GREE_FEATURE_LIGHT = 1,
-  GREE_FEATURE_HEALTH = 2,
-  GREE_FEATURE_XFAN = 3,
-};
-
-static constexpr uint8_t gree_feature_bit(GreeFeature feature) { return GREE_MODE_BIT_TURBO << feature; }
-
-using GreeState = std::array<uint8_t, GREE_STATE_FRAME_SIZE>;
-
-struct GreeClimateData {
-  climate::ClimateMode mode;
-  uint8_t target_temperature;
-  climate::ClimateFanMode fan_mode;
-  climate::ClimateSwingMode swing_mode;
-  climate::ClimatePreset preset;
-  uint8_t feature_bits{0};
-  // The unit's panel shows Fahrenheit; half_degree adds half a degree Celsius to target_temperature
-  bool fahrenheit{false};
-  bool half_degree{false};
-};
-
-class GreeProtocol {
- public:
-  explicit GreeProtocol(Model model) : model_(model) {}
-
-  void encode(remote_base::RemoteTransmitData *data, const GreeState &state) const;
-#ifdef USE_GREE_RECEIVER
-  optional<GreeState> decode(remote_base::RemoteReceiveData data) const;
-#endif
-
-  static uint8_t calculate_checksum(const GreeState &state);
-#ifdef USE_GREE_RECEIVER
-  static bool valid_checksum(const GreeState &state);
-#endif
-
- protected:
-  Model model_;
-};
-
-class GreeClimateCodec {
- public:
-  static GreeState encode(Model model, const GreeClimateData &data);
-#ifdef USE_GREE_RECEIVER
-  /// Decode a frame whose checksum the protocol layer already checked.
-  static optional<GreeClimateData> decode(Model model, const GreeState &state);
-#endif
-
- protected:
-  static uint8_t encode_operation_mode(climate::ClimateMode mode);
-  static uint8_t encode_fan_mode(Model model, climate::ClimateFanMode fan_mode);
-  static uint8_t encode_horizontal_swing(climate::ClimateSwingMode swing_mode);
-  static uint8_t encode_vertical_swing(climate::ClimateSwingMode swing_mode);
-#ifdef USE_GREE_RECEIVER
-  static optional<GreeClimateData> decode_legacy(Model model, const GreeState &state);
-  static optional<GreeClimateData> decode_model_a(Model model, const GreeState &state);
-#endif
-};
+enum Model : uint8_t { GREE_GENERIC, GREE_YAN, GREE_YAA, GREE_YAC, GREE_YAC1FB9, GREE_YX1FF, GREE_YAG, GREE_YAW1F };
 
 class GreeClimate final : public climate_ir::ClimateIR {
  public:
@@ -188,38 +123,25 @@ class GreeClimate final : public climate_ir::ClimateIR {
                               {climate::CLIMATE_SWING_OFF, climate::CLIMATE_SWING_VERTICAL,
                                climate::CLIMATE_SWING_HORIZONTAL, climate::CLIMATE_SWING_BOTH}) {}
 
-#ifdef USE_GREE_FEATURE_SWITCH
-  void setup() override;
-#endif
   void set_model(Model model);
 #ifdef USE_GREE_FAHRENHEIT
   void set_use_fahrenheit(bool use_fahrenheit) { this->use_fahrenheit_ = use_fahrenheit; }
 #endif
-  void set_feature_state(GreeFeature feature, bool enabled);
-  bool get_feature_state(GreeFeature feature) const;
-#ifdef USE_GREE_FEATURE_SWITCH
-  void register_feature_switch(GreeFeature feature, switch_::Switch *feature_switch);
-#endif
+  void set_mode_bit(uint8_t bit_mask, bool enabled);
 
  protected:
-  void control(const climate::ClimateCall &call) override;
   // Transmit via IR the state of this climate controller.
   void transmit_state() override;
-#ifdef USE_GREE_RECEIVER
-  bool on_receive(remote_base::RemoteReceiveData data) override;
-#endif
 
-#ifdef USE_GREE_FEATURE_SWITCH
-  void publish_feature_state_(GreeFeature feature);
-#ifdef USE_GREE_RECEIVER
-  void publish_feature_states_();
-#endif
-
-  std::array<switch_::Switch *, 4> feature_switches_{};
-#endif
+  uint8_t operation_mode_();
+  uint8_t fan_speed_();
+  uint8_t horizontal_swing_();
+  uint8_t vertical_swing_();
+  uint8_t temperature_();
+  uint8_t preset_();
 
   Model model_{};
-  uint8_t feature_bits_{0};
+  uint8_t mode_bits_{GREE_MODE_BIT_LIGHT};  // The display light is on until a switch says otherwise
 #ifdef USE_GREE_FAHRENHEIT
   bool use_fahrenheit_{false};
 #endif

esphome/components/gree/switch/__init__.py

@@ -1,17 +1,7 @@
-from collections.abc import Callable
-
 import esphome.codegen as cg
 from esphome.components import switch
 import esphome.config_validation as cv
-from esphome.const import (
-    CONF_INITIAL_STATE,
-    CONF_LIGHT,
-    CONF_RESTORE_MODE,
-    CONF_RESTORE_STATE,
-    DEVICE_CLASS_SWITCH,
-    ENTITY_CATEGORY_CONFIG,
-)
-from esphome.core import CORE
+from esphome.const import CONF_LIGHT, DEVICE_CLASS_SWITCH, ENTITY_CATEGORY_CONFIG
 import esphome.final_validate as fv
 from esphome.types import ConfigType
 
@@ -20,174 +10,77 @@ from ..climate import CONF_MODEL, GreeClimate
 
 CODEOWNERS = ["@nagyrobi"]
 
-GreeFeature = gree_ns.enum("GreeFeature")
+GreeModeBitSwitch = gree_ns.class_("GreeModeBitSwitch", switch.Switch, cg.Component)
 
 CONF_TURBO = "turbo"
 CONF_HEALTH = "health"
 CONF_XFAN = "xfan"
 CONF_GREE_ID = "gree_id"
 
-# Switch configurations: (config_key, feature, icon, default_restore_mode)
+# Switch configurations: (config_key, display_name, mode_bit, icon)
 SWITCH_CONFIGS = (
     (
         CONF_TURBO,
-        GreeFeature.GREE_FEATURE_TURBO,
+        "Gree Turbo Switch",
+        gree_ns.GREE_MODE_BIT_TURBO,
         "mdi:car-turbocharger",
-        "RESTORE_DEFAULT_OFF",
-    ),
-    # The display light was on before the switches existed, so it stays on by default
-    (
-        CONF_LIGHT,
-        GreeFeature.GREE_FEATURE_LIGHT,
-        "mdi:led-outline",
-        "RESTORE_DEFAULT_ON",
-    ),
-    (
-        CONF_HEALTH,
-        GreeFeature.GREE_FEATURE_HEALTH,
-        "mdi:pine-tree",
-        "RESTORE_DEFAULT_OFF",
     ),
+    (CONF_LIGHT, "Gree Light Switch", gree_ns.GREE_MODE_BIT_LIGHT, "mdi:led-outline"),
+    (CONF_HEALTH, "Gree Health Switch", gree_ns.GREE_MODE_BIT_HEALTH, "mdi:pine-tree"),
     (
         CONF_XFAN,
-        GreeFeature.GREE_FEATURE_XFAN,
+        "Gree X-FAN Switch",
+        gree_ns.GREE_MODE_BIT_XFAN,
         "mdi:wall-sconce-flat",
-        "RESTORE_DEFAULT_OFF",
     ),
 )
 
-ALL_FEATURES = frozenset(key for key, *_ in SWITCH_CONFIGS)
-MODEL_FEATURES = {
-    "yan": ALL_FEATURES,
-    "yaa": ALL_FEATURES,
-    "yac": ALL_FEATURES,
-    "yac1fb9": ALL_FEATURES,
-    "yb1fa": ALL_FEATURES - {CONF_HEALTH},
-    "yx1ff": frozenset({CONF_LIGHT}),
+SUPPORTED_MODELS = {
+    "yan",
+    "yaa",
+    "yac",
+    "yac1fb9",
 }
-# These models receive feature state over IR, so the switches follow it instead of restoring
-RX_FEATURE_MODELS = frozenset({"yb1fa", "yx1ff"})
-
-_RESTORE_KEYS = (CONF_RESTORE_MODE, CONF_RESTORE_STATE, CONF_INITIAL_STATE)
-
-
-def _feature_switch_schema(
-    icon: str, default_restore_mode: str
-) -> Callable[[ConfigType], ConfigType]:
-    schema = switch.switch_schema(
-        switch.ApplySwitch,
-        icon=icon,
-        default_restore_mode=default_restore_mode,
-        device_class=DEVICE_CLASS_SWITCH,
-        entity_category=ENTITY_CATEGORY_CONFIG,
-    )
-
-    def validator(value: ConfigType) -> ConfigType:
-        explicit = isinstance(value, dict) and any(
-            key in value for key in _RESTORE_KEYS
-        )
-        config = schema(value)
-        # Leave an omitted restore mode unset, so final validation can tell it from an explicit one
-        # and to_code can fill in the default for the model.
-        if not explicit:
-            config.pop(CONF_RESTORE_MODE, None)
-        return config
-
-    return validator
-
 
 CONFIG_SCHEMA = cv.Schema(
     {
         cv.Required(CONF_GREE_ID): cv.use_id(GreeClimate),
         **{
-            cv.Optional(key): _feature_switch_schema(icon, default_restore_mode)
-            for key, _, icon, default_restore_mode in SWITCH_CONFIGS
+            cv.Optional(key): switch.switch_schema(
+                GreeModeBitSwitch,
+                icon=icon,
+                # The display light was on before the switches existed, so it stays on by default
+                default_restore_mode="RESTORE_DEFAULT_ON"
+                if key == CONF_LIGHT
+                else "RESTORE_DEFAULT_OFF",
+                device_class=DEVICE_CLASS_SWITCH,
+                entity_category=ENTITY_CATEGORY_CONFIG,
+            )
+            for key, _, _, icon in SWITCH_CONFIGS
         },
     }
 )
 
 
-def _validate_features_for_model(model: str, config: ConfigType) -> None:
-    supported_features = MODEL_FEATURES.get(model)
-    if supported_features is None:
+def _validate_model(config: ConfigType) -> None:
+    climate_conf = fv.get_declaring_config(config[CONF_GREE_ID])
+    if climate_conf[CONF_MODEL] not in SUPPORTED_MODELS:
         raise cv.Invalid(
             "Gree switches are only supported for the "
-            + ", ".join(sorted(MODEL_FEATURES))
+            + ", ".join(SUPPORTED_MODELS)
             + " models"
         )
 
-    configured_features = {key for key, *_ in SWITCH_CONFIGS if key in config}
-    if unsupported := configured_features - supported_features:
-        suffix = "switch" if len(unsupported) == 1 else "switches"
-        raise cv.Invalid(
-            f"Gree model {model} does not support the "
-            + ", ".join(sorted(unsupported))
-            + f" {suffix}"
-        )
 
-
-def _validate_model(config: ConfigType) -> None:
-    model = fv.get_declaring_config(config[CONF_GREE_ID])[CONF_MODEL]
-    _validate_features_for_model(model, config)
-    if model not in RX_FEATURE_MODELS:
-        return
-    for feature, *_ in SWITCH_CONFIGS:
-        if (feature_conf := config.get(feature)) is None:
-            continue
-        if (
-            CONF_RESTORE_STATE in feature_conf
-            or str(feature_conf.get(CONF_RESTORE_MODE, "DISABLED")) != "DISABLED"
-        ):
-            raise cv.Invalid(
-                f"Gree model {model} receives {feature} state from IR; "
-                "restore_mode must be DISABLED or omitted",
-                path=[feature],
-            )
-
-
-# The climate keeps one switch per feature, so a second entry would take over the first
-_validate_unique = fv.unique_platform_key(
-    domain=switch.DOMAIN,
-    platform="gree",
-    keys=(CONF_GREE_ID,),
-    message="Only one gree switch entry is allowed per climate ('{gree_id}')",
-)
-
-
-def _final_validate(config: ConfigType) -> None:
-    _validate_unique(config)
-    _validate_model(config)
-
-
-FINAL_VALIDATE_SCHEMA = _final_validate
-
-
-def _with_default_restore_mode(
-    feature_conf: ConfigType, default_restore_mode: str, receives_state: bool
-) -> ConfigType:
-    """Fill in the model's restore mode when none was configured."""
-    if CONF_RESTORE_MODE in feature_conf or CONF_RESTORE_STATE in feature_conf:
-        return feature_conf
-    mode = "DISABLED" if receives_state else default_restore_mode
-    return {**feature_conf, CONF_RESTORE_MODE: switch.RESTORE_MODES[mode]}
+FINAL_VALIDATE_SCHEMA = _validate_model
 
 
 async def to_code(config: ConfigType) -> None:
-    hub = await cg.get_variable(config[CONF_GREE_ID])
-    receives_state = (
-        fv.get_declaring_config(config[CONF_GREE_ID], CORE.config)[CONF_MODEL]
-        in RX_FEATURE_MODELS
-    )
-    cg.add_define("USE_GREE_FEATURE_SWITCH")
+    parent = await cg.get_variable(config[CONF_GREE_ID])
 
-    switches = switch.sub_switches(config, parent=hub)
-    for conf_key, feature, _, default_restore_mode in SWITCH_CONFIGS:
-        if (feature_conf := config.get(conf_key)) is None:
-            continue
-        await switches.create(
-            _with_default_restore_mode(
-                feature_conf, default_restore_mode, receives_state
-            ),
-            lambda sw, feature=feature: hub.register_feature_switch(feature, sw),
-            apply=f"set_feature_state({feature}, state)",
-        )
+    for conf_key, name, bit_mask, _ in SWITCH_CONFIGS:
+        if switch_conf := config.get(conf_key):
+            sw = cg.new_Pvariable(switch_conf[cv.CONF_ID], name, bit_mask)
+            await switch.register_switch(sw, switch_conf)
+            await cg.register_component(sw, switch_conf)
+            await cg.register_parented(sw, parent)

esphome/components/gree/switch/gree_switch.cpp

@@ -0,0 +1,17 @@
+#include "gree_switch.h"
+#include "esphome/core/log.h"
+
+namespace esphome::gree {
+
+ESPHOME_LOG_TAG(TAG, "gree.switch");
+
+void GreeModeBitSwitch::setup() { this->restore(); }
+
+void GreeModeBitSwitch::dump_config() { log_switch(TAG, "  ", this->name_, this); }
+
+void GreeModeBitSwitch::write_state(bool state) {
+  this->parent_->set_mode_bit(this->bit_mask_, state);
+  this->publish_state(state);
+}
+
+}  // namespace esphome::gree

esphome/components/gree/switch/gree_switch.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "esphome/core/component.h"
+#include "esphome/components/switch/switch.h"
+#include "esphome/components/gree/gree.h"
+
+namespace esphome::gree {
+
+class GreeModeBitSwitch final : public switch_::Switch, public Component, public Parented<GreeClimate> {
+ public:
+  GreeModeBitSwitch(const char *name, uint8_t bit_mask) : name_(name), bit_mask_(bit_mask) {}
+
+  void setup() override;
+  void dump_config() override;
+  void write_state(bool state) override;
+
+ protected:
+  const char *name_;
+  uint8_t bit_mask_;
+};
+
+}  // namespace esphome::gree

esphome/components/ld2410/ld2410.cpp

@@ -102,6 +102,8 @@ static constexpr uint8_t ENGINEERING_FRAME_MIN = OUT_PIN_SENSOR + 3 + HEADER_FOO
 // Data Header & Footer
 static constexpr uint8_t DATA_FRAME_HEADER[HEADER_FOOTER_SIZE] = {0xF4, 0xF3, 0xF2, 0xF1};
 static constexpr uint8_t DATA_FRAME_FOOTER[HEADER_FOOTER_SIZE] = {0xF8, 0xF7, 0xF6, 0xF5};
+// MAC address the module uses when Bluetooth is disabled
+static constexpr uint8_t NO_MAC[] = {0x08, 0x05, 0x04, 0x03, 0x02, 0x01};
 
 void LD2410Component::dump_config() {
   char mac_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
@@ -423,7 +425,10 @@ void LD2410Component::handle_ack_data_() {
         break;  // too short to hold a MAC address
       }
 
-      this->bluetooth_on_ = ld24xx::store_mac(&this->buffer_data_[10], this->mac_address_);
+      this->bluetooth_on_ = std::memcmp(&this->buffer_data_[10], NO_MAC, sizeof(NO_MAC)) != 0;
+      if (this->bluetooth_on_) {
+        std::memcpy(this->mac_address_, &this->buffer_data_[10], sizeof(this->mac_address_));
+      }
 
       char mac_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
       const char *mac_str = ld24xx::format_mac_str(this->mac_address_, mac_s);

esphome/components/ld2412/ld2412.cpp

@@ -120,6 +120,8 @@ static constexpr uint8_t ENGINEERING_FRAME_MIN = LIGHT_SENSOR + 3 + HEADER_FOOTE
 // Data Header & Footer
 static constexpr uint8_t DATA_FRAME_HEADER[HEADER_FOOTER_SIZE] = {0xF4, 0xF3, 0xF2, 0xF1};
 static constexpr uint8_t DATA_FRAME_FOOTER[HEADER_FOOTER_SIZE] = {0xF8, 0xF7, 0xF6, 0xF5};
+// MAC address the module uses when Bluetooth is disabled
+static constexpr uint8_t NO_MAC[] = {0x08, 0x05, 0x04, 0x03, 0x02, 0x01};
 static constexpr uint8_t GATE_SENS_ACK_SIZE = ACK_PAYLOAD + TOTAL_GATES + HEADER_FOOTER_SIZE;
 
 void LD2412Component::dump_config() {
@@ -475,7 +477,10 @@ void LD2412Component::handle_ack_data_() {
         break;  // too short to hold a MAC address
       }
 
-      this->bluetooth_on_ = ld24xx::store_mac(&this->buffer_data_[10], this->mac_address_);
+      this->bluetooth_on_ = std::memcmp(&this->buffer_data_[10], NO_MAC, sizeof(NO_MAC)) != 0;
+      if (this->bluetooth_on_) {
+        std::memcpy(this->mac_address_, &this->buffer_data_[10], sizeof(this->mac_address_));
+      }
 
       char mac_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
       const char *mac_str = ld24xx::format_mac_str(this->mac_address_, mac_s);

esphome/components/ld2450/ld2450.cpp

@@ -79,6 +79,8 @@ static constexpr uint8_t DATA_FRAME_FOOTER[2] = {0x55, 0xCC};
 // 3 zones * 8 + footer (4).
 static constexpr uint8_t ZONE_ACK_FRAME_SIZE = 40;
 static constexpr uint8_t PERIODIC_FRAME_SIZE = 30;  // header, three targets of 8 bytes, footer
+// MAC address the module uses when Bluetooth is disabled
+static constexpr uint8_t NO_MAC[] = {0x08, 0x05, 0x04, 0x03, 0x02, 0x01};
 
 static inline uint32_t convert_seconds_to_ms(uint16_t value) { return (uint32_t) value * 1000; };
 
@@ -190,11 +192,6 @@ void LD2450Component::dump_config() {
   for (text_sensor::TextSensor *s : this->direction_text_sensors_) {
     LOG_TEXT_SENSOR("  ", "Direction", s);
   }
-#ifdef USE_LD2450_TARGET_XY
-  for (text_sensor::TextSensor *s : this->target_xy_text_sensors_) {
-    LOG_TEXT_SENSOR("  ", "TargetXY", s);
-  }
-#endif
 #endif
 #ifdef USE_NUMBER
   ESP_LOGCONFIG(TAG, "Numbers:");
@@ -298,6 +295,9 @@ bool LD2450Component::get_timeout_status_(uint32_t check_millis) {
   if (check_millis == 0) {
     return true;
   }
+  if (this->timeout_ == 0) {
+    this->timeout_ = ld2450::convert_seconds_to_ms(DEFAULT_PRESENCE_TIMEOUT);
+  }
   return App.get_loop_component_start_time() - check_millis >= this->timeout_;
 }
 
@@ -468,16 +468,9 @@ void LD2450Component::handle_periodic_data_() {
 
     // Store target info for zone target count. Zero out untracked targets (td==0)
     // so stale coordinates don't produce ghost counts in count_targets_in_zone_().
-#ifdef USE_LD2450_TARGET_XY
-    const Target previous = this->target_info_[index];
-#endif
     this->target_info_[index].x = (td > 0) ? tx : 0;
     this->target_info_[index].y = (td > 0) ? ty : 0;
     this->target_info_[index].is_moving = (td > 0) && is_moving;
-#ifdef USE_LD2450_TARGET_XY
-    this->update_target_xy_(index,
-                            previous.x != this->target_info_[index].x || previous.y != this->target_info_[index].y);
-#endif
 
   }  // End loop thru targets
 
@@ -628,7 +621,10 @@ void LD2450Component::handle_ack_data_() {
         break;  // too short to hold a MAC address
       }
 
-      this->bluetooth_on_ = ld24xx::store_mac(&this->buffer_data_[10], this->mac_address_);
+      this->bluetooth_on_ = std::memcmp(&this->buffer_data_[10], NO_MAC, sizeof(NO_MAC)) != 0;
+      if (this->bluetooth_on_) {
+        std::memcpy(this->mac_address_, &this->buffer_data_[10], sizeof(this->mac_address_));
+      }
 
       char mac_s[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
       const char *mac_str = ld24xx::format_mac_str(this->mac_address_, mac_s);
@@ -866,27 +862,6 @@ void LD2450Component::set_direction_text_sensor(uint8_t target, text_sensor::Tex
   this->direction_text_sensors_[target] = s;
 }
 #endif
-#ifdef USE_LD2450_TARGET_XY
-void LD2450Component::set_target_xy_text_sensor(uint8_t target, text_sensor::TextSensor *s) {
-  this->target_xy_text_sensors_[target] = s;
-}
-
-// Publish the position of a target in one radar frame; the sensor's filters throttle it
-void LD2450Component::update_target_xy_(uint8_t target, bool changed) {
-  text_sensor::TextSensor *s = this->target_xy_text_sensors_[target];
-  if (s == nullptr || (!changed && s->has_state()))
-    return;
-  const Target &pos = this->target_info_[target];
-  if (pos.x == 0 && pos.y == 0) {
-    s->publish_state(DirectionStrings::get_progmem_str(DIRECTION_NA, DirectionStrings::LAST_INDEX));
-    return;
-  }
-  // Longest is "-32767,-32767"
-  char text[16];
-  const size_t len = buf_append_printf(text, sizeof(text), 0, "%d,%d", pos.x, pos.y);
-  s->publish_state(text, len);
-}
-#endif
 
 // Send Zone coordinates data to LD2450
 #ifdef USE_NUMBER
@@ -925,14 +900,17 @@ void LD2450Component::set_zone_numbers(uint8_t zone, number::Number *x1, number:
 // Set Presence Timeout load and save from flash
 #ifdef USE_NUMBER
 void LD2450Component::set_presence_timeout() {
-  if (this->presence_timeout_number_ == nullptr)
-    return;
-  // Restore only while the number has no state yet: 0 is a valid presence_timeout (no hold)
-  if (!this->presence_timeout_number_->has_state())
-    this->presence_timeout_number_->publish_state(this->restore_from_flash_());
-  const float timeout = this->presence_timeout_number_->state;
-  this->save_to_flash_(timeout);
-  this->timeout_ = ld2450::convert_seconds_to_ms(timeout);
+  if (this->presence_timeout_number_ != nullptr) {
+    if (this->presence_timeout_number_->state == 0) {
+      float timeout = this->restore_from_flash_();
+      this->presence_timeout_number_->publish_state(timeout);
+      this->timeout_ = ld2450::convert_seconds_to_ms(timeout);
+    }
+    if (this->presence_timeout_number_->has_state()) {
+      this->save_to_flash_(this->presence_timeout_number_->state);
+      this->timeout_ = ld2450::convert_seconds_to_ms(this->presence_timeout_number_->state);
+    }
+  }
 }
 
 // Save Presence Timeout to flash

esphome/components/ld2450/ld2450.h

@@ -146,9 +146,6 @@ class LD2450Component : public Component, public uart::UARTDevice {
 #ifdef USE_TEXT_SENSOR
   void set_direction_text_sensor(uint8_t target, text_sensor::TextSensor *s);
 #endif
-#ifdef USE_LD2450_TARGET_XY
-  void set_target_xy_text_sensor(uint8_t target, text_sensor::TextSensor *s);
-#endif
 #ifdef USE_NUMBER
   void set_zone_coordinate(number::Number *n);
   void set_zone_numbers(uint8_t zone, number::Number *x1, number::Number *y1, number::Number *x2, number::Number *y2);
@@ -192,9 +189,6 @@ class LD2450Component : public Component, public uart::UARTDevice {
   void save_to_flash_(float value);
   float restore_from_flash_();
   bool get_timeout_status_(uint32_t check_millis);
-#ifdef USE_LD2450_TARGET_XY
-  void update_target_xy_(uint8_t target, bool changed);
-#endif
   void count_targets_in_zone_(const Zone &zone, uint8_t &still, uint8_t &moving);
 
   uint32_t presence_millis_ = 0;
@@ -232,10 +226,6 @@ class LD2450Component : public Component, public uart::UARTDevice {
 #ifdef USE_TEXT_SENSOR
   std::array<text_sensor::TextSensor *, MAX_TARGETS> direction_text_sensors_{};
 #endif
-#ifdef USE_LD2450_TARGET_XY
-  // Publishes a target's position as "x,y" text, so both values always come from the same radar frame
-  std::array<text_sensor::TextSensor *, MAX_TARGETS> target_xy_text_sensors_{};
-#endif
 
 #ifdef LD2450_POLYGON_ZONE_COUNT
   StaticVector<PolygonZone *, LD2450_POLYGON_ZONE_COUNT> polygon_zones_;