mirror of
https://github.com/esphome/esphome.git
synced 2026-11-17 18:46:08 +00:00
Compare commits
121
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
c2aa2c5995 | ||
|
|
3040ee9b3a | ||
|
|
719e5bf2fa | ||
|
|
4af3936ede | ||
|
|
24d843302e | ||
|
|
b75b3e2bef | ||
|
|
144c799cf5 | ||
|
|
61cce92aaa | ||
|
|
38c1646870 | ||
|
|
b60c2864ef | ||
|
|
db0121bc21 | ||
|
|
be8f6c5e41 | ||
|
|
b621332de5 | ||
|
|
982cbba291 | ||
|
|
a2ac68faac | ||
|
|
731f6e2722 | ||
|
|
598d87836c | ||
|
|
e852e15ca3 | ||
|
|
6b82e127fe | ||
|
|
17baeae3ea | ||
|
|
bc57ad5c87 | ||
|
|
0c1606d3b8 | ||
|
|
a155401afc | ||
|
|
e3bfffc8ab | ||
|
|
9f5ca49e2f | ||
|
|
94cb20d9e1 | ||
|
|
82f2203cc3 | ||
|
|
23a83a9f3d | ||
|
|
59f6affb51 | ||
|
|
4a02a0d4ba | ||
|
|
85f0011e6b | ||
|
|
b617926576 | ||
|
|
34881c3e3c | ||
|
|
71f55f270e | ||
|
|
1a9cce8bb8 | ||
|
|
b6c5a6e7c2 | ||
|
|
149b9280eb | ||
|
|
7a09548cdc | ||
|
|
1a07f39062 | ||
|
|
4c99a0f1ed | ||
|
|
875b8faf43 | ||
|
|
47b27a93a6 | ||
|
|
3c8940bfef | ||
|
|
4886238892 | ||
|
|
d611d9a3ca | ||
|
|
aa2a31647d | ||
|
|
f18de29d20 | ||
|
|
4eb24d78b0 | ||
|
|
1658efa9e7 | ||
|
|
feebc28853 | ||
|
|
86385ea2fe | ||
|
|
9bee9629c6 | ||
|
|
422ba0662e | ||
|
|
4b4d787884 | ||
|
|
34d68a0fa0 | ||
|
|
7caa7de696 | ||
|
|
9b23184e10 | ||
|
|
2f9abefe3f | ||
|
|
84079c07e2 | ||
|
|
110f854246 | ||
|
|
b7dbf17469 | ||
|
|
b91750c325 | ||
|
|
6c5bdd9251 | ||
|
|
92d2a457fa | ||
|
|
be41bc41e4 | ||
|
|
c0cf8f6b19 | ||
|
|
49d1f61df7 | ||
|
|
95c67a5523 | ||
|
|
8045a11909 | ||
|
|
208d0021a9 | ||
|
|
1da90be339 | ||
|
|
4b48ff0255 | ||
|
|
fed2b2995e | ||
|
|
ae48c7ab4c | ||
|
|
6f6e34ca40 | ||
|
|
0561d90334 | ||
|
|
78ef1fd104 | ||
|
|
a6bca49020 | ||
|
|
2e68c56908 | ||
|
|
a1fecebb09 | ||
|
|
32b9d4cbe7 | ||
|
|
c53401a28d | ||
|
|
6b7d17c762 | ||
|
|
93a3306d82 | ||
|
|
54d3477240 | ||
|
|
5f9d83d293 | ||
|
|
43864283b4 | ||
|
|
4efbb38b86 | ||
|
|
045374965f | ||
|
|
39a939720f | ||
|
|
a79e51e784 | ||
|
|
517f0d6d48 | ||
|
|
1327d0ddc5 | ||
|
|
2adb544e7a | ||
|
|
48905beb96 | ||
|
|
ed401814bf | ||
|
|
0245db6285 | ||
|
|
07ee0f9f04 | ||
|
|
3d34ad572b | ||
|
|
5c9033e04d | ||
|
|
e91934e4bd | ||
|
|
602cbff184 | ||
|
|
da274f92d3 | ||
|
|
c6f330458a | ||
|
|
dbb4ba769a | ||
|
|
0eb4a09935 | ||
|
|
ed9e5cff58 | ||
|
|
7acd023079 | ||
|
|
5623a5d511 | ||
|
|
4f8c2239dd | ||
|
|
07bbad4061 | ||
|
|
1cd99ce6d6 | ||
|
|
91db9d86d0 | ||
|
|
2f900f23d7 | ||
|
|
373224c141 | ||
|
|
1dff22f578 | ||
|
|
c2eb540b37 | ||
|
|
fad21e3f14 | ||
|
|
904f0df920 | ||
|
|
7128d22f07 | ||
|
|
825e2c3dd0 |
No files matched your search
@@ -47,6 +47,15 @@ driven, what the logs show, and the same flow on a `dev` build when a quirk coul
|
||||
piped, or lines land minutes late. Bound every long command with `timeout` (coreutils) or
|
||||
`perl -e 'alarm shift; exec @ARGV' <seconds> <command>` on macOS without it. Save an exit code with `rc=$?`
|
||||
right after the command: in `echo "$(date +%T) rc=$?"` the command substitution runs first and `$?` reads 0.
|
||||
8. **Give builds a private PlatformIO directory when sessions may use different Pythons.** ESPHome stamps the
|
||||
PlatformIO core directory with the Python version that last built, and a build from another version wipes and
|
||||
reinstalls the shared packages under every other build. Set `PLATFORMIO_CORE_DIR=<scratch>/pio` on every
|
||||
compile and upload (`scripts/pio_build.sh` does). Old releases and framework A/B builds need one too
|
||||
(see `reference/boards.md`).
|
||||
9. **One ESP-IDF or LibreTiny build at a time on a shared machine.** Concurrent builds race over tool caches. Wrap
|
||||
compiles in a lock (`BUILD_LOCK` for `scripts/pio_build.sh`, for example a script that holds a `mkdir` lock).
|
||||
10. **Check that the stimulus ran.** A load or soak run where most requests failed was not loaded, and a capture
|
||||
that stopped early covers nothing; check the driver's own counters before reading the device's verdict.
|
||||
|
||||
## Workflow
|
||||
|
||||
@@ -81,7 +90,17 @@ driven, what the logs show, and the same flow on a `dev` build when a quirk coul
|
||||
> Automated testing results
|
||||
```
|
||||
|
||||
Then one short sentence saying what was tested (builds and SHAs, board, what was driven), a results table
|
||||
Then one short sentence saying what was tested (builds and SHAs, board, what was driven), and on the next line a
|
||||
bold result, one of **Test result: PASS**, **Test result: FAIL**, **Test result: PASS WITH CAVEATS** or
|
||||
**Test result: UNCLEAR**, followed by one sentence with the key numbers (for example "the device closed none of 32
|
||||
streams, dev closed 12 of 16"). FAIL means a regression or a fix that does not work. PASS WITH CAVEATS means it works
|
||||
but something about the change itself needs a look; name the caveat in that sentence. A limit of the test (the
|
||||
original crash did not reproduce) or a device or network quirk the tooling reported correctly is not a caveat on
|
||||
the change; say it as a separate note. UNCLEAR means the run could not decide; say what is
|
||||
missing. A reader must not have to dig through the table or guess. Side findings that do not change the result (a
|
||||
bug already on `dev`, a one-off oddity) go in the bullets, marked as separate from the result.
|
||||
|
||||
Then 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.
|
||||
@@ -118,8 +137,13 @@ ESP-IDF OTA image: `.esphome/build/<name>/build/firmware.ota.bin`. LibreTiny OTA
|
||||
and then; retry up to three times.
|
||||
- `api_button.py HOST KEY list|press NAME [...]`: list a device's template buttons or press them over the API; the
|
||||
recipes drive their test configs with it.
|
||||
- `apiconn.py`: `connect(host, tries)` (API connect and login with retries, `API_KEY` from the env) and `log_text()`
|
||||
(an API log line without ANSI codes), imported by the newer API drivers.
|
||||
- `apiconn.py`: `connect(host, tries, port, on_stop)` (API connect and login with retries, `API_KEY` from the env),
|
||||
`log_text()` (an API log line without ANSI codes), `stop_event()` (an Event set when the connection ends),
|
||||
`ble_connect()` (wait for an advert, connect through a proxy without a cache like Home Assistant) and
|
||||
`enable_notify()` (start notify and write the CCCD), imported by the API drivers.
|
||||
- `pio_build.sh compile|upload NAME YAML [DEVICE] [esphome options]`: build or upload YAML as `-s name NAME` from
|
||||
`TREE` with a private PlatformIO directory, an import check and an optional `BUILD_LOCK`; logs to `NAME-*.log`.
|
||||
- `resolve.sh NAME [TRIES]`: the address of `NAME.local` once it resolves and answers a ping.
|
||||
- `wifisave_hammer.sh KIND DUT_PORT DUT_YAML DUT_TREE CLIENT_PORT CLIENT_YAML CLIENT_TREE [SETTLE]`:
|
||||
the fallback AP plus captive portal hammer end to end (compile, flash, capture, counts) with the
|
||||
templates below. KIND is `esp`, `pico`, `bw15` or `bk`. It ends with `RESULT PASS` (exit 0),
|
||||
@@ -134,7 +158,7 @@ recorder, dump saver and decoder, cover cycle driver), `online_image/`
|
||||
(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,
|
||||
capture decoder, RTL8720C ROM dump versus report matcher), `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, frame stream harness with presence hold and link loss drivers, BT MAC driver), `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, AT commands for the UART passthrough), `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/` (`ha_discovery/`, `disable/`, `retained_burst/` and `reconnect/` runners; 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), `gpio_hold/` (ISR pin hold self test with ESP32 and S3 configs), `ble_event_inject/` (GAP and GATTC event injector header and proxy package), `light_sleep_wake/` (LEDC wave and edge timer for light sleep wakeup on a C3, external wave generator and per-call edge detail probe for peripheral power-down on the P4), `manual_ip/` (station and AP manual IP configs, DNS probe and runners), `web_handlers/` (late handler, web_server, captive_portal and prometheus variants, web OTA runner), `bk72xx_flash/` (flash readback with retries, per partition diff of two dumps), `ble_server_security/` (secure GATT server and pairing client configs, driver, summary and runner), `prometheus/` (datetime metrics configs and driver), `zephyr_ble_server/` (nRF52 server, looping ESP32 client and UF2 flash and count runner), `ble_adv_triggers/` (advertiser with six raw frames, ESP32 and BK72xx receivers with eleven triggers, runner and checker), `sun/` (longitude sweep package, runner and checker), `sensor_filters/` (every filter shape with a fixed input sequence, per-board packages and runner), `led_driver_sniff/` (SPI slave capture header with selftest, config generator, window comparer and runner), `hub_input_sim/` (keypad, wiegand and rdm6300 simulation on a D1 mini, API log runner), `value_range/` (on_value_range sequence with a restart, runner), `ezo_fake_bus/` (fake EZO I2C bus and step config, runner), `twai_self/` (TWAI self-reception header, on_frame config and counter runner), `ota_automations/` (OTA automation package for both OTA platforms, four case runner, repeated web upload runner and per case summary), `output_button/` (pad edge timer header, button package and runner), `homeassistant_button/` (raw plaintext API client for action calls and wizard inputs, package and runner), `uart_button/` (UART0 loopback package, API driver with TX and RX counts, runner), `interval/` (plain and delayed interval package, timing summary and runner), `smp_udp_ota/` (SMP reset fault injector, OTA runner, per mode result check, MCUboot swap limit, running image check and slot blanking UF2, Thread device config), `ld2420_sim/` (fake LD2420 answering the hub's commands on a UART0 loopback, API state recorder, two-build comparer and runner), `nrf52_tcp_probe/` (TCP and UDP socket probe config, build and log check, API check over Thread), `rs485_frame/` (simulated DLE/STX/ETX bus device, frame and Line truncated
|
||||
capture decoder, RTL8720C ROM dump versus report matcher), `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, frame stream harness with presence hold and link loss drivers, BT MAC driver), `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, AT commands for the UART passthrough), `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, per-session `/events` listing check with its config, `/events` head, multi-client, stall, Wi-Fi drop and churn modes with their config, head comparer and runner), `mqtt/` (`ha_discovery/`, `disable/`, `retained_burst/` and `reconnect/` runners; 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), `gpio_hold/` (ISR pin hold self test with ESP32 and S3 configs), `ble_event_inject/` (GAP and GATTC event injector header and proxy package), `light_sleep_wake/` (LEDC wave and edge timer for light sleep wakeup on a C3, external wave generator and per-call edge detail probe for peripheral power-down on the P4), `manual_ip/` (station and AP manual IP configs, DNS probe and runners), `web_handlers/` (late handler, web_server, captive_portal and prometheus variants, web OTA runner), `bk72xx_flash/` (flash readback with retries, per partition diff of two dumps), `ble_server_security/` (secure GATT server and pairing client configs, driver, summary and runner), `prometheus/` (datetime metrics configs and driver), `zephyr_ble_server/` (nRF52 server, looping ESP32 client and UF2 flash and count runner), `ble_adv_triggers/` (advertiser with six raw frames, ESP32 and BK72xx receivers with eleven triggers, runner and checker), `sun/` (longitude sweep package, runner and checker), `sensor_filters/` (every filter shape with a fixed input sequence, per-board packages and runner), `led_driver_sniff/` (SPI slave capture header with selftest, config generator, window comparer and runner), `hub_input_sim/` (keypad, wiegand and rdm6300 simulation on a D1 mini, API log runner), `value_range/` (on_value_range sequence with a restart, runner), `ezo_fake_bus/` (fake EZO I2C bus and step config, runner), `twai_self/` (TWAI self-reception header, on_frame config and counter runner), `ota_automations/` (OTA automation package for both OTA platforms, four case runner, repeated web upload runner and per case summary), `output_button/` (pad edge timer header, button package and runner), `homeassistant_button/` (raw plaintext API client for action calls and wizard inputs, package and runner), `uart_button/` (UART0 loopback package, API driver with TX and RX counts, runner), `interval/` (plain and delayed interval package, timing summary and runner), `smp_udp_ota/` (SMP reset fault injector, OTA runner, per mode result check, MCUboot swap limit, running image check and slot blanking UF2, Thread device config), `ld2420_sim/` (fake LD2420 answering the hub's commands on a UART0 loopback, API state recorder, two-build comparer and runneLine truncated
|
||||
|
||||
## Templates in `$SKILL/templates`
|
||||
|
||||
@@ -143,6 +167,8 @@ capture decoder, RTL8720C ROM dump versus report matcher), `api_outgoing/` (wake
|
||||
- `client-wifisave.yaml` (package): joins that AP, posts N bogus `/wifisave` requests, then the real
|
||||
credentials from `!secret`. `example-client.yaml` is the per-run file. `bogus_saves: "1"` gives a
|
||||
plain provisioning check.
|
||||
- `diagnostics.yaml` (package): DEBUG logs, esphome OTA, uptime, free heap, reset reason and a 200 ms counter
|
||||
for soak and load tests.
|
||||
- Per-topic device configs, each described in `reference/recipes/<component>.md`: `online-image-dut.yaml`,
|
||||
`usb-cdc-acm-dongle-dut.yaml`, `nrf52-preferences-dut.yaml`, `rtsp-waveshare-s3-eth-dut.yaml`,
|
||||
`waveshare-s3-eth-camdiag.yaml`, `s31-cse7766-dut.yaml`, `nrf52-coredump-crash-dut.yaml`,
|
||||
@@ -196,6 +222,10 @@ comment quotes the exact commits. Fetch `origin dev` before computing a merge ba
|
||||
the shared `~/.platformio/platforms/libretiny`, so every later build on the machine uses the patched copy. Patch
|
||||
through the ESPHome side (a linker `-Wl,-wrap,<symbol>` or a define) instead, and if it happened, restore the
|
||||
directory from a clean copy of the same release.
|
||||
- Copying a .uf2 to a mounted bootloader drive (`RPI-RP2`, `ITSY840BOOT`) from a terminal on macOS can fail with
|
||||
"Operation not permitted" (the Removable Volumes privacy permission), and picotool then sees no device. Flash through
|
||||
the serial path instead (`esphome upload --device <port>`: the 1200 baud touch on RP2, serial DFU on Adafruit nRF52
|
||||
boards) or by OTA; a board that only shows the drive needs the file dragged in Finder.
|
||||
- `wc -l` pads its count on macOS, so `tail -n +$n0` needs `$((n0+0))` or an arithmetic expansion.
|
||||
- `api:` reboots a board after 15 min without a client: `reboot_timeout: 0s` on `api:` and `mqtt:` for
|
||||
soak tests.
|
||||
|
||||
@@ -29,6 +29,9 @@ Ports are not listed on purpose: they follow the USB hub port and change on ever
|
||||
interrupt handler; `Software Watchdog` with `pm_send_nullfunc` means the loop was busy too long. Code that takes
|
||||
interrupt locks needs a load run to show either (`scripts/esp8266_lock_load/`, see recipes/one_wire.md).
|
||||
- `GPI` bits 16 to 31 are strapping bits (mask with 0xFFFF). GPIO16 has no interrupt; read `GP16O` for an output.
|
||||
- Cover positions and other restored entity state live in RTC memory by default, so they survive `erase_flash`
|
||||
and a dev build's state carries into the next build's first boot. Set `esp8266: restore_from_flash: true` on A/B
|
||||
configs that erase between builds.
|
||||
|
||||
## ESP32 classic devkit
|
||||
|
||||
@@ -50,6 +53,8 @@ Ports are not listed on purpose: they follow the USB hub port and change on ever
|
||||
- An ESP32 whose bootloader has no app rollback is protected only by `safe_mode` after a bad OTA. Before sending a
|
||||
change to such a device that nobody can reach by hand, boot the same code on a devkit first and keep a fallback
|
||||
image of the merge base built.
|
||||
- On modules where GPIO16 and GPIO17 are taken by the module itself (PSRAM on WROVER modules, for example), a
|
||||
`uart:` bus on those pins boot-loops with a watchdog reset during setup. Use GPIO21 and GPIO22.
|
||||
|
||||
## ESP32-S3, C3, C6, H2 with native USB
|
||||
|
||||
@@ -72,6 +77,25 @@ Ports are not listed on purpose: they follow the USB hub port and change on ever
|
||||
- A board left in the ROM bootloader after an upload (BOOT held, or the USB JTAG reset landing in download mode
|
||||
again) starts its app without a replug through `esptool --port <port> --after watchdog-reset chip-id`; flash a
|
||||
minimal Wi-Fi plus API image first when recovering from a crash-looping one.
|
||||
- On macOS a software reboot of an ESP32-C3 does not drop its USB JTAG serial port: pyserial keeps reading and gets
|
||||
no error, so a client that watches for a port reset misses it. Count ESPHome's `Running through setup()` line
|
||||
instead.
|
||||
- W5500 SPI Ethernet with IPv6 on (seen on an ESP32-S3, #22676): every `safe_reboot()` (OTA, restart button)
|
||||
aborts while an API client is subscribed to logs. `mdns_free()` leaves the IPv6 group inside `tcpip_api_call`, the
|
||||
W5500 driver logs "IPv6 multicast is always filtered in by W5500", the logger sends that line to the API inline,
|
||||
and the nested `LwIPLock` in `setsockopt(TCP_NODELAY)` releases the core lock it did not take, so `udp_recv`
|
||||
asserts. No crash with IPv6 off, with no log subscriber (a connected client that does not subscribe is fine), or
|
||||
on RMII Ethernet. Reading the crash record afterwards: `recipes/crash_report.md`.
|
||||
- `usb_serial_jtag` holds a `NO_LIGHT_SLEEP` power lock by itself, so a light sleep soak on a native USB board logs
|
||||
to UART0 instead (see `recipes/light_sleep_gpio_wake.md`).
|
||||
- The Waveshare ESP32-P4-WIFI6 needs `engineering_sample: true`. Its Wi-Fi is an ESP32-C6 over SDIO through
|
||||
`esp32_hosted`; a test with no network logs over UART0 to the CH343 console.
|
||||
|
||||
## ESP32-C2 (ESP8684, 26 MHz crystal)
|
||||
|
||||
- Boards with a 26 MHz crystal print the ROM banner (`ESP-ROM:esp8684`) at 74880 baud; at 115200 it is garbage.
|
||||
- ESP-IDF builds need `esp32: framework: sdkconfig_options: {CONFIG_XTAL_FREQ_26: y}`, or the app console runs at
|
||||
the wrong baud rate (the upload log warns `Crystal frequency mismatch`).
|
||||
|
||||
## RP2040 / RP2350 (Pico W, Pico 2 W)
|
||||
|
||||
@@ -99,6 +123,25 @@ Ports are not listed on purpose: they follow the USB hub port and change on ever
|
||||
each RD_REQ with one byte from a 256-byte register file, so any read length works (used for BME280/BMP280 in
|
||||
esphome#22236). The ESP32-S3 I2C slave v2 driver is not usable for register emulation: answering from a task or
|
||||
straight from the interrupt both gave shifted multi-byte reads.
|
||||
- RP2350 PIO instruction memory survives a reflash (the 1200 baud touch and the UF2 reboot), so a program loaded by
|
||||
the previous firmware can hide a missing `pio_add_program`. Clear it from an `on_boot` priority 1000 lambda
|
||||
(`pio1->instr_mem[i] = 0` for i < 32) to start from power-on state; `scripts/pio_probe/pio-common.yaml` does.
|
||||
- `RP2Preferences::reset()` erases the flash sector but not the RAM copy the preferences load from, so the LibreTiny
|
||||
`on_boot` wipe-once pattern still boots with the old saved Wi-Fi credentials. Use a fallback AP config with
|
||||
`networks:` and a fresh `name:` per build instead.
|
||||
- WIZnet W5100S-EVB-Pico (RP2040, `rp2: board: wiznet_5100s_evb_pico`): W5100S on SPI with CLK 18, MOSI 19, MISO 16,
|
||||
CS 17, INT 21, RST 20 (`ethernet: type: W5100`). ESPHome firmware gives it no USB CDC port; reach it over Ethernet,
|
||||
OTA by address, and flash it over USB only through BOOTSEL and the UF2 drive. Keep `interrupt_pin` in every build:
|
||||
without it OTA starves and never completes (`recipes/arduino_pico.md`), which strands the board until a USB flash.
|
||||
The W5100S answers ICMP in hardware, so a ping reply says nothing about the RP2040; probe TCP instead (OTA port
|
||||
2040, API 6053, HTTP 80). In safe mode only 2040 answers.
|
||||
- Through a Pico W `bluetooth_proxy`, about 1 to 2 in 5 BLE connects fail with 0x3E (`connect err=62` in the
|
||||
client) on every build; retry.
|
||||
- arduino-pico framework bumps and the RPAsyncTCP SSE stall: see `recipes/arduino_pico.md`.
|
||||
- USB CDC sends nothing until the host asserts DTR; a client that opens with DTR low (`improvcli.py` without
|
||||
`--keep-dtr`) sees silence.
|
||||
- Powering a breakout from the Pico: use 3V3(OUT), pin 36. Pin 37 is 3V3_EN, which switches the Pico off when pulled
|
||||
low.
|
||||
|
||||
## BW15 kit (RTL8720CF, LibreTiny rtl87xx)
|
||||
|
||||
@@ -140,6 +183,12 @@ Ports are not listed on purpose: they follow the USB hub port and change on ever
|
||||
- Wrong-MD5 OTA test without changing firmware: monkeypatch `espota2.hashlib.md5` so only the image checksum (data
|
||||
over 64 KB) returns a wrong hexdigest. Give each build its own `name:` and read `device_info().name` after a
|
||||
restart to see which image booted.
|
||||
- Logger UART: `DEFAULT` is UART2 (the kit's USB serial). `hardware_uart: UART1` hangs after the boot banner and
|
||||
never joins Wi-Fi, on dev too. `UART0` moves both ESPHome and `lt_log` output off the kit's port. LibreTiny's own
|
||||
`LT_I` lines need `framework: loglevel: info` (the default is warn).
|
||||
- A config with no Wi-Fi network and no `ap:` resets about 10 s into setup when it has `web_server:` (dev too):
|
||||
`web_server` setup blocks with no interface up, and no crash record is left. VERBOSE logs show the last
|
||||
`Setup <component>` line.
|
||||
|
||||
## BK7238, WB3S, CB3S (BK7231N) (LibreTiny bk72xx, CH340, RTS on CEN)
|
||||
|
||||
@@ -265,6 +314,10 @@ Ports are not listed on purpose: they follow the USB hub port and change on ever
|
||||
partition even when the upgrade state is still `UPG_STATE_DOWNLOAD_ING` (esphome#22111).
|
||||
- Without serial access to recover, never send a corrupted image; wrong-MD5 and cut-upload tests with valid
|
||||
images are safe.
|
||||
- On the WL2H-U `logger: hardware_uart: DEFAULT` resolves to UART1, LibreTiny's log port for that board.
|
||||
- Over a poor link (about 60 ms ping and 5 % loss) an ESPHome OTA takes anywhere from 50 to 445 s and a web `/update`
|
||||
of a UF2 can abort early while ESPHome OTA still works. Treat such a board's results as crash or no crash only, and
|
||||
settle questions about rates, heap after streams or OTA aborts on a BK7238 (same LibreTiny AsyncTCP).
|
||||
|
||||
## nRF52840
|
||||
|
||||
@@ -294,6 +347,10 @@ 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.
|
||||
- `2fe3:0100` is Zephyr's default USB VID:PID, so `ports.py` labels any board running a Zephyr ESPHome build as an
|
||||
nRF52840 Dongle. Tell an ItsyBitsy from a PCA10059 with a 1200 baud touch: the ItsyBitsy shows its `ITSY840BOOT`
|
||||
UF2 volume, the PCA10059 its Nordic DFU port.
|
||||
- nRF52 Zephyr builds use newlib; the nRF54LM20 builds use picolibc.
|
||||
- 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
|
||||
@@ -347,6 +404,16 @@ Ports are not listed on purpose: they follow the USB hub port and change on ever
|
||||
- BDK headers such as `power_save_pub.h` have no `extern "C"`; wrap them when including them from the Arduino
|
||||
core's C++ files.
|
||||
|
||||
## Shared PlatformIO directory
|
||||
|
||||
- The stamp file is `.esphome.pio.stamp.json`; a mismatch deletes `packages`, `platforms` and `.cache`.
|
||||
- Building an old release (2025.7.0, Arduino ESP32) against the shared directory swapped `tool-scons` for an older
|
||||
version and broke it midway (`No module named 'SCons.SConf'`) for every PlatformIO build until a newer build
|
||||
reinstalled it. Build old releases with their own `PLATFORMIO_CORE_DIR`.
|
||||
- Two arduino-pico framework versions share the plain `framework-arduinopico` package directory, so an A/B swaps the
|
||||
framework on every build; give each side its own `PLATFORMIO_CORE_DIR`.
|
||||
- The general rule (a private directory whenever sessions may use different Pythons) is ground rule 8 in `SKILL.md`.
|
||||
|
||||
## LibreTiny crash and abort() facts (esphome#21596, #22288)
|
||||
|
||||
- `abort()` on dev: the BK7238 hangs for good (the main loop stops and the watchdog never fires once Wi-Fi is up;
|
||||
@@ -426,3 +493,33 @@ Ports are not listed on purpose: they follow the USB hub port and change on ever
|
||||
- LED0 P1.22, LED1 P1.25; BUTTON0 P1.26, BUTTON1 P1.09, BUTTON2 P1.08, BUTTON3 P0.05 (active low, pull-up). GPIO
|
||||
P1 registers at 0x500D8200 (IN +0x00C, PIN_CNF +0x080), P0 at 0x5010A200.
|
||||
- Binary sensor state changes are not logged at DEBUG; log the states or count `on_press` to see button presses.
|
||||
- FICR INFO.PART reads 0x054BC20B; the build target is `nrf54lm20dk`.
|
||||
- Zephyr `micros()` on nRF has 30.5 us resolution. Time short blocks with the DWT cycle counter instead; nRF54L idle
|
||||
clears `DWT_CTRL`, so enable it again before each timed block.
|
||||
- The nrf52 logger defaults to USB_CDC (the chip's own USB); set `logger: hardware_uart: UART0` to get the log on the
|
||||
J-Link VCOM port.
|
||||
- I2C (#22642): TWIM21 only takes pins on P1 or P3; P0 pins are rejected at config. BUTTON1 (P1.09) and BUTTON2
|
||||
(P1.08) pads work as SDA and SCL. A bus with no pull-ups times out (-116) on every scan address, so setup takes
|
||||
about 56 s. The JLinkExe `st` command reads VTref to check the I/O voltage.
|
||||
|
||||
## Seeed XIAO nRF54LM20A
|
||||
|
||||
- CMSIS-DAP probe (`2886:0068`) with one serial port that carries the console (uart20 on P1.11 and P1.10, #22599).
|
||||
It ships with a Seeed demo.
|
||||
- Flash with `esphome run` (pyOCD, MCUboot plus the signed app). A plain `esphome upload` flashed only the bare app
|
||||
on #22599, and the board stayed dark.
|
||||
- Reset: `<sdk-nrf python> -m pyocd reset -t nrf54lm20a -u <probe id>`.
|
||||
- nPM1300 PMIC at 0x6B on P1.18 (SDA) and P1.17 (SCL) (#22661; `i2c:` builds on i2c21 at 100 kHz). Per the upstream
|
||||
Zephyr board files, BUCK2 supplies VSYS_3V3, the nRF54 and the SAMD11 USB debugger: never switch it off (there is no
|
||||
way back without a power cycle, and the probe dies with it). LDO1 feeds the IMU and microphone (3.3 V, LDO mode) and
|
||||
is safe to toggle. BUCK1 and LDO2 are not described anywhere; leave them alone.
|
||||
- nPM1300 power-on state: BUCK2 on at 3.3 V, BUCK1 off, LDO1 and LDO2 off in load switch mode (enabling one as is
|
||||
passes VINLDO straight through), charger off, VBUS limit 100 mA, NTC select 10 k. Flows: `recipes/npm1300.md`.
|
||||
|
||||
## I2C and SPI breakouts
|
||||
|
||||
- GPIO switches on an I2C expander (XL9535 and others) write `value_or(false)` at setup even with
|
||||
`restore_mode: DISABLED`, so test pin retention on a pin no switch uses.
|
||||
- ADS1015: `sample_rate: 8` maps to 128 SPS at `12_BITS`.
|
||||
- A bus held low (`Performing bus recovery`, no devices found) on a new breakout can be a bad header joint; reflow
|
||||
it before blaming the driver.
|
||||
@@ -4,7 +4,7 @@ Each flow names the pull requests it was used on, so their result tables show wh
|
||||
|
||||
One file per component, named after it:
|
||||
|
||||
- [`api.md`](api.md): noise handshake and OTA encryption on the ESP8266, outgoing connection wake timing on deep sleep and after a Wi-Fi drop, user defined action listing and execution with a raw plaintext client, store_yaml recovery over Noise or plaintext
|
||||
- [`api.md`](api.md): noise handshake and OTA encryption on the ESP8266, outgoing connection wake timing on deep sleep and after a Wi-Fi drop, user defined action listing and execution with a raw plaintext client, store_yaml recovery over Noise or plaintext, rapid connect/disconnect stress (`connstress.py`)
|
||||
- [`ble_midi.md`](ble_midi.md): BLE MIDI client against a fake ESP32 instrument, every packet shape and the send actions
|
||||
- [`captive_portal.md`](captive_portal.md): fallback AP and /wifisave hammer
|
||||
- [`cse7766.md`](cse7766.md): Sonoff S31 parser check over the API
|
||||
@@ -18,11 +18,12 @@ One file per component, named after it:
|
||||
- [`modem.md`](modem.md): PPPoS modem component boot check with no modem attached, loop blocking and disable timing, SIM7080G behaviour with no SIM and with no data plan through a raw UART passthrough
|
||||
- [`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, zephyr_ble_server connection slot under reordered callbacks, SMP over UDP OTA over Thread with reset faults, MCUboot swap limit and stuck slot recovery, TCP stack probe, sdk-nrf 3.4.1 build and USB notes
|
||||
- [`npm1300.md`](npm1300.md): nPM1300 PMIC on the XIAO nRF54LM20A: probe build, every entity with a register dump and regulator toggles, power-on state and no-battery readings
|
||||
- [`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): upload without a configuration and the refusal checks, overlap and lock, timeouts, deflate, upload timing A/B per build and board with deflate and raw, on-device inflate benchmark, OTA automations on two platforms
|
||||
- [`rtsp_server.md`](rtsp_server.md): camera streaming on the Waveshare ESP32-S3-ETH
|
||||
- [`scheduler.md`](scheduler.md): loop wake A/B, interval startup delay and control from lambdas
|
||||
- [`scheduler.md`](scheduler.md): loop wake A/B, interval startup delay and control from lambdas, RP2 scheduler lock under IRQ and lwIP load
|
||||
- [`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, soft AP clients with the BLE tracker scanning, ESP8266 power save after captive portal provisioning
|
||||
@@ -36,8 +37,8 @@ One file per component, named after it:
|
||||
- [`usb_audio.md`](usb_audio.md): USB audio speaker and microphone, the usb_host FIFO split, and Music Assistant playback through sendspin
|
||||
- [`dfrobot_sen0395.md`](dfrobot_sen0395.md): SEN0395 mmWave command flow, module quirks and overlong lines through its error reply
|
||||
- [`speaker.md`](speaker.md): media player pipeline tasks on the Connect AUX-2 with the `speaker` platform player
|
||||
- [`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
|
||||
- [`web_server.md`](web_server.md): state SSE stress and the HTTPD task stack on web_server_idf, entity icon and device class readback, per-session `/events` listing, `/events` head, stall, Wi-Fi drop and churn checks
|
||||
- [`uart_sim.md`](uart_sim.md): UART sensors simulated on a classic ESP32 with loopback and cross-wired UARTs, a Duco ventilation box model on a second UART
|
||||
- [`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
|
||||
- [`remote_base.md`](remote_base.md): remote_receiver protocol decoding through a one-pin loopback on ESP32 and ESP8266, no IR hardware
|
||||
@@ -63,11 +64,11 @@ One file per component, named after it:
|
||||
- [`rs485_frame.md`](rs485_frame.md): DLE/STX/ETX bus on an ESP32-C3 with a cross-wired simulated bus device (frame cases, gate timing)
|
||||
- [`hx711.md`](hx711.md): fake HX711 driven from the other core, every published value matched to the served conversion
|
||||
- [`automation_trace.md`](automation_trace.md): automation codegen A/B, a marker trace of chains, conditions, loops and script modes over the API
|
||||
- [`bluetooth_proxy.md`](bluetooth_proxy.md): held GATT link after a half-open API session, frozen Home Assistant stand-in, out-of-order GATT discovery responses injected on the proxy
|
||||
- [`bluetooth_proxy.md`](bluetooth_proxy.md): held GATT link after a half-open API session, frozen Home Assistant stand-in, out-of-order GATT discovery responses injected on the proxy, GATT UUID forms (16 bit, 32-bit base, 128 bit) compared against an ESP32 proxy
|
||||
- [`crash_report.md`](crash_report.md): crash buttons, fetching the previous boot's crash report over the API, per-chip abort facts
|
||||
- [`https_idf.md`](https_idf.md): web_server_idf HTTPS test component, listener switch, stalled TLS clients, bad key
|
||||
- [`mdns.md`](mdns.md): legacy unicast mDNS dump, hammer and latency straight to the device
|
||||
- [`sim_buses.md`](sim_buses.md): PCF8574/HD44780, MAX7219, SPI spy, packet_interface and SN74HC165 simulators, status LED probe, fake Home Assistant, cg.static_buffer probes
|
||||
- [`sim_buses.md`](sim_buses.md): PCF8574/HD44780, MAX7219, SPI spy, packet_interface and SN74HC165 simulators, status LED probe, fake Home Assistant, cg.static_buffer probes, a TRF7962A NFC reader chip behind a fake SPI bus
|
||||
- [`sigma_delta.md`](sigma_delta.md): pulse density of the sigma_delta speaker pin read inside the ESP32-P4, rtttl note onset and release
|
||||
- [`microphone_http_stream.md`](microphone_http_stream.md): raw PCM over HTTP with a counter fake mic or a USB mic, multi-reader client
|
||||
- [`i2s_audio.md`](i2s_audio.md): I2S microphone fed by an I2S TX channel on the same S3 through three jumpers
|
||||
@@ -83,3 +84,6 @@ One file per component, named after it:
|
||||
- [`heap_alloc.md`](heap_alloc.md): operator new counting, and a ring of allocation callers decoded with addr2line to tell the first run after boot from repeats
|
||||
- [`wled.md`](wled.md): WLED realtime sender on a board's own access point
|
||||
- [`combination.md`](combination.md): combination sensor NaN behaviour from the last source
|
||||
- [`improv.md`](improv.md): Improv serial with stray bytes, scan, bad and good passwords from a client that reads frames out of the log stream, Improv over BLE, per board notes
|
||||
- [`arduino_pico.md`](arduino_pico.md): arduino-pico framework bump A/B: W5100S Ethernet soak, Pico W fallback AP client count, Pico W bluetooth_proxy GATT hold, web_server SSE stalls, `/events` churn crashes and never completed connects, W5100S OTA without `interrupt_pin`
|
||||
- [`bluedroid_gattc_queue.md`](bluedroid_gattc_queue.md): queued MTU request and execute write recursion that overflows BTU_TASK, ble_client central against an ESP32-S3 peer
|
||||
@@ -62,3 +62,19 @@ Results: https://github.com/esphome/esphome/pull/16445#issuecomment-6335435397
|
||||
An API client that connects allocates about 15 times on ESP32: the connection object, then the list entities and
|
||||
initial state batches growing the `DeferredBatch` vector. A log subscription adds more per line. Connect before a
|
||||
heap measurement and subscribe to logs only afterwards (`heap_alloc.md`).
|
||||
|
||||
## Native API connect/disconnect stress (#14679, #14687, #14706)
|
||||
|
||||
`scripts/api/connstress.py HOST [ITERATIONS] [CONCURRENCY]` (aioesphomeapi; `API_KEY` env for a noise key) opens and
|
||||
closes native API connections as fast as it can, 500 attempts with 4 at a time by default, and ends with
|
||||
`RESULT PASS` or `RESULT FAIL`. It is the test that found the raw lwIP socket heap corruption, so run it for any change to
|
||||
the socket layer, the scheduler or locking on RP2040/RP2350 and ESP8266, with a bounded serial capture on the device:
|
||||
the client only sees resets, the crash is in the log.
|
||||
|
||||
- RP2040/RP2350 before #14687: crashed after 3 or 4 iterations (`malloc` from the lwIP accept IRQ while the main loop
|
||||
was in `malloc`: double free in `~APIFrameHelper`, `_malloc_r` in `APIConnection()`); after: 500/500. #14679 first
|
||||
added the lwIP locking between the lwIP callbacks and the main loop on RP2040.
|
||||
- ESP8266 before #14706: crashed within about 50 iterations (`umm_malloc_core` LoadStoreError, use after free of a
|
||||
closed PCB's callbacks); after: 490/500, the 10 failures are connection resets from overload, which is expected there.
|
||||
- ESP32 (BSD sockets) passes 500/500 on both and is the control.
|
||||
- Compare against dev on the same board; count reboots and decode crash addresses as well as the client's failures.
|
||||
@@ -0,0 +1,42 @@
|
||||
# arduino-pico framework bumps (RP2040/RP2350)
|
||||
|
||||
Scripts: `scripts/rp2_web_ble/` (README there). Used for #22671 (6.1.1 to 6.3.2).
|
||||
|
||||
- Build PR and dev with a private `PLATFORMIO_CORE_DIR` (`scripts/pio_build.sh` does; see `reference/boards.md`).
|
||||
Check the compile log line `framework-arduinopico @ 1.60302.0` per build.
|
||||
- Wired Ethernet (W5100S EVB): 6.3.2 defines `LWIP_ASSERT_CORE_LOCKED()` as `async_context_lock_check` on the
|
||||
Ethernet context (`cores/rp2040/lwip_wrap.cpp`), so unlocked lwIP calls panic there. Soak the API (200 ms template
|
||||
counter, 1 s uptime, logs subscribed), load pages, OTA and reboot; the rp2 crash handler shows a panic as
|
||||
`Crash (HardFault)` in the debug reset reason on the next boot.
|
||||
- Fallback AP client count: `ap_clients_` is protected and `WiFiComponent` is final; read it from an
|
||||
`esphome: includes:` header through an explicitly instantiated member pointer (`appeek.hpp`). Join raises it to 1.
|
||||
- bluetooth_proxy on the Pico W: `rp2_ble_tracker:` + `bluetooth_proxy: active: true`. Drive with `gatthold.py`
|
||||
against the ESP32-S3 server in `scripts/ble_notify/server.yaml`. UUID forms and the 0x3E connect failures are in
|
||||
`bluetooth_proxy.md`. A "Failed to send notify data response" warning at each disconnect is normal.
|
||||
- web_server SSE on the W5100S (dev 2a6a1a050e4, 6.1.1): every `/events` stream stops after 0.3 to 11 s (alone, with
|
||||
the API, or with page loads alike), then the EVB closes it with a FIN 5.8 to 6.3 s after its last data segment, so
|
||||
curl exits 0. The pcap shows every byte ACKed by the host, window 65535, no retransmits, nothing sent in the gap:
|
||||
the device simply stops writing. The 5 s gap matches RPAsyncTCP `ASYNC_MAX_ACK_TIME` (likely `_pcb_busy` not
|
||||
cleared, then `_onTimeout` closes). A new `/events`, GET / and the API keep working. Pico W: 60 s steady. On macOS
|
||||
`tcpdump` runs without sudo once your account is in the bpf group. Tools: `sserun.sh HOST TAG SECS alone|api|pages
|
||||
N` (pcap, netstat poll, API VERBOSE log, probes) and `pcapsum.py PCAP DEVICE_IP` (per connection last data, FIN/RST,
|
||||
retx). Confirmed with counters patched into the build's `.piolibdeps` copy of RPAsyncTCP: every stall is one
|
||||
`_sent()` underflow with `_tx_unacked_len` 0 and the pcb idle after `send()`; ESPAsyncWebServer 3.12.1 does not
|
||||
help. The esphome-libs RPAsyncTCP fork (`esphome-1.3.2`, 8efb83c) streams 16 x 30 s with no stall. `stallctr.py PCAP
|
||||
IP APILOG` lines the counters up with each stall.
|
||||
- `H=<device ip> churn.sh TAG SECS` (4 loops of 0.2 to 1.5 s `/events` connections) crashes the rp2 web_server: dev on
|
||||
the EVB, the fork build on the EVB and the Pico W. HardFault in `AsyncEventSource::send` from
|
||||
`deferrable_send_state`, about one reboot every 10 to 20 s. Ten quick reboots put the board in safe mode (ping and
|
||||
OTA port 2040 only); OTA a build to recover.
|
||||
- **Never flash the W5100S EVB a build without `interrupt_pin`** unless you can reach BOOTSEL: arduino-pico then polls
|
||||
the W5100 from an async_context timer that every lwIP call pushes back, so the esphome OTA read loop starves the
|
||||
poller and OTA never completes (the device ACKs the hello, then never the features byte). Web and API still work.
|
||||
The board has no USB CDC port with ESPHome firmware, so the only way back is BOOTSEL and the UF2 drive.
|
||||
- `churnflow.sh` (in `rp2_web_ble/`) repeats `churn.sh` with heap and main loop checks and reflashes by OTA when a
|
||||
round left the board in safe mode.
|
||||
- `leakflow.sh` with `neverconn.py HOST N rst|head`: ESPAsyncWebServer 3.9.6 leaks about 175 B per `/events` client
|
||||
that resets before the response head is ACKed (52 KB per 300); 3.12.1 stays flat.
|
||||
- `/events` churn also hangs the BK7238 main loop or drops it off the network on dev; recover with a serial reset.
|
||||
- The API has 3 sockets on these builds: connstress at concurrency 4 always shows some "dropped after hello" failures;
|
||||
use 2 for a clean 500/500.
|
||||
- IRQ context scheduler test for #22688: `scripts/rp2_sched_lock/`, described in `scheduler.md`.
|
||||
@@ -0,0 +1,47 @@
|
||||
# Bluedroid GATT client command queue
|
||||
|
||||
## Queued MTU request recursion overflows BTU_TASK (#17954, #22670)
|
||||
|
||||
Bluedroid's `bta_gattc_pop_command_to_send()` runs the head of `p_cmd_list` and removes it only after
|
||||
`bta_gattc_sm_execute()` returns. When that head is an MTU request (or an execute write) whose send fails at once,
|
||||
the failure path pops again with the same command still at the head, so it recurses until the BTU task stack
|
||||
overflows. Every ESP-IDF release so far; PR #22670 fixes it in ESPHome with linker wraps
|
||||
(`bluedroid_gattc_queue.c`).
|
||||
|
||||
Rig, `scripts/bluedroid_mtu_recursion/`:
|
||||
|
||||
- Peer: an ESP32-S3 with `btusrv.yaml` (`esp32_ble_server`, one readable and writable characteristic, advertising).
|
||||
- Central: a classic ESP32 devkit with `btu-common.yaml` plus a per-build file like `btucli-example.yaml` (set
|
||||
`peer_mac` to the peer's Bluetooth MAC, which is its Wi-Fi MAC + 2, and give each build its own name).
|
||||
`CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK: y` makes the overflow panic at the write:
|
||||
`Stack canary watchpoint triggered (BTU_TASK)`.
|
||||
- Each connection: `on_connect` looks up the characteristic handle right away (a `ble_client` with no child nodes
|
||||
releases services and cleans the GATT cache in the same SEARCH_CMPL event, so a lookup after a delay finds
|
||||
nothing), waits 1.5 s, then suspends `BTU_TASK`, calls `esp_ble_gap_disconnect`, queues 4 reads and one MTU
|
||||
request, waits 30 ms and resumes. The batch is the key: sent one at a time, the BTU task handles each request
|
||||
before the next arrives and nothing waits in the queue. The reads fail and keep the command slot busy so the MTU
|
||||
request is queued; when popped, `GATTC_ConfigureMTU` fails with "BT_GATT: connection not established".
|
||||
`ble_client` reconnects on its own and the next round starts.
|
||||
- `analyze.py CAPTURE` counts rounds, BTU canary crashes, boots, reconnects with and without a reboot and MTU 517.
|
||||
- Decode with the IDF `xtensa-esp32-elf-addr2line -pfiaC`; the overflow shows the repeating
|
||||
`pop_command_to_send (act.c:1739/1746) -> sm_execute -> cfg_mtu (act.c:1042)` frames.
|
||||
|
||||
Results on ESP-IDF 5.5.6: dev at 46844d3631 crashed 73 of 73 rounds in 5.5 min (every round, about 4.5 s per
|
||||
reboot cycle); the PR at ad787163fd ran with no crash and reconnected without a reboot each time. Check the wraps are
|
||||
linked with `nm firmware.elf | grep __wrap_GATTC_ConfigureMTU` (native ESP-IDF builds only; the define is
|
||||
`USE_ESP32_BLE_BLUEDROID_GATTC_QUEUE`).
|
||||
|
||||
### Execute write variant
|
||||
|
||||
`btuxw-example.yaml` sets `exec_write: "true"`, which sends `esp_ble_gattc_execute_write(gattc_if, conn_id, true)`
|
||||
in place of the MTU request. No prepare write is needed: Bluedroid does not check for prepared writes, and
|
||||
`GATTC_ExecuteWrite` fails synchronously with the same "connection not established" error. The variant also sets
|
||||
`CONFIG_BT_LOG_GATT_TRACE_LEVEL_API: y`, so each send logs `BT_GATT: GATTC_ExecuteWrite conn_id=... is_execute=1`,
|
||||
and those lines are counted per round with awk between the `ROUND n start` lines. In a few rounds (about 3 to 14%)
|
||||
the controller reports the disconnect before the command is popped. Those rounds log no execute send and never
|
||||
crash, so count "rounds that reached the send", not all rounds. Most dev backtraces in this variant are cut off in
|
||||
`vTaskSwitchContext` (the extra trace logging makes task switches more likely at the moment of overflow). Use the
|
||||
complete ones to decode the `bta_gattc_execute (act.c:1352)` cycle.
|
||||
|
||||
Results: dev 46844d3631 had 81 rounds, 70 reached the send, and all 70 crashed. PR e51f0b8321 had 151
|
||||
rounds, 147 reached the send with exactly one execute line each, and there were 0 crashes and 1 boot.
|
||||
@@ -55,3 +55,15 @@ real device uses, decode an Android HCI snoop: a Read By Type response lists its
|
||||
- Give the proxy an `api` encryption key (`API_KEY` for the scripts). A Home Assistant on the same network connected to
|
||||
a plaintext test proxy and took over its Bluetooth subscription (`Subscription from Home Assistant ... replaces
|
||||
aioesphomeapi`), dropping the test client's connection mid-run.
|
||||
|
||||
## GATT UUID forms through a proxy (#22679)
|
||||
|
||||
`scripts/gatt_uuid/`: `server.yaml` (the `ble_notify` server plus a service with 128 bit, 32-bit base and 16 bit
|
||||
UUIDs on characteristics and descriptors, and 2901 and 2902; set the name with `-s name`), `gattlist.py PROXY PEER
|
||||
OUT.json` (lists every UUID, reads, notifies 10 s, retries 0x3E), `cmp.py REF.json OTHER.json` (entry by entry diff,
|
||||
exits 1 on a difference) and `run.sh NAME` (Pico W proxy from `rp2_web_ble/picow.yaml`, list, compare). Take the
|
||||
reference from an ESP32 proxy (unset `API_KEY` for a plaintext API).
|
||||
|
||||
- On rp2 before #22679, BTstack truncated 32-bit base UUIDs with a nonzero low half to 16 bits (`5ec10001-...` came
|
||||
out as `00000001-...`); a zero low half (5ec10000) came through intact.
|
||||
- Connects through the Pico W proxy fail with 0x3E now and then (see `reference/boards.md`); the scripts retry.
|
||||
@@ -24,3 +24,11 @@ put `scripts/` on `PYTHONPATH`):
|
||||
- Quick crash reboots count toward BK72xx safe mode, so space out back-to-back crash tests on those boards.
|
||||
- A device that keeps the previous crash replays it to every new log client until the next crash; that is one
|
||||
record, not two.
|
||||
|
||||
## Crash records and log subscribers
|
||||
|
||||
The record is replayed and cleared by the first log subscribe (`on_subscribe_logs_request`), so drain it on the
|
||||
first boot after an OTA, or a stale record from the previous build shows up. Moving `api: port:` keeps Home Assistant
|
||||
off the board while testing. `scripts/crash_report/quiet_then_subscribe.py HOST PORT OUT N` drains the record, stays
|
||||
connected without a log subscription for N reboots, then subscribes and records the replayed record; it tells a crash
|
||||
that needs a log subscriber (like the W5500 IPv6 reboot abort in `reference/boards.md`) from one that does not.
|
||||
@@ -2,13 +2,13 @@
|
||||
|
||||
## Fake devices on an in-firmware I2C bus
|
||||
|
||||
When there is no chip and no wiring, subclass `i2c::I2CBus` in an include, implement `write_readv()` only, answer
|
||||
the registers the driver reads and check each write. Point the component at it from an `on_boot` lambda that runs
|
||||
before the component's `setup()`: `id(x)->set_i2c_bus(&fake::bus)` at priority 950, which is ahead of every I2C
|
||||
component (hubs set up at IO, 900, sensors at DATA, 600). The configs here that use 700 to 1000 work for their
|
||||
components; use 950 for a new one. Keep a real `i2c:` block in the config so validation passes. Bulk
|
||||
loops in a button lambda must call `App.feed_wdt()` and keep their per-iteration logs below INFO: 2000 DEBUG lines at
|
||||
115200 baud trip the task watchdog, which is a fault of the harness and not of the PR.
|
||||
When there is no chip and no wiring, subclass `i2c::I2CBus` in an include, implement `write_readv()` only, answer the
|
||||
registers the driver reads and check each write. Point the component at it from an `on_boot` lambda that runs before the
|
||||
component's `setup()`: `id(x)->set_i2c_bus(&fake::bus)` at a priority above the swapped component's own setup priority
|
||||
(a hub at BUS - 0.1 needs 999.95; 950 is ahead of hubs at IO, 900, and sensors at DATA, 600). Keep a real `i2c:` block
|
||||
in the config so validation passes. Bulk loops in a button lambda must call `App.feed_wdt()` and keep their
|
||||
per-iteration logs below INFO: 2000 DEBUG lines at 115200 baud trip the task watchdog, which is a fault of the harness
|
||||
and not of the PR. Sensor publishes log at VERBOSE, so log entity values from a lambda (`on_value` or an interval).
|
||||
|
||||
`templates/i2c_fake/` holds the fakes; each `*-common.yaml` or `*-test.yaml` is a classic ESP32 or ESP32-S3 config
|
||||
that includes its `.hpp` (add `esphome: name:` for the `-common` ones):
|
||||
@@ -151,3 +151,42 @@ Prefer this to glitching the wire. Holding SDA low by rerouting the pin (`esp_ro
|
||||
`SIG_GPIO_OUT_IDX` and back to `I2CEXT0_SDA_OUT_IDX`) wedges the ESP-IDF controller, which then needs
|
||||
`i2c_master_bus_reset()` after each glitch, and glitches timed onto writes left the VL53L0X answering 0x00 until a
|
||||
power cycle.
|
||||
|
||||
## WeiKai WK2168 on I2C (#22759)
|
||||
|
||||
`templates/i2c_fake/wkfake.hpp` + `wk-common.yaml`: answers 0x10 to 0x17 (`0 A1 A0 1 0 C1 C0 F`), keeps only A3..A0 of
|
||||
the register byte and builds the 6 bit address C1C0A3..A0, models the globals (a GRST write resets the channels in its
|
||||
low nibble and logs `!!!!! GRST WRITE`), per-channel SCR/LCR/FCR/baud/RFCNT/FSR and FIFOs (TX logged, RX injected with
|
||||
`inject_rx`, dropped when SCR is off), GPDIR/GPDAT with `set_input()`. It classifies each transaction W / P (1 byte
|
||||
pointer) / R / WR (repeated start); `fail_reads`, `fail_ptr` and `every_n` inject NACKs and the fake counts whether
|
||||
the next read is a retry of the same register. The driver polls RFCNT and FSR of every channel and GPDAT every loop:
|
||||
log only writes, changes and a `trace` window, never every read. `wk-map-check.cpp.example` is a host check with
|
||||
copies of the driver's `i2c_address()` (the same in both trees) and the PR's `i2c_register()`, comparing the address
|
||||
and register byte each tree sends for every register; paste the current bodies in before running it. On #22759 the
|
||||
base build's GPIO writes hit GRST and reset UART channel 0.
|
||||
|
||||
## BMI270 config upload and BMM150 aux (#22778)
|
||||
|
||||
`bmi270fake.hpp` + `bmi270-common.yaml` + `bmi270-motion-aux.yaml`: BMI270 register file with reset values; config
|
||||
upload port (INIT_ADDR word address, INIT_DATA into 8 KB) where INTERNAL_STATUS reads 0x01 only when every byte was
|
||||
written once and FNV-1a equals `expected_fnv` (default 0x95BB75B5, the current table, computed on the host from
|
||||
bmi270_config.h; the host harness takes an override in `BMI_EXPECTED_FNV`), else 0x02. Aux interface: AUX_DEV_ID selects
|
||||
the BMM150, manual mode turns AUX_WR_ADDR/AUX_RD_ADDR writes into BMM150 writes and 1/2/6/8 byte reads into AUX_X..,
|
||||
STATUS.aux_busy for two polls, auto mode mirrors the BMM150 data. Fault knobs: `bmm_mode` (absent, wrong chip id),
|
||||
`busy_stuck`, `stuck_from_aux_op` (busy stuck from the Nth aux transfer: 1 power-on, 2 soft reset, 3 chip id, 4 to 6
|
||||
trim, 7 normal mode), `nack_at` (main-bus transaction N). `norm_fnv` hashes register-level effects and leaves STATUS
|
||||
polls out (their count depends on timing). Heap is sampled at INIT_CTRL=0/1 and inside each INIT_DATA burst;
|
||||
`-DBMI_FAKE_WRAP_MALLOC` with `-Wl,--wrap=malloc` in `platformio_options: build_flags` counts malloc() during the upload
|
||||
through `alloc_count.hpp` (list it in `includes:` too; the link fails without the wrap, so a clean link proves it
|
||||
applied).
|
||||
- Host side: copy `bmi270-host-harness.cpp.example` (as a `.cpp`) and the fake into `tests/components/bmi270/` of both
|
||||
worktrees, plus a `benchmark.yaml` with `esphome: build_flags: [-DUSE_BMI270_BMM150, -DUSE_LOG_LISTENERS,
|
||||
-DESPHOME_LOG_MAX_LISTENERS=4]` (the unit test build does not use defines.h; this is how to get a component's
|
||||
optional code and log capture into it); the base also needs the PR's `__init__.py` manifest override.
|
||||
`bmi270-setters.py` turns each tree's generated main.cpp (`esphome compile --only-generate`) into the setter list
|
||||
the harness applies, so codegen changes (setters skipped at defaults) are tested as generated.
|
||||
`bmi270-host-run.sh.example TREE NAME SETTERS [32]` runs it (32 forces the Arduino burst branch);
|
||||
`bmi270-host-compare.py BASE.report PR.report` merges base's split INIT_ADDR writes, compares every config, fault and
|
||||
per-step scenario, maps the NACK sweep through the merged stream and lists every log difference.
|
||||
`bmm150-sweep.cpp.example` compares a decoder against a namespace-renamed copy of the base header bit for bit.
|
||||
- A planted one byte burst offset gave INTERNAL_STATUS 0x02 and "Config file upload failed" at both burst sizes.
|
||||
@@ -14,3 +14,39 @@ On the NiceMCU WB3S V1 board (BK7238), P26 and P24 are on the right-hand header.
|
||||
|
||||
Fake devices that need no real chip (in-firmware buses, the Pico 2 W target, the DS2482-800 simulator, NACK
|
||||
injection) are in [fake_i2c.md](fake_i2c.md).
|
||||
|
||||
## I2C wire A/B of a bus change (#22780, write_prefixed)
|
||||
|
||||
`scripts/i2c_wire_ab/`.
|
||||
- Host (`host/run.sh TREE OUT`, then `host/compare.py BASE PR`): copies a harness into the tree's
|
||||
`tests/components/i2c/` (removed again afterwards) and runs `script/cpp_unit_test.py i2c`. `extract.py` cuts the
|
||||
Arduino and ESP-IDF `write_readv`/`transfer_` bodies out of the tree and compiles them against the tree's real headers
|
||||
with stub `Wire.h` (esp8266 core 3.1.2 and arduino-pico 6.3.2 buffer rules, 128 and 256 bytes) and a stub
|
||||
`driver/i2c_master.h` (IDF 5.5.5 checks: at most SOC_I2C_CMD_REG_NUM jobs, NACK before STOP); the software bus is
|
||||
compiled whole with `#define InternalGPIOPin wab::FakePin` over a bit-level target. Every bus emits one token stream
|
||||
(`S 90+ 02+ ... P`, `Sr`, `rA0+`), with mallocs counted through macOS `malloc_logger` (ASan is dropped on macOS).
|
||||
Stub headers must live outside the test dir (a subfolder there is taken as a platform domain) and reach the build
|
||||
through a `benchmark.yaml` `esphome: build_flags: [-I...]`; `.h` files in the test dir are included into main.cpp, so
|
||||
generated bodies are `.inc`. Explicit-instantiation member robbers must be declared at global scope. The sources are
|
||||
stored as `.cpp.example`, `.h.example` and `.hpp` so the repo's C++ lints skip them; `run.sh` copies them back.
|
||||
- Device: `dev/snf.hpp` is a GPIO interrupt sniffer on the I2C pads (an ESP32-C2 with an ADS1015: SDA 4, SCL 5,
|
||||
`dev/c2common.yaml`) plus the same case sweep and a malloc counter; at 10 to 20 kHz on the C2 it still drops a bit in
|
||||
about 0.5 % of transactions (mostly at the chip's NACK), so capture three runs per build with
|
||||
`dev/flashrun.sh NAME YAML PORT SECONDS SUFFIX` (suffix empty, 2 and 3 write NAME-ser.txt, -ser2 and -ser3) and
|
||||
judge with `clean.py` (`--nacks` sorts each DIFF into a chip NACK or not) and `maj.py`, which also takes one or two
|
||||
captures. On the software bus it is exact. `dev/pdslave.hpp` with `snf.hpp` built with `-DSNF_PDSLAVE`
|
||||
(`pdcommon.yaml`) turn an ESP32-PICO-D4 into its own target at 0x48 on GPIO32/33 (ACKs every byte, so 300-byte
|
||||
writes reach the wire): exact on 6 of 6 captures at 25 kHz once one warm-up probe runs before the sweep (the ISR
|
||||
runs from flash; IRAM_ATTR on header inline functions fails to link with l32r literal errors). `mksw.py` turns a
|
||||
tree's LibreTiny-only software bus into a header so an ESP32 build can run it on real pins. The ADS1015 NACKs the
|
||||
third byte after the pointer, so long writes on that chip end there on every build.
|
||||
- `ard/swp.hpp` is the same sweep for ESP8266 (GPIO interrupt sniffer on GPIO4/5), RP2 (raw IO_IRQ_BANK0 handler) and
|
||||
BK72xx (no sniffer, so `ard/ardcmp.py --reads-by-data` compares reads by their data), with `ard/common.yaml` plus a
|
||||
board file (`d1.yaml`, `pico.yaml`, `bk.yaml`). Both sweeps share the decoder in `wiredecode.hpp` and count heap
|
||||
calls with `templates/i2c_fake/alloc_count.hpp`, which names the link flag for each platform. Each image checks
|
||||
itself with `ALLOC_PROBE 1`. `buildall.sh YAML...` builds the configs of either folder, each under the `name` of
|
||||
its substitutions (the file name without one), `x-pr.yaml` from PR_TREE and the rest from BASE_TREE.
|
||||
- Facts: on a D1 mini without a target, register writes up to 128 bytes total show `S 90- P`, longer ones fail with
|
||||
rc 6 and nothing on the wire; a write+read whose address is NACKed leaves no STOP (`S 90-`), dev too.
|
||||
arduino-pico: after a register write over 256 bytes, the next empty write (a probe) sends the stale buffer to the
|
||||
failed write's address.
|
||||
@@ -0,0 +1,46 @@
|
||||
# Improv serial and BLE (#22597)
|
||||
|
||||
`scripts/improv/` drives Improv on a freshly erased board with no saved network:
|
||||
|
||||
- `improvcli.py PORT OUT --secrets FILE`: Improv serial client. It shares the console with the logs and parses
|
||||
frames out of the log stream. The flow: 300 stray bytes with no `I` in them, state, info, network state, scan, a
|
||||
bad password (expect `unable_to_connect` after about 30 s), the real password, then state and network state
|
||||
again. It ends with a count of frames, bad frames, port resets, reboots and log lines. Credentials come from the
|
||||
secrets file and are never printed, and the SSID is masked in scan results. It reopens a native USB port that
|
||||
re-enumerates. A reboot is counted from each new `Running through setup()` log line after the settle, so a board
|
||||
behind a USB-UART bridge that reboots without a port reset is caught too.
|
||||
Every request must get its reply; a missing reply, an unexpected error, a malformed frame, a port reset or a
|
||||
reboot fails the run. `--skip-bad` leaves out the bad password case, `--keep-dtr` leaves DTR asserted,
|
||||
`--allow-reset` accepts a reboot.
|
||||
- `improvble.py NAME SECRETS`: Improv BLE client (bleak). Finds the device by name, sends WIFI_SETTINGS and prints
|
||||
the state changes and the RPC result URLs. Needs `improv_ble` (formerly `esp32_improv`) with `authorizer: none`
|
||||
and a `next_url`; the result must carry a URL.
|
||||
- `common.yaml`: package with Wi-Fi and no network, `web_server`, `improv_serial` with a `next_url` (so the
|
||||
provisioned reply carries URLs) and an ALIVE line every 5 s. `example-esp32.yaml` uses it on a classic ESP32.
|
||||
- `run.sh NAME [improvcli args]` (env `TREE`, `PORT`, `SECRETS`, `PY`): compile, erase, flash and run the client.
|
||||
It erases with esptool, so ESP chips only; on LibreTiny or RP2040 erase and flash with that platform's tools and
|
||||
run `improvcli.py` directly. Both clients end with PASS or FAIL and exit non-zero on FAIL.
|
||||
|
||||
Per board:
|
||||
|
||||
- Improv serial uses the logger's UART, so the client must open the port the log is on. On LibreTiny check which
|
||||
UART `logger: hardware_uart: DEFAULT` resolves to (see the board notes).
|
||||
- BW15: drop `web_server:` or add an `ap:` (it resets during setup otherwise), and pass `--allow-reset` for the known
|
||||
reboot after `Disabling AP`; the provisioned reply usually goes out first, not always. See `reference/boards.md`.
|
||||
- ESP32-C3 on USB_SERIAL_JTAG: passes with and without `--keep-dtr`; its reboots only show in the
|
||||
`Running through setup()` count (see `reference/boards.md`). The scan returns only the last scan's results, which
|
||||
are empty in the first seconds after boot; use `--settle 10` or more when the target network should be listed.
|
||||
- Pico 2 W: run with `--keep-dtr` (see `reference/boards.md`). Its Improv scan lists no networks, on dev and PR alike.
|
||||
- Erase the flash between builds: a saved network skips the provisioning path entirely. Both clients fail at once
|
||||
when the board already reports `provisioned`; erase the flash first. A new config name does not help: the
|
||||
network is saved under a fixed key when the config has no `networks:`. A provisioned board also stops advertising
|
||||
Improv over BLE, so `improvble.py` reports the device as not found.
|
||||
- If the real password fails right after the bad password case, rerun once before blaming the change: on the C3 it
|
||||
failed once (`Auth Leave` while Wi-Fi was still retrying the bad network) and passed on every rerun.
|
||||
|
||||
When posting results:
|
||||
|
||||
- Scan results list the neighbours' SSIDs; filter `RPC cmd=4 len=[1-9]` lines out of anything you post.
|
||||
- Mask IP addresses in the result URLs.
|
||||
- Cover a long password too: provision once against a network whose password is 20 characters or more (the client
|
||||
prints the length).
|
||||
@@ -61,3 +61,10 @@ frame of two LEDs set to `Color(0xA5, 0x3C, 0x0F)` reads `3ca50f3ca50f`.
|
||||
- An RP2350 `panic()` escalates to a HardFault and the rp2 crash handler reboots within about a second, so a panic
|
||||
during component setup boot-loops before USB CDC enumerates and the board looks dead (no port, no BOOTSEL drive).
|
||||
Hold BOOTSEL while plugging it in and flash the UF2 drive. To see such a fault, trigger it after boot.
|
||||
|
||||
## Counting a PIO strip's edges on its own pin (#16243)
|
||||
|
||||
A GPIO interrupt on the strip's own data pin (`gpio_set_irq_enabled_with_callback(pin, GPIO_IRQ_EDGE_RISE, ...)`)
|
||||
counts every bit the PIO program sends, with no wires or LEDs; a strip that sends nothing shows 0 edges per report.
|
||||
Log the PIO block's state machine enable mask and program counters next to the count. `pio_probe/pio-common.yaml`
|
||||
clears PIO1 instruction memory at boot because it survives a reflash (see `reference/boards.md`).
|
||||
@@ -34,3 +34,11 @@ wave on the same pad no longer reaches the input (the pad reads 0).
|
||||
- Result on #21074 at 2ef417bd81 with peripherals powered down: the PR caught all 644 real edges (dev 66) but added
|
||||
4642 calls while the line was high, one per sleep cycle (about 16 ms), with the level read correctly. Peripherals
|
||||
on: both builds caught every edge. https://github.com/esphome/esphome/pull/21074#issuecomment-6503939850
|
||||
|
||||
## Power lock check
|
||||
|
||||
`power_management: esp32_power_management` with `profiling: true` and an `interval` lambda that calls
|
||||
`esp_pm_dump_locks(stdout);` prints the lock and mode tables on the USB console (not through the ESPHome logger).
|
||||
Compare lock lists between builds: `usb_serial_jtag` holds `NO_LIGHT_SLEEP` by itself. For a soak that the USB console
|
||||
must not keep awake, set `logger: hardware_uart: UART0`, dump the locks into `open_memstream()` and log the SLEEP,
|
||||
CPU_MAX and light sleep count lines, read over the API.
|
||||
@@ -0,0 +1,29 @@
|
||||
# nPM1300 PMIC on the Seeed XIAO nRF54LM20A (#22661)
|
||||
|
||||
Scripts: `scripts/npm1300/`. The board's nPM1300 sits at 0x6B on P1.18 (SDA) and P1.17 (SCL); board facts, including
|
||||
which rails must never be switched off, are in `reference/boards.md`.
|
||||
|
||||
- Probe first: `npmprobe.yaml` has the hub with no regulator or charger settings, scans the bus and dumps the
|
||||
registers every 20 s, so you see what is on before any setting is written.
|
||||
- `npm-all.yaml` (with `npmcommon.yaml`) has every sensor, binary sensor, text sensor and switch, logs each value from
|
||||
`on_value` and `on_state` lambdas (entity state lines are VERBOSE on dev, so DEBUG shows nothing without them), dumps
|
||||
the registers and switch states, and toggles the charger and LDO1. Put a setting under test (the VBUS limit, the
|
||||
charger values) in `npmcommon.yaml`, not in the per-run file.
|
||||
- `regdump.yaml` reads a fixed register list with `id(pmic).read_register16()` and logs `REGS 0201=.. ...`; compare two
|
||||
builds' dumps after stripping timestamps and source line numbers.
|
||||
- `runone.sh NAME CONFIG PORT [SECS]` flashes with `esphome run --no-logs` (pyOCD) while a serial capture stays open on
|
||||
the same port. Builds without `ota:` have no MCUboot.
|
||||
|
||||
Findings:
|
||||
|
||||
- With no battery and the charger on, VBAT reads about 4.23 V, IBAT about 0.2 mA, battery detected is ON and the status
|
||||
flips between Trickle Charge and Constant Current; with the charger off it says No Battery, and it can drop to Not
|
||||
Charging for one update on its own. The battery temperature stays at 24.6 C (a fixed 10 k on the NTC pin). Charge
|
||||
current scale and sign need a real cell.
|
||||
- ADCIBATMEASSTATUS (0x0510) reads 0x0C (charge) most of the time with no cell and the charger on, sometimes 0x08 or
|
||||
0x0F.
|
||||
- `vbus_current_limit: 300mA` writes ILIM0 and ILIMSTARTUP as 0x03 and the board stays up on USB.
|
||||
- BUCKSWCTRLSEL (0x040F) keeps its value across reflashes until a power cycle, so a setup write to it shows no change on
|
||||
a warm board.
|
||||
- To prove a setup priority change, add `on_boot` hooks at 1001, 950 and 900 that log markers and see where the
|
||||
component's first publishes land between them.
|
||||
@@ -27,3 +27,13 @@ captures 40 s from boot and runs `ivsum.py`, which prints the run count, first r
|
||||
10 s after setup the scheduler frees its item pool and shrinks its `to_add_` and `items_` vectors
|
||||
(`SCHEDULER_FREELIST_TRIM_DELAY_MS` in `application.cpp`). The first burst of timers after that allocates new
|
||||
items and regrows the vectors once, so heap or timing measurements should skip the first run after boot.
|
||||
|
||||
## RP2 scheduler lock under IRQ and lwIP load (#22688)
|
||||
|
||||
`scripts/rp2_sched_lock/` (README there). The `irq_sched_stress` external component calls `defer()` and `set_timeout()`
|
||||
from a 300 us pico-sdk repeating timer while the main loop does the same; the removed item race integration fixture
|
||||
runs on the board as an API action. `flow.sh` runs the actions, API connect churn (`../api/connstress.py`), REST POST
|
||||
churn and both together, then the actions again, and fails on a failed action, a failed connstress 500x2 or a reboot.
|
||||
Judge by counts, not order: RP2 is `ESPHOME_THREAD_SINGLE`, so `defer()` order is not FIFO on any build. Keep
|
||||
`debug_scheduler` off, it logs from the IRQ. Dev before #22688 failed the defer count on the Pico W; the PR passed.
|
||||
`looptime.sh` compares the 16 ms interval gaps with the API and page loads running between two builds.
|
||||
@@ -73,3 +73,16 @@ address they do not simulate.
|
||||
- An `addressable_light` display writes nothing until its light is turned on.
|
||||
- Before calling a rebased PR's change trivial, diff the PR's own diff (head against its parent) old against new: a
|
||||
move that looks like a merge only can carry real commits from below.
|
||||
|
||||
## TRF7962A fake chip (#22188)
|
||||
|
||||
`scripts/trf7962a_sim/`: `trfsim.hpp` replaces the SPI component's bus (`SPIComponent` is final, so `spi_bus_` is
|
||||
reached through the explicit-instantiation member pointer trick) with a `FakeBus` from `on_boot` priority 800, between
|
||||
the bus (1000) and the reader's setup (600). The bus hands both of the reader's clients (MODE0 write, MODE1 read)
|
||||
delegates on one register, FIFO and IRQ model; the IRQ pad is switched to input/output after setup and driven by the
|
||||
model. `trfpr.yaml` runs the tag scenarios (none, present, slow, flaky, swap, collision, CRC, error flag, bad MSB,
|
||||
TX only, stuck IRQ) and prints per-phase counters (CS, field timing, TX payload, reads without an address). The
|
||||
same FakeBus approach works for any SPI chip whose reply depends on the address byte inside one CS window, which the
|
||||
ESP32 SPI slave cannot fake.
|
||||
The header targets the SPI API of the #22188 branch (`SPIBus` and `SPIComponent::spi_bus_`); dev has since dropped
|
||||
`SPIBus`, so on a newer tree the bus hook has to move to the new delegate creation before it builds.
|
||||
@@ -72,3 +72,23 @@ case, and `T1 X` shows which frames got through.
|
||||
about 49 s after reset. Only the second boot logs `CASE done`, so a skipped reboot fails the run.
|
||||
|
||||
See `rs485_frame.md` for the same cross-wired UART trick on an ESP32-C3.
|
||||
|
||||
## Duco ventilation box (#22560)
|
||||
|
||||
`scripts/uart_sim/duco/`: `ducosim.hpp` is the box model from `tests/integration/fixtures/uart_mock_duco.yaml` (ack
|
||||
plus answer, AA 01 stuffing, CRC16) on a second UART of the same board; on an ESP32-C6 the hub used tx 18 rx 19 and
|
||||
the box tx 19 rx 18 at 57600, wired across. `gen.py NAME pr|dev` writes the config (every text sensor, sensors, mode,
|
||||
comfort, sntp clock) with an `on_value` log per entity (`STATE id = '...'`, newlines as `\n`); `DUCO_VERBOSE=1` shows
|
||||
`Found node`, `DUCO_SERIAL_SIZE=18` gives the dev fixture's short serial answer. `run.sh NAME KIND SECONDS` (env
|
||||
`TREE`, `DUCO_PORT`, `PY`, optional `BUILD_LOCK`), run from a scratch directory with a copy of `ducosim.hpp`,
|
||||
generates, builds through `scripts/pio_build.sh`, flashes and captures with `scripts/serial_capture.py`; a pr build
|
||||
ends with `check.py` against `expected.txt` (exit 1 on a mismatch), and the model logs requests it has no answer for.
|
||||
- Answer one request per poll call. Answering a 26 request burst in one pass blocks about 100 ms and overflows the
|
||||
hub's 256 byte UART RX buffer, which silently drops the serial and version answers every round.
|
||||
- Dev's hub frame is 32 bytes: the PR model's 34 byte serial answer is dropped there and duco sets "No answer".
|
||||
- Error cases 7 (three long, 210 B) and 8 (four short, 148 B) check that the code-only fallback goes by length.
|
||||
|
||||
## ESP8266 software serial byte checks
|
||||
|
||||
The worst case for an unlock after a trailing run of high bits is a frame of bytes all below 0x80; a mixed frame
|
||||
hides it.
|
||||
@@ -59,3 +59,46 @@ valve, update, alarm_control_panel or water_heater entity reboots with `Exceptio
|
||||
`json::linked(const char *)` (the ROM `strlen` on a flash address), fixed by #21316. The cover in the template keeps
|
||||
that path covered; before #21316 is merged, apply its one line change to both trees or the web_server comparison
|
||||
cannot run.
|
||||
|
||||
## Basic auth on the async web servers (ESP8266, RP2040, LibreTiny)
|
||||
|
||||
`scripts/web_auth/` (see its README) fuzzes Basic auth over raw sockets: functional routes with and without
|
||||
credentials, wrong credentials, other schemes, a tampered hash, spacing and case, then large headers, many failed
|
||||
attempts next to an authenticated `/events` stream, and a timing comparison of wrong first and last bytes. It also
|
||||
has a captive portal client package that probes `/`, `/config.json`, POST with and without credentials and
|
||||
`/wifisave`. `compare.py` lines a dev run up with a PR run. These scripts were still being extended when copied here.
|
||||
The README also covers the newer flows: the heap under paced connection churn (`heap_churn.py`, the LibreTiny TIME_WAIT
|
||||
check for #22696) and the main task stack high-water mark with the JSON arena (`arena/`, #22699).
|
||||
|
||||
## Per-session /events listing on ESP32 (#22691)
|
||||
|
||||
Checks that a new `/events` client's entity listing goes only to that client. Config
|
||||
`scripts/web_server/sse-listing.yaml` (ESP32 ESP-IDF, web_server version 3, 19 entities, 3 sorting groups, heap logged
|
||||
every 5 s); build each head with a different `-s name` through `pio_build.sh`. Driver:
|
||||
`python -I scripts/web_server/sse_listing.py DEVICE_IP --rounds 4 --out events.jsonl`. Each round opens streams 1 and
|
||||
2, waits for their listing, connects stream 3 and counts for 10 s per stream. A `state` event that carries `domain`
|
||||
is a full detail (detail_all) entry; a `ping` with only `uptime` is the 10 s keepalive, any other `ping` the greeting
|
||||
(config JSON). The greeting and `sorting_group` events always go only to the new session, so only the detail_all
|
||||
count tells the builds apart. Ends `RESULT PASS` or `RESULT FAIL` (exit 0 or 1).
|
||||
|
||||
On an ESP32-PICO-D4 the control sent all 19 detail_all entries to streams 1 and 2 on every round, the PR none; stream 3
|
||||
was ordered on both.
|
||||
|
||||
## /events stream rework checks (#21973)
|
||||
|
||||
Config `scripts/web_server/stream-dut.yaml` (ESP32 ESP-IDF, 20 ms template sensor, a "Wifi Drop" button that runs
|
||||
`wifi.disable`, 8 s, `wifi.enable`, heap every 5 s). `scripts/web_server/stream_retest.py HOST MODE` has five modes:
|
||||
`head` (raw bytes of the first 3 s; compare two builds with `head_compare.py A B NAME_A NAME_B`, which masks numbers
|
||||
and the device name), `multi` (4 clients 20 s, events and longest gap), `stall` (a client with a 2 KB receive buffer
|
||||
stops reading for 35 s; read the close time from `Closing stuck stream`, or `Closing stuck EventSource connection` on
|
||||
older builds), `wifidrop` (REST press, the client reconnects after 5 s idle like a browser `EventSource`) and `churn`
|
||||
(40 connects, 20 of them reset, then a fresh client). `stream_runall.sh NAME PORT` uploads, captures and runs every
|
||||
mode. Both builds should close the stalled stream at about 20 s and close the stream at the Wi-Fi drop.
|
||||
|
||||
- `sse_listing.py` prints stream 3's TCP connect and first event times. A late greeting (3 to 4 s) was TCP connect
|
||||
time on the network (SYN retransmits), seen on the control too, not the device.
|
||||
- On a noisy Wi-Fi network multi-client runs fell to 110 to 900 events per client with every client pausing together,
|
||||
and a stalled client sometimes missed the EOF although the device logged `Closing stuck stream`. Alternate the
|
||||
builds (flash A, 4 multi runs, flash B, repeat) before calling a rate difference.
|
||||
- Log text check for refactors: collect every `[web_server*]` line from all captures, mask timestamps, source line
|
||||
numbers and digits, `sort -u`, and diff the two builds' sets.
|
||||
@@ -21,3 +21,23 @@ uart_button/uartbtn*.yaml
|
||||
value_range/rng*.yaml
|
||||
ld2420_sim/ldenergy*.yaml
|
||||
ld2420_sim/ldsimple*.yaml
|
||||
apikey.txt
|
||||
pio/
|
||||
rp2_web_ble/*.log
|
||||
rp2_web_ble/*.txt
|
||||
rp2_web_ble/*.pcap
|
||||
gatt_uuid/*.json
|
||||
gatt_uuid/*.txt
|
||||
web_auth/configs/*.log
|
||||
web_auth/configs/*.txt
|
||||
web_auth/configs/*.json
|
||||
improv/*.log
|
||||
npm1300/*-cap.txt
|
||||
npm1300/*-cap.err
|
||||
npm1300/*-run.log
|
||||
rp2_sched_lock/*.txt
|
||||
rp2_sched_lock/*.log
|
||||
i2c_wire_ab/*/*-ser*.txt
|
||||
i2c_wire_ab/*/*-flash.log
|
||||
i2c_wire_ab/*/*-compile.log
|
||||
i2c_wire_ab/*/*-upload.log
|
||||
@@ -0,0 +1,88 @@
|
||||
"""
|
||||
Rapid native API connect/disconnect stress test (from esphome#14687 and esphome#14706).
|
||||
|
||||
usage: connstress.py HOST [ITERATIONS] [CONCURRENCY] (default 500 iterations, 4 at a time)
|
||||
env: API_KEY (base64 noise key; unset, empty or - for plaintext), API_PORT (default 6053), API_PASSWORD
|
||||
Each attempt connects with login, disconnects and counts a failure on any error or a 10 s timeout on either step.
|
||||
Exits 1 when any attempt failed. Watch the serial log for crashes: the client only sees resets.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import contextlib
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
|
||||
from aioesphomeapi import APIClient
|
||||
|
||||
HOST = sys.argv[1] if len(sys.argv) > 1 else sys.exit(__doc__)
|
||||
PORT = int(os.environ.get("API_PORT", "6053"))
|
||||
PASSWORD = os.environ.get("API_PASSWORD", "")
|
||||
NOISE_PSK = (
|
||||
None if os.environ.get("API_KEY") in (None, "", "-") else os.environ["API_KEY"]
|
||||
)
|
||||
|
||||
|
||||
async def connect_disconnect(client_id: int, iteration: int) -> tuple[int, bool, str]:
|
||||
cli = APIClient(HOST, PORT, PASSWORD, noise_psk=NOISE_PSK)
|
||||
try:
|
||||
await asyncio.wait_for(cli.connect(login=True), timeout=10)
|
||||
# a disconnect that hangs on a wedged device is a failure too, not a stuck slot
|
||||
await asyncio.wait_for(cli.disconnect(), timeout=10)
|
||||
return iteration, True, ""
|
||||
except Exception as e: # noqa: BLE001 every failure is a counted result
|
||||
return (
|
||||
iteration,
|
||||
False,
|
||||
f"client{client_id} iter{iteration}: {type(e).__name__}: {e}",
|
||||
)
|
||||
finally:
|
||||
with contextlib.suppress(Exception):
|
||||
await asyncio.wait_for(cli.disconnect(force=True), timeout=10)
|
||||
|
||||
|
||||
async def main() -> None:
|
||||
iterations = int(sys.argv[2]) if len(sys.argv) > 2 else 500
|
||||
concurrency = int(sys.argv[3]) if len(sys.argv) > 3 else 4
|
||||
print(f"Iterations: {iterations}, Concurrency: {concurrency}", flush=True)
|
||||
|
||||
success = fail = 0
|
||||
errors: list[str] = []
|
||||
start = time.monotonic()
|
||||
sem = asyncio.Semaphore(concurrency)
|
||||
|
||||
async def run(client_id: int, iteration: int) -> tuple[int, bool, str]:
|
||||
async with sem:
|
||||
return await connect_disconnect(client_id, iteration)
|
||||
|
||||
tasks = [asyncio.create_task(run(i % concurrency, i)) for i in range(iterations)]
|
||||
for coro in asyncio.as_completed(tasks):
|
||||
_, ok, err = await coro
|
||||
if ok:
|
||||
success += 1
|
||||
else:
|
||||
fail += 1
|
||||
errors.append(err)
|
||||
total = success + fail
|
||||
if total % 10 == 0 or not ok:
|
||||
rate = total / max(time.monotonic() - start, 1e-6)
|
||||
print(
|
||||
f"[{total}/{iterations}] ok={success} fail={fail} ({rate:.1f}/s)",
|
||||
flush=True,
|
||||
)
|
||||
if err:
|
||||
print(f" ERROR: {err}", flush=True)
|
||||
|
||||
elapsed = time.monotonic() - start
|
||||
print(f"\nDone in {elapsed:.1f}s")
|
||||
print(f"Success: {success}, Failed: {fail}, Rate: {iterations / elapsed:.1f}/s")
|
||||
if errors:
|
||||
print("\nLast 10 errors:")
|
||||
for e in errors[-10:]:
|
||||
print(f" {e}")
|
||||
print("RESULT", "PASS" if fail == 0 else "FAIL")
|
||||
sys.exit(1 if fail else 0)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
@@ -4,6 +4,7 @@ Import it with this directory on sys.path (the drivers add their parent director
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
from collections.abc import Awaitable, Callable
|
||||
import contextlib
|
||||
import os
|
||||
import re
|
||||
@@ -27,19 +28,32 @@ FATAL = (
|
||||
)
|
||||
|
||||
|
||||
async def connect(host: str, tries: int = 30, timeout: float = 10) -> APIClient:
|
||||
async def connect(
|
||||
host: str,
|
||||
tries: int = 30,
|
||||
timeout: float = 10,
|
||||
port: int = 6053,
|
||||
on_stop: Callable[[bool], Awaitable[None]] | None = None,
|
||||
) -> APIClient:
|
||||
"""Connect and log in, retrying once a second; exits after TRIES failures with the last error.
|
||||
|
||||
API_KEY in the env selects Noise; unset, empty or - is plaintext.
|
||||
API_KEY in the env selects Noise; unset, empty or - is plaintext. ON_STOP is called when the connection ends.
|
||||
"""
|
||||
key = os.environ.get("API_KEY")
|
||||
last: BaseException | None = None
|
||||
for _ in range(tries):
|
||||
c = APIClient(
|
||||
host, 6053, None, noise_psk=None if key in (None, "", "-") else key
|
||||
host, port, None, noise_psk=None if key in (None, "", "-") else key
|
||||
)
|
||||
live = [False]
|
||||
|
||||
# a failed attempt's cleanup may call on_stop too; pass on only stops of the returned client
|
||||
async def stop(expected: bool, live: list[bool] = live) -> None:
|
||||
if live[0] and on_stop is not None:
|
||||
await on_stop(expected)
|
||||
|
||||
try:
|
||||
await asyncio.wait_for(c.connect(login=True), timeout)
|
||||
await asyncio.wait_for(c.connect(on_stop=stop, login=True), timeout)
|
||||
except FATAL as e:
|
||||
sys.exit(f"no API connection to {host}: {type(e).__name__}: {e}")
|
||||
except Exception as e: # noqa: BLE001
|
||||
@@ -49,6 +63,7 @@ async def connect(host: str, tries: int = 30, timeout: float = 10) -> APIClient:
|
||||
await c.disconnect(force=True)
|
||||
await asyncio.sleep(1)
|
||||
else:
|
||||
live[0] = True
|
||||
return c
|
||||
sys.exit(
|
||||
f"no API connection to {host} after {tries} tries: {type(last).__name__}: {last}"
|
||||
@@ -58,3 +73,80 @@ async def connect(host: str, tries: int = 30, timeout: float = 10) -> APIClient:
|
||||
def log_text(msg) -> str:
|
||||
"""The message of a subscribe_logs callback as text, without ANSI colour codes."""
|
||||
return ANSI.sub("", msg.message.decode(errors="replace"))
|
||||
|
||||
|
||||
def stop_event() -> tuple[asyncio.Event, Callable[[bool], Awaitable[None]]]:
|
||||
"""An Event and an on_stop callback for connect() that sets it when the connection ends."""
|
||||
ev = asyncio.Event()
|
||||
|
||||
async def on_stop(expected: bool) -> None:
|
||||
ev.set()
|
||||
|
||||
return ev, on_stop
|
||||
|
||||
|
||||
async def ble_connect(
|
||||
cli: APIClient,
|
||||
addr: int,
|
||||
on_lost: Callable[[int], None] | None = None,
|
||||
advert_timeout: float = 60,
|
||||
timeout: float = 30,
|
||||
) -> tuple[bool, int, int, Callable[[], None]]:
|
||||
"""Wait for an advert from ADDR, then connect through the proxy without a cache (like Home Assistant).
|
||||
|
||||
Returns (connected, mtu, error, cancel); a missing advert or a connect timeout gives (False, 0, -1, cancel), so
|
||||
callers can retry. ON_LOST(error) is called when the link drops later.
|
||||
"""
|
||||
seen = asyncio.Event()
|
||||
unsub = cli.subscribe_bluetooth_le_raw_advertisements(
|
||||
lambda m: (
|
||||
seen.set() if any(a.address == addr for a in m.advertisements) else None
|
||||
)
|
||||
)
|
||||
try:
|
||||
await asyncio.wait_for(seen.wait(), advert_timeout)
|
||||
except TimeoutError:
|
||||
return False, 0, -1, lambda: None
|
||||
finally:
|
||||
unsub()
|
||||
first: asyncio.Queue = asyncio.Queue()
|
||||
pending = True
|
||||
|
||||
def on_state(connected: bool, mtu: int, err: int) -> None:
|
||||
nonlocal pending
|
||||
if pending:
|
||||
pending = False
|
||||
first.put_nowait((connected, mtu, err))
|
||||
elif not connected and on_lost is not None:
|
||||
on_lost(err)
|
||||
|
||||
cancel = await cli.bluetooth_device_connect(
|
||||
addr,
|
||||
on_state,
|
||||
timeout=timeout,
|
||||
address_type=0,
|
||||
feature_flags=0xFF,
|
||||
has_cache=False,
|
||||
)
|
||||
try:
|
||||
connected, mtu, err = await asyncio.wait_for(first.get(), timeout + 5)
|
||||
except TimeoutError:
|
||||
return False, 0, -1, cancel
|
||||
return connected, mtu, err, cancel
|
||||
|
||||
|
||||
async def enable_notify(
|
||||
cli: APIClient, addr: int, ch, on_notify: Callable[[int, bytearray], None]
|
||||
) -> bool:
|
||||
"""Start notify on characteristic CH and write its first CCCD (2902) like Home Assistant.
|
||||
|
||||
Returns False when the characteristic lists no CCCD.
|
||||
"""
|
||||
await cli.bluetooth_gatt_start_notify(addr, ch.handle, on_notify)
|
||||
cccd = next(
|
||||
(d for d in ch.descriptors if d.uuid.lower().startswith("00002902")), None
|
||||
)
|
||||
if cccd is None:
|
||||
return False
|
||||
await cli.bluetooth_gatt_write_descriptor(addr, cccd.handle, b"\x01\x00")
|
||||
return True
|
||||
@@ -0,0 +1,57 @@
|
||||
"""Count rounds, BTU_TASK crashes, reconnects without reboot and MTU 517 in a central capture.
|
||||
|
||||
analyze.py CAPTURE
|
||||
A round counts from its "start" line (a crashing round never logs "fired"); rounds that log "not queued" or
|
||||
"aborted" are taken back out and listed apart. Exits 1 when no round counts, since such a capture tested nothing.
|
||||
"""
|
||||
|
||||
import pathlib
|
||||
import re
|
||||
import sys
|
||||
|
||||
lines = (
|
||||
pathlib.Path(sys.argv[1]).read_text(encoding="utf-8", errors="replace").splitlines()
|
||||
)
|
||||
rounds = crashes = other_panics = boots = connects = mtu517 = mtu_other = 0
|
||||
not_queued = aborted = skipped = 0
|
||||
reconnect_ok = reconnect_reboot = 0
|
||||
pending = False # a round fired and we wait for the next connect
|
||||
for ln in lines:
|
||||
if "Stack canary watchpoint triggered (BTU_TASK)" in ln:
|
||||
crashes += 1
|
||||
elif "Guru Meditation" in ln or "abort() was called" in ln:
|
||||
other_panics += 1
|
||||
if "rst:0x" in ln:
|
||||
boots += 1
|
||||
if pending:
|
||||
reconnect_reboot += 1
|
||||
pending = False
|
||||
if "CLI connected" in ln:
|
||||
connects += 1
|
||||
if pending:
|
||||
reconnect_ok += 1
|
||||
pending = False
|
||||
if re.search(r"ROUND \d+ start", ln):
|
||||
rounds += 1
|
||||
pending = True
|
||||
if re.search(r"ROUND \d+ (not queued|aborted)", ln):
|
||||
rounds -= 1
|
||||
pending = False
|
||||
not_queued += "not queued" in ln
|
||||
aborted += "aborted" in ln
|
||||
skipped += "ROUND skipped" in ln
|
||||
if m := re.search(r"cfg_mtu status 0, mtu (\d+)", ln):
|
||||
if m.group(1) == "517":
|
||||
mtu517 += 1
|
||||
else:
|
||||
mtu_other += 1
|
||||
print(
|
||||
f"rounds={rounds} btu_canary_crashes={crashes} other_panics={other_panics} boots={boots}"
|
||||
)
|
||||
print(
|
||||
f"connects={connects} reconnect_without_reboot={reconnect_ok} reconnect_after_reboot={reconnect_reboot}"
|
||||
)
|
||||
print(f"mtu517={mtu517} mtu_other={mtu_other}")
|
||||
print(f"not_queued={not_queued} aborted={aborted} skipped={skipped}")
|
||||
if rounds <= 0:
|
||||
sys.exit("FAIL: no round reached the BTU queue")
|
||||
@@ -0,0 +1,75 @@
|
||||
# Central for the Bluedroid queued MTU recursion repro (esphome#17954). Every connection: wait 1.5 s, then
|
||||
# suspend BTU_TASK, local disconnect, 4 reads + 1 MTU request (or execute write with exec_write: "true") in one
|
||||
# batch, resume. ble_client reconnects.
|
||||
esp32:
|
||||
board: esp32dev
|
||||
framework:
|
||||
type: esp-idf
|
||||
sdkconfig_options:
|
||||
CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK: y
|
||||
|
||||
logger:
|
||||
level: DEBUG
|
||||
|
||||
esp32_ble_tracker:
|
||||
scan_parameters:
|
||||
active: false
|
||||
|
||||
globals:
|
||||
- {id: rounds, type: int, initial_value: "0"}
|
||||
- {id: chr_handle, type: uint16_t, initial_value: "0"}
|
||||
|
||||
ble_client:
|
||||
- mac_address: ${peer_mac}
|
||||
id: srv
|
||||
on_connect:
|
||||
- logger.log: {format: "CLI connected", level: INFO}
|
||||
# Runs inside SEARCH_CMPL, before ble_client releases the GATT cache (it has no other nodes)
|
||||
- lambda: |-
|
||||
esp_bt_uuid_t uuid = esp32_ble_tracker::ESPBTUUID::from_raw("5ec10001-0000-1000-8000-00805f9b34fb").get_uuid();
|
||||
esp_gattc_char_elem_t elem;
|
||||
uint16_t count = 1;
|
||||
id(chr_handle) = 0;
|
||||
if (esp_ble_gattc_get_char_by_uuid(id(srv)->get_gattc_if(), id(srv)->get_conn_id(), 1, 0xFFFF, uuid, &elem,
|
||||
&count) == ESP_GATT_OK && count > 0)
|
||||
id(chr_handle) = elem.char_handle;
|
||||
- delay: 1500ms
|
||||
- lambda: |-
|
||||
if (!id(srv)->connected()) return;
|
||||
esp_gatt_if_t gattc_if = id(srv)->get_gattc_if();
|
||||
uint16_t conn_id = id(srv)->get_conn_id();
|
||||
uint16_t handle = id(chr_handle);
|
||||
if (handle == 0) {
|
||||
ESP_LOGW("btu", "ROUND skipped, no characteristic");
|
||||
return;
|
||||
}
|
||||
int n = ++id(rounds);
|
||||
ESP_LOGI("btu", "ROUND %d start conn_id=%u handle=0x%04x", n, conn_id, handle);
|
||||
TaskHandle_t btu = xTaskGetHandle("BTU_TASK");
|
||||
if (btu == nullptr) {
|
||||
// vTaskSuspend(nullptr) would suspend this task forever
|
||||
ESP_LOGE("btu", "ROUND %d aborted, no BTU_TASK", n);
|
||||
return;
|
||||
}
|
||||
vTaskSuspend(btu);
|
||||
// a rejected disconnect leaves the link up, so the queued calls never take the failing send path
|
||||
esp_err_t err = esp_ble_gap_disconnect(id(srv)->get_remote_bda());
|
||||
for (int i = 0; i < 4; i++) {
|
||||
esp_err_t e = esp_ble_gattc_read_char(gattc_if, conn_id, handle, ESP_GATT_AUTH_REQ_NONE);
|
||||
if (e != ESP_OK)
|
||||
err = e;
|
||||
}
|
||||
esp_err_t e = ${exec_write} ? esp_ble_gattc_execute_write(gattc_if, conn_id, true)
|
||||
: esp_ble_gattc_send_mtu_req(gattc_if, conn_id);
|
||||
if (e != ESP_OK)
|
||||
err = e;
|
||||
delay(30);
|
||||
vTaskResume(btu);
|
||||
// a round whose calls were rejected never reached the BTU queue, so it tests nothing
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGW("btu", "ROUND %d not queued: %s", n, esp_err_to_name(err));
|
||||
} else {
|
||||
ESP_LOGI("btu", "ROUND %d fired", n);
|
||||
}
|
||||
on_disconnect:
|
||||
- logger.log: {format: "CLI disconnected", level: INFO}
|
||||
@@ -0,0 +1,9 @@
|
||||
esphome:
|
||||
name: btuclibase # one name per build (btuclibase, btuclipr)
|
||||
|
||||
substitutions:
|
||||
peer_mac: "AA:BB:CC:DD:EE:FF" # the peer S3 Bluetooth MAC (Wi-Fi MAC + 2)
|
||||
exec_write: "false"
|
||||
|
||||
packages:
|
||||
common: !include btu-common.yaml
|
||||
@@ -0,0 +1,31 @@
|
||||
# Peer for the Bluedroid queued MTU recursion repro: a GATT server with one readable and writable characteristic
|
||||
esphome:
|
||||
name: btusrv
|
||||
|
||||
esp32:
|
||||
variant: esp32s3
|
||||
board: esp32-s3-devkitc-1
|
||||
framework:
|
||||
type: esp-idf
|
||||
|
||||
logger:
|
||||
level: DEBUG
|
||||
hardware_uart: USB_SERIAL_JTAG
|
||||
|
||||
esp32_ble:
|
||||
name: btusrv
|
||||
|
||||
esp32_ble_server:
|
||||
on_connect:
|
||||
- logger.log: {format: "SRV connected", level: INFO}
|
||||
on_disconnect:
|
||||
- logger.log: {format: "SRV disconnected", level: INFO}
|
||||
services:
|
||||
- uuid: 5ec10000-0000-1000-8000-00805f9b34fb
|
||||
advertise: true
|
||||
characteristics:
|
||||
- id: numc
|
||||
uuid: 5ec10001-0000-1000-8000-00805f9b34fb
|
||||
read: true
|
||||
write: true
|
||||
value: [42]
|
||||
@@ -0,0 +1,15 @@
|
||||
esphome:
|
||||
name: btuxwbase # one name per build (btuxwbase, btuxwpr)
|
||||
|
||||
substitutions:
|
||||
peer_mac: "AA:BB:CC:DD:EE:FF" # the peer S3 Bluetooth MAC (Wi-Fi MAC + 2)
|
||||
exec_write: "true"
|
||||
|
||||
esp32:
|
||||
framework:
|
||||
sdkconfig_options:
|
||||
# GATT API trace prints one "GATTC_ExecuteWrite conn_id=" line per execute send
|
||||
CONFIG_BT_LOG_GATT_TRACE_LEVEL_API: y
|
||||
|
||||
packages:
|
||||
common: !include btu-common.yaml
|
||||
@@ -0,0 +1,102 @@
|
||||
"""quiet_then_subscribe.py HOST PORT OUT QUIET_BOOTS: on the first boot drain any crash record (the first log
|
||||
subscribe replays and clears it), then stay connected without a log subscription for QUIET_BOOTS reboots, then
|
||||
subscribe on the next boot and record the log (including a crash record replayed on subscribe) until a line with
|
||||
REBOOT. The drain connection is dropped and replaced by one without a subscription before boot 1 reboots, so a crash
|
||||
that needs a log subscriber is not recorded as a quiet one; a reboot during the drain, or a reconnect slow enough to
|
||||
hide one, fails the run instead of shifting the boot count. Exits 1 when that line never comes or a quiet boot does
|
||||
not reboot within QUIET_REBOOT_WAIT seconds (default 900). Every lost connection counts as a reboot, so run it on a
|
||||
stable link.
|
||||
env: API_KEY (unset for a plaintext API), QUIET_REBOOT_WAIT."""
|
||||
|
||||
import asyncio
|
||||
import contextlib
|
||||
import os
|
||||
import pathlib
|
||||
import sys
|
||||
import time
|
||||
|
||||
from aioesphomeapi import LogLevel
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
from apiconn import connect, log_text, stop_event # noqa: E402
|
||||
|
||||
# how long a quiet boot may run before its reboot; QUIET_REBOOT_WAIT in the env overrides it
|
||||
REBOOT_WAIT = float(os.environ.get("QUIET_REBOOT_WAIT", "900"))
|
||||
# a reconnect slower than this may have waited out a reboot (connect() retries once a second)
|
||||
RECONNECT_MAX_S = 5.0
|
||||
|
||||
|
||||
async def main(host: str, port: int, outf: str, quiet: int) -> None:
|
||||
with pathlib.Path(outf).open("a", encoding="utf-8") as f:
|
||||
|
||||
def w(t: str) -> None:
|
||||
f.write(f"{time.strftime('%H:%M:%S')} {t}\n")
|
||||
f.flush()
|
||||
|
||||
boots = 0
|
||||
while True:
|
||||
lost, on_stop = stop_event()
|
||||
cli = await connect(host, tries=300, timeout=5, port=port, on_stop=on_stop)
|
||||
boots += 1
|
||||
info = await cli.device_info()
|
||||
w(
|
||||
f"=== CONNECTED boot {boots} name={info.name} quiet={1 < boots <= quiet + 1}"
|
||||
)
|
||||
if boots > quiet + 1:
|
||||
done = asyncio.Event()
|
||||
|
||||
def on_log(m, done: asyncio.Event = done) -> None:
|
||||
t = log_text(m)
|
||||
w(t)
|
||||
if "REBOOT" in t:
|
||||
done.set()
|
||||
|
||||
cli.subscribe_logs(
|
||||
on_log, log_level=LogLevel.LOG_LEVEL_DEBUG, dump_config=False
|
||||
)
|
||||
try:
|
||||
await asyncio.wait_for(done.wait(), 120)
|
||||
except TimeoutError:
|
||||
w("=== no REBOOT within 120 s")
|
||||
with contextlib.suppress(Exception):
|
||||
await cli.disconnect()
|
||||
if not done.is_set():
|
||||
sys.exit("FAIL: no REBOOT line within 120 s of subscribing")
|
||||
return
|
||||
if boots == 1:
|
||||
# drain any crash record left by the reboot that brought this build up
|
||||
cli.subscribe_logs(
|
||||
lambda m: w("drain " + log_text(m)),
|
||||
log_level=LogLevel.LOG_LEVEL_DEBUG,
|
||||
dump_config=False,
|
||||
)
|
||||
await asyncio.sleep(3)
|
||||
if lost.is_set():
|
||||
w("=== boot 1 rebooted during the drain")
|
||||
sys.exit("FAIL: boot 1 rebooted with the drain subscriber attached")
|
||||
with contextlib.suppress(Exception):
|
||||
await cli.disconnect()
|
||||
lost, on_stop = stop_event()
|
||||
t = time.monotonic()
|
||||
cli = await connect(
|
||||
host, tries=300, timeout=5, port=port, on_stop=on_stop
|
||||
)
|
||||
if (dt := time.monotonic() - t) > RECONNECT_MAX_S:
|
||||
w(f"=== boot 1 reconnect took {dt:.1f} s")
|
||||
sys.exit(
|
||||
f"FAIL: the reconnect after the drain took {dt:.1f} s, boot 1 may have rebooted"
|
||||
)
|
||||
w("=== boot 1 reconnected without a log subscription")
|
||||
# quiet: wait for the device to drop the connection (its reboot)
|
||||
try:
|
||||
await asyncio.wait_for(lost.wait(), REBOOT_WAIT)
|
||||
except TimeoutError:
|
||||
w(f"=== boot {boots}: no reboot within {REBOOT_WAIT:.0f} s")
|
||||
sys.exit(
|
||||
f"FAIL: boot {boots} did not reboot within {REBOOT_WAIT:.0f} s"
|
||||
)
|
||||
w("=== connection lost")
|
||||
await asyncio.sleep(2)
|
||||
|
||||
|
||||
asyncio.run(main(sys.argv[1], int(sys.argv[2]), sys.argv[3], int(sys.argv[4])))
|
||||
@@ -0,0 +1,62 @@
|
||||
"""cmp.py REF.json OTHER.json : list each UUID (service / characteristic / descriptor, in order) where OTHER differs
|
||||
from REF, whether reads match (static characteristics), whether every notifying characteristic notified and
|
||||
whether OTHER lost its link before the final disconnect. Exits 1 on any difference."""
|
||||
|
||||
import json
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
|
||||
def flat(p):
|
||||
d = json.loads(pathlib.Path(p).read_text(encoding="utf-8"))
|
||||
rows = []
|
||||
for s in d["services"]:
|
||||
rows.append(("svc", s["uuid"].lower()))
|
||||
for c in s["characteristics"]:
|
||||
rows.append(("chr", c["uuid"].lower()))
|
||||
rows += [("dsc", x.lower()) for x in c["descriptors"]]
|
||||
return d, rows
|
||||
|
||||
|
||||
rd, ref = flat(sys.argv[1])
|
||||
od, oth = flat(sys.argv[2])
|
||||
diff = [(a, b) for a, b in zip(ref, oth, strict=False) if a != b]
|
||||
print(
|
||||
f"entries ref={len(ref)} other={len(oth)} differing={len(diff) + abs(len(ref) - len(oth))}"
|
||||
)
|
||||
for a, b in diff:
|
||||
print(f" {a[0]} ref {a[1]} other {b[1]}")
|
||||
|
||||
|
||||
def chars(d: dict) -> list[dict]:
|
||||
return [c for s in d["services"] for c in s["characteristics"]]
|
||||
|
||||
|
||||
# compare by position: a UUID form bug renames the keys, so values and notify counts are matched by table order
|
||||
problems = []
|
||||
rc, oc = chars(rd), chars(od)
|
||||
for i, (a, b) in enumerate(zip(rc, oc, strict=False)):
|
||||
if a["props"] != b["props"]:
|
||||
problems.append(
|
||||
f"props {i} {b['uuid']} 0x{b['props']:02X} != ref 0x{a['props']:02X}"
|
||||
)
|
||||
rv, ov = rd["reads"].get(a["uuid"]), od["reads"].get(b["uuid"])
|
||||
if str(ov).startswith("FAILED"):
|
||||
problems.append(f"read {i} {b['uuid']} {ov}")
|
||||
elif not a["props"] & 0x10 and rv is not None and ov != rv:
|
||||
problems.append(f"read {i} {b['uuid']} {ov!r} != ref {rv!r}")
|
||||
if a["props"] & 0x10:
|
||||
n = od["notify"].get(b["uuid"])
|
||||
if not isinstance(n, int) or n <= 0:
|
||||
problems.append(f"notify {i} {b['uuid']} {n}")
|
||||
# a link that dropped after the first notification still has counts, so the drop itself fails the run
|
||||
if od.get("lost"):
|
||||
problems.append(f"link lost before the disconnect: {od['lost']}")
|
||||
print(f"notify {od['notify']}")
|
||||
for x in problems:
|
||||
print(" ", x)
|
||||
if diff or len(ref) != len(oth) or problems:
|
||||
sys.exit(
|
||||
f"FAIL: {len(diff)} differing entries, {len(problems)} read or notify problems"
|
||||
)
|
||||
print("PASS")
|
||||
@@ -0,0 +1,100 @@
|
||||
"""List every service, characteristic and descriptor UUID a bluetooth_proxy reports for a peer, read each readable
|
||||
characteristic, enable notify (CCCD write) on each notifying one and count 10 s of notifications, then disconnect.
|
||||
A link lost before that disconnect is recorded as "lost" in the JSON, which cmp.py fails on.
|
||||
usage: gattlist.py PROXY PEER_MAC OUT_JSON env: API_KEY (unset for a plaintext API). Retries 0x3E connect failures."""
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
from apiconn import ble_connect, connect, enable_notify # noqa: E402
|
||||
|
||||
|
||||
async def once(host: str, addr: int) -> dict | None:
|
||||
cli = await connect(host)
|
||||
lost: list[int] = []
|
||||
closing = False
|
||||
|
||||
def on_lost(e: int) -> None:
|
||||
if not closing:
|
||||
lost.append(e)
|
||||
print(f"LINK LOST err={e}", flush=True)
|
||||
|
||||
c, _mtu, err, cancel = await ble_connect(cli, addr, on_lost)
|
||||
if not c:
|
||||
print(f"connect err={err}", flush=True)
|
||||
cancel()
|
||||
await cli.disconnect()
|
||||
return None
|
||||
svcs = await cli.bluetooth_gatt_get_services(addr)
|
||||
out = {"services": [], "reads": {}, "notify": {}}
|
||||
notif: dict[str, int] = {}
|
||||
for s in svcs.services:
|
||||
so = {"uuid": s.uuid, "characteristics": []}
|
||||
for ch in s.characteristics:
|
||||
so["characteristics"].append(
|
||||
{
|
||||
"uuid": ch.uuid,
|
||||
"props": ch.properties,
|
||||
"descriptors": [d.uuid for d in ch.descriptors],
|
||||
}
|
||||
)
|
||||
if ch.properties & 0x02:
|
||||
try:
|
||||
out["reads"][ch.uuid] = bytes(
|
||||
await cli.bluetooth_gatt_read(addr, ch.handle)
|
||||
).hex()
|
||||
except Exception as e: # noqa: BLE001
|
||||
out["reads"][ch.uuid] = f"FAILED {type(e).__name__}"
|
||||
if ch.properties & 0x10:
|
||||
notif[ch.uuid] = 0
|
||||
try:
|
||||
if not await enable_notify(
|
||||
cli,
|
||||
addr,
|
||||
ch,
|
||||
lambda h, d, u=ch.uuid: (
|
||||
notif.__setitem__(u, notif[u] + 1)
|
||||
if isinstance(notif[u], int)
|
||||
else None
|
||||
),
|
||||
):
|
||||
notif[ch.uuid] = "FAILED no CCCD"
|
||||
except Exception as e: # noqa: BLE001
|
||||
notif[ch.uuid] = f"FAILED {type(e).__name__}"
|
||||
out["services"].append(so)
|
||||
await asyncio.sleep(10)
|
||||
out["notify"] = notif
|
||||
out["lost"] = lost
|
||||
closing = True
|
||||
await cli.bluetooth_device_disconnect(addr)
|
||||
await asyncio.sleep(2)
|
||||
cancel()
|
||||
await cli.disconnect()
|
||||
return out
|
||||
|
||||
|
||||
async def main(host: str, peer: str, path: str) -> None:
|
||||
addr = int(peer.replace(":", ""), 16)
|
||||
for _attempt in range(6):
|
||||
res = await once(host, addr)
|
||||
if res:
|
||||
break
|
||||
await asyncio.sleep(10)
|
||||
else:
|
||||
sys.exit("FAIL: no connection")
|
||||
pathlib.Path(path).write_text(json.dumps(res, indent=1), encoding="utf-8")
|
||||
for s in res["services"]:
|
||||
print(f"SVC {s['uuid']}")
|
||||
for c in s["characteristics"]:
|
||||
print(
|
||||
f" CHR {c['uuid']} props=0x{c['props']:02X} read={res['reads'].get(c['uuid'], '-')}"
|
||||
f" notify={res['notify'].get(c['uuid'], '-')}"
|
||||
)
|
||||
for d in c["descriptors"]:
|
||||
print(f" DSC {d}")
|
||||
|
||||
|
||||
asyncio.run(main(sys.argv[1], sys.argv[2], sys.argv[3]))
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
#!/bin/zsh
|
||||
# run.sh NAME: build ../rp2_web_ble/picow.yaml as NAME, USB flash the Pico W proxy, list the GATT UUID server
|
||||
# (server.yaml here) through it and compare with the ESP32 reference. Exit 0 only when the lists match.
|
||||
# env: TREE, PY, PICO_SN, PEER_MAC (the server); esp32ref.json (gattlist.py through an ESP32 proxy) and apikey.txt here
|
||||
D=${0:A:h}; N=$1; S=$D/..; T=${TREE:?set TREE}; PY=${PY:-$T/venv/bin/python}; C=$S/rp2_web_ble/picow.yaml
|
||||
$S/pio_build.sh compile $N $C || exit 1
|
||||
PORT=$($PY $S/ports.py --wait 2e8a --serial ${PICO_SN:?set PICO_SN} --timeout 30) || { echo "no pico"; exit 1; }
|
||||
$S/pio_build.sh upload $N $C $PORT || exit 1
|
||||
H=$($S/resolve.sh $N) || exit 1; sleep 5
|
||||
rm -f $D/$N.json
|
||||
API_KEY=$(cat $D/apikey.txt) timeout 600 $PY -I $D/gattlist.py $H ${PEER_MAC:?set PEER_MAC} $D/$N.json > $D/$N-list.txt
|
||||
RC=$?; grep -v "^ *CHR 00002a\|DSC 00002902\|SVC 000018" $D/$N-list.txt
|
||||
[ $RC = 0 ] && [ -s $D/$N.json ] || { echo "FAIL: gattlist.py exited $RC"; exit 1; }
|
||||
$PY $D/cmp.py $D/esp32ref.json $D/$N.json
|
||||
@@ -0,0 +1,27 @@
|
||||
# GATT server (ESP32-S3) for the UUID form check: the ble_notify server (16 bit and 32-bit base UUIDs, notify) plus a
|
||||
# 128 bit service whose characteristics and descriptors use 128 bit, 32-bit base (zero and nonzero low half) and
|
||||
# 16 bit UUIDs, with a 2901 user description. Set the name with -s name.
|
||||
packages:
|
||||
notify: !include ../ble_notify/server.yaml
|
||||
esp32_ble_server:
|
||||
services:
|
||||
- uuid: 0f1e2d3c-4b5a-6978-8796-a5b4c3d2e1f0
|
||||
characteristics:
|
||||
- uuid: 0f1e2d3c-4b5a-6978-8796-a5b4c3d2e1f1
|
||||
read: true
|
||||
value: "c128"
|
||||
description: "text value"
|
||||
descriptors:
|
||||
- uuid: 5ec1ab01-0000-1000-8000-00805f9b34fb
|
||||
value: "d32"
|
||||
- uuid: 7d3e0a51-9c1b-4f2e-8a6d-1c2b3a4d5e6f
|
||||
value: "d128"
|
||||
- uuid: 5ec20000-0000-1000-8000-00805f9b34fb
|
||||
read: true
|
||||
value: "c32zero"
|
||||
- uuid: 5ec2abcd-0000-1000-8000-00805f9b34fb
|
||||
read: true
|
||||
value: "c32"
|
||||
- uuid: 2a19
|
||||
read: true
|
||||
value: [77]
|
||||
@@ -0,0 +1,50 @@
|
||||
"""ardcmp.py BASE_SER PR_SER [--reads-by-data]: per case rc and wire hash must match; alloc summary, rc counts and
|
||||
wire shapes. --reads-by-data compares read cases by the returned data instead (BK72xx has no sniffer, so its wire
|
||||
hash is that of an empty stream)."""
|
||||
|
||||
import argparse
|
||||
from collections import Counter
|
||||
import pathlib
|
||||
import re
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
|
||||
from snlog import first_alloc, is_read, load # noqa: E402
|
||||
|
||||
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||
ap.add_argument("base")
|
||||
ap.add_argument("pr")
|
||||
ap.add_argument("--reads-by-data", action="store_true")
|
||||
args = ap.parse_args()
|
||||
b, p = load(args.base, "SW"), load(args.pr, "SW")
|
||||
print("cases", len(b), len(p))
|
||||
|
||||
|
||||
def key(label: str, case: dict) -> tuple:
|
||||
if args.reads_by_data and is_read(label):
|
||||
return case["rc"], case["rd"]
|
||||
return case["rc"], case["fnv"]
|
||||
|
||||
|
||||
diff = [k for k in b if k not in p or key(k, b[k]) != key(k, p[k])]
|
||||
print("rc/wire (or read data) differences:", len(diff))
|
||||
for k in diff[:20]:
|
||||
print(" ", k, "\n base", b[k], "\n pr ", p.get(k))
|
||||
for name, d in (("base", b), ("pr", p)):
|
||||
wr = [k for k in d if k.startswith("wreg")]
|
||||
allocs = {k: v["alloc"] for k, v in d.items()}
|
||||
first = {s: first_alloc(allocs, s) for s in ("wreg8", "wreg16")}
|
||||
print(
|
||||
f"{name}: write_register calls that allocated {sum(allocs[k] > 0 for k in wr)} of {len(wr)}; first "
|
||||
f"allocating len {first}; other allocs {[k for k in d if not k.startswith('wreg') and allocs[k]]}"
|
||||
)
|
||||
print(
|
||||
" rc counts:",
|
||||
dict(Counter(v["rc"] for v in d.values())),
|
||||
"| wire shapes:",
|
||||
dict(
|
||||
Counter(
|
||||
re.sub(r"[0-9A-F]{2}", "xx", v["wire"]) for v in d.values()
|
||||
).most_common(6)
|
||||
),
|
||||
)
|
||||
@@ -0,0 +1,6 @@
|
||||
bk72xx:
|
||||
board: xh-wb3s # set your board
|
||||
ads1115:
|
||||
- address: 0x48
|
||||
id: dev
|
||||
i2c_id: bus_hw
|
||||
@@ -0,0 +1,15 @@
|
||||
#!/bin/bash
|
||||
# bkrun.sh NAME PORT: flash NAME's UF2 to a BK72xx board (up to 3 tries), then capture 60 s from a reset (log on
|
||||
# UART1) and print the sweep line count, the ALLOC_PROBE line and the SWDONE line. env: PY, LTPY (LibreTiny python)
|
||||
D=$(cd "$(dirname "$0")" && pwd); S=$(dirname "$(dirname "$D")"); cd "$D" || exit 1
|
||||
N=${1:?name}; P=${2:?port}; PY=${PY:-python3}
|
||||
LTPY=${LTPY:-$D/../pio/penv/.libretiny/bin/python}
|
||||
[ -x "$LTPY" ] || LTPY=~/.platformio/penv/.libretiny/bin/python
|
||||
for i in 1 2 3; do
|
||||
timeout 200 "$LTPY" "$S/flash_bk72xx.py" flash write -d "$P" ".esphome/build/$N/.pioenvs/$N/firmware.uf2" > "$N-flash.log" 2>&1 &&
|
||||
break
|
||||
echo "flash try $i failed: $(tail -1 "$N-flash.log")"
|
||||
[ "$i" = 3 ] && exit 1
|
||||
done
|
||||
$PY "$S/serial_capture.py" "$P" 60 "$N-ser.txt" --reset > /dev/null 2>&1
|
||||
echo "$N $(grep -a -c 'SW ' "$N-ser.txt") $(grep -a -o 'ALLOC_PROBE.*' "$N-ser.txt") $(grep -a -o 'SWDONE.*' "$N-ser.txt")"
|
||||
@@ -0,0 +1,47 @@
|
||||
esphome:
|
||||
name: ${name}
|
||||
includes:
|
||||
- ../../../templates/i2c_fake/alloc_count.hpp
|
||||
- ../wiredecode.hpp
|
||||
- swp.hpp
|
||||
platformio_options:
|
||||
build_flags:
|
||||
- ${wrapflag}
|
||||
- ${defs}
|
||||
on_boot:
|
||||
- priority: -100
|
||||
then:
|
||||
- delay: ${start_delay}
|
||||
- lambda: |-
|
||||
swp::bus = id(bus_hw);
|
||||
swp::install();
|
||||
id(started) = true;
|
||||
|
||||
logger:
|
||||
level: DEBUG
|
||||
hardware_uart: ${loguart}
|
||||
|
||||
globals:
|
||||
- id: started
|
||||
type: bool
|
||||
initial_value: "false"
|
||||
- id: wedged
|
||||
type: bool
|
||||
initial_value: "false"
|
||||
|
||||
i2c:
|
||||
id: bus_hw
|
||||
sda: ${sda}
|
||||
scl: ${scl}
|
||||
frequency: ${freq}
|
||||
scan: true
|
||||
|
||||
interval:
|
||||
- interval: 20ms
|
||||
then:
|
||||
- lambda: |-
|
||||
if (!id(started)) return;
|
||||
if (!swp::step(id(dev)) && !id(wedged) && ${do_wedge}) {
|
||||
id(wedged) = true;
|
||||
swp::wedge(id(dev));
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
esp8266:
|
||||
board: d1_mini
|
||||
ads1115:
|
||||
- address: 0x48
|
||||
id: dev
|
||||
i2c_id: bus_hw
|
||||
@@ -0,0 +1,17 @@
|
||||
rp2040:
|
||||
board: rpipico2w
|
||||
sensor:
|
||||
- platform: ina226
|
||||
id: dev
|
||||
i2c_id: bus_hw
|
||||
address: 0x40
|
||||
shunt_resistance: 0.1 ohm
|
||||
update_interval: 2s
|
||||
bus_voltage:
|
||||
name: vbus
|
||||
on_value:
|
||||
- lambda: ESP_LOGI("rd", "READ vbus %.4f", x);
|
||||
shunt_voltage:
|
||||
name: vshunt
|
||||
on_value:
|
||||
- lambda: ESP_LOGI("rd", "READ vshunt %.6f", x);
|
||||
@@ -0,0 +1,10 @@
|
||||
#!/bin/bash
|
||||
# picorun.sh NAME YAML PORT [OUTSUFFIX]: upload from TREE (reboots the Pico), wait for the port, capture 60 s and print
|
||||
# the sweep line count, the SWDONE line and the count of wedge cases. env: TREE, PY
|
||||
D=$(cd "$(dirname "$0")" && pwd); S=$(dirname "$(dirname "$D")"); cd "$D" || exit 1
|
||||
N=${1:?name}; Y=${2:?yaml}; P=${3:?port}; X=${4:-}; PY=${PY:-${TREE:?set TREE}/venv/bin/python}
|
||||
PIO_CORE=${PIO_CORE:-$D/../pio} bash "$S/pio_build.sh" upload "$N" "$Y" "$P" > /dev/null || exit 1
|
||||
$PY "$S/ports.py" --wait 2e8a > /dev/null 2>&1
|
||||
$PY "$S/serial_capture.py" "$P" 60 "$N-ser$X.txt" > /dev/null 2>&1
|
||||
echo "$N$X $(grep -a -c 'SW ' "$N-ser$X.txt") $(grep -a -o 'SWDONE.*' "$N-ser$X.txt")" \
|
||||
"$(grep -a -c 'WEDGE.*rc=6 then read rc=6' "$N-ser$X.txt")"
|
||||
@@ -0,0 +1,235 @@
|
||||
#pragma once
|
||||
// esphome#22780 sweep for the Arduino (ESP8266, RP2040) and software (BK72xx) buses: one "SW" line per I2CDevice call
|
||||
// with rc, mallocs during the call (alloc_count.hpp) and, where a sniffer exists (ESP8266, RP2), the decoded wire
|
||||
// stream and its hash.
|
||||
#include <cstring>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include "esphome/core/application.h"
|
||||
#include "esphome/core/hal.h"
|
||||
#include "esphome/core/helpers.h"
|
||||
#include "esphome/core/log.h"
|
||||
#include "esphome/components/i2c/i2c.h"
|
||||
#include "alloc_count.hpp"
|
||||
#include "wiredecode.hpp"
|
||||
#ifdef USE_RP2
|
||||
#include <hardware/gpio.h>
|
||||
#include <hardware/irq.h>
|
||||
#include <hardware/structs/sio.h>
|
||||
#endif
|
||||
|
||||
#ifndef SWP_ADDR
|
||||
#define SWP_ADDR 0x48
|
||||
#endif
|
||||
#ifndef SWP_WREG
|
||||
#define SWP_WREG 0x02
|
||||
#endif
|
||||
#ifndef SWP_RREG
|
||||
#define SWP_RREG 0x01
|
||||
#endif
|
||||
#ifndef SWP_MAXLEN8
|
||||
#define SWP_MAXLEN8 300
|
||||
#endif
|
||||
#ifndef SWP_MAXLEN16
|
||||
#define SWP_MAXLEN16 300
|
||||
#endif
|
||||
#ifndef SWP_SDA
|
||||
#define SWP_SDA 4
|
||||
#endif
|
||||
#ifndef SWP_SCL
|
||||
#define SWP_SCL 5
|
||||
#endif
|
||||
|
||||
namespace swp {
|
||||
static const char *const TAG = "swp";
|
||||
|
||||
#if defined(USE_ESP8266) || defined(USE_RP2)
|
||||
#define SWP_SNIFF 1
|
||||
static constexpr uint32_t N = 12000;
|
||||
static uint8_t buf[N];
|
||||
static volatile uint32_t n = 0, ovf = 0;
|
||||
static volatile uint8_t last = 3;
|
||||
static volatile bool armed = false;
|
||||
static inline __attribute__((always_inline)) uint8_t levels() {
|
||||
#ifdef USE_ESP8266
|
||||
uint32_t v = GPI;
|
||||
#else
|
||||
uint32_t v = sio_hw->gpio_in;
|
||||
#endif
|
||||
return ((v >> SWP_SDA) & 1) | (((v >> SWP_SCL) & 1) << 1);
|
||||
}
|
||||
#ifdef USE_ESP8266
|
||||
static void IRAM_ATTR isr() {
|
||||
#else
|
||||
static void isr() {
|
||||
for (int p : {SWP_SDA, SWP_SCL}) {
|
||||
uint32_t ev = gpio_get_irq_event_mask(p);
|
||||
if (ev)
|
||||
gpio_acknowledge_irq(p, ev);
|
||||
}
|
||||
#endif
|
||||
uint8_t s = levels();
|
||||
if (!armed || s == last)
|
||||
return;
|
||||
last = s;
|
||||
if (n < N)
|
||||
buf[n++] = s;
|
||||
else
|
||||
ovf = ovf + 1;
|
||||
}
|
||||
static void install() {
|
||||
#ifdef USE_ESP8266
|
||||
attachInterrupt(SWP_SDA, isr, CHANGE);
|
||||
attachInterrupt(SWP_SCL, isr, CHANGE);
|
||||
#else
|
||||
gpio_add_raw_irq_handler_masked((1u << SWP_SDA) | (1u << SWP_SCL), isr);
|
||||
gpio_set_irq_enabled(SWP_SDA, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL, true);
|
||||
gpio_set_irq_enabled(SWP_SCL, GPIO_IRQ_EDGE_RISE | GPIO_IRQ_EDGE_FALL, true);
|
||||
irq_set_enabled(IO_IRQ_BANK0, true);
|
||||
#endif
|
||||
ESP_LOGI(TAG, "sniffer on SDA %d SCL %d", SWP_SDA, SWP_SCL);
|
||||
}
|
||||
#else
|
||||
#define SWP_SNIFF 0
|
||||
static void install() {}
|
||||
#endif
|
||||
|
||||
static i2c::I2CBus *bus = nullptr;
|
||||
static uint8_t data[320];
|
||||
static uint8_t rdata[40];
|
||||
static uint32_t idx = 0, nalloc = 0;
|
||||
static bool done = false, probed = false;
|
||||
#if SWP_SNIFF
|
||||
static uint8_t start = 3; // levels when the sniffer was armed
|
||||
#endif
|
||||
|
||||
static void arm() {
|
||||
#if SWP_SNIFF
|
||||
n = 0;
|
||||
ovf = 0;
|
||||
start = levels();
|
||||
last = start;
|
||||
armed = true;
|
||||
#endif
|
||||
alloc_count::count = 0;
|
||||
alloc_count::window = true;
|
||||
}
|
||||
static void disarm() {
|
||||
alloc_count::window = false;
|
||||
#if SWP_SNIFF
|
||||
armed = false;
|
||||
#endif
|
||||
}
|
||||
static std::string sniffed(uint32_t &amb) {
|
||||
#if SWP_SNIFF
|
||||
return wiredecode::decode(buf, n, start, amb);
|
||||
#else
|
||||
return {};
|
||||
#endif
|
||||
}
|
||||
|
||||
static bool step(i2c::I2CDevice *dev) {
|
||||
if (done)
|
||||
return false;
|
||||
if (!probed) {
|
||||
// the counter must see a malloc inside the window
|
||||
alloc_count::count = 0;
|
||||
alloc_count::window = true;
|
||||
void *volatile p = malloc(100);
|
||||
alloc_count::window = false;
|
||||
free(p);
|
||||
ESP_LOGI(TAG, "ALLOC_PROBE %u", (unsigned) alloc_count::count);
|
||||
probed = true;
|
||||
}
|
||||
const uint32_t W8 = SWP_MAXLEN8 + 1, W16 = SWP_MAXLEN16 + 1;
|
||||
std::string label;
|
||||
uint32_t i = idx++;
|
||||
for (size_t k = 0; k < sizeof data; k++)
|
||||
data[k] = static_cast<uint8_t>(0x11 + i + k * 7);
|
||||
memset(rdata, 0, sizeof rdata);
|
||||
i2c::ErrorCode rc;
|
||||
if (i < W8) {
|
||||
label = "wreg8 len=" + std::to_string(i);
|
||||
arm();
|
||||
rc = dev->write_register(SWP_WREG, data, i);
|
||||
disarm();
|
||||
} else if (i < W8 + W16) {
|
||||
size_t len = i - W8;
|
||||
label = "wreg16 len=" + std::to_string(len);
|
||||
arm();
|
||||
rc = dev->write_register16((SWP_WREG << 8) | 0x03, data, len);
|
||||
disarm();
|
||||
} else if (i < W8 + W16 + 10) {
|
||||
static const size_t ns[] = {1, 2, 3, 4, 8};
|
||||
uint32_t j = i - W8 - W16;
|
||||
size_t k = ns[j % 5];
|
||||
bool sixteen = j >= 5;
|
||||
label = std::string(sixteen ? "rreg16" : "rreg8") + " n=" + std::to_string(k);
|
||||
arm();
|
||||
rc = sixteen ? dev->read_register16(SWP_RREG << 8, rdata, k) : dev->read_register(SWP_RREG, rdata, k);
|
||||
disarm();
|
||||
} else if (i < W8 + W16 + 13) {
|
||||
size_t k = i - (W8 + W16 + 10) + 1;
|
||||
label = "read n=" + std::to_string(k);
|
||||
arm();
|
||||
rc = dev->read(rdata, k);
|
||||
disarm();
|
||||
} else if (i < W8 + W16 + 16) {
|
||||
static const uint8_t p1[] = {SWP_RREG};
|
||||
size_t k = i - (W8 + W16 + 13) + 1;
|
||||
label = "write1+read n=" + std::to_string(k);
|
||||
arm();
|
||||
rc = dev->write_read(p1, 1, rdata, k);
|
||||
disarm();
|
||||
} else if (i < W8 + W16 + 16 + 112) {
|
||||
uint8_t a = 8 + (i - (W8 + W16 + 16));
|
||||
label = "probe " + std::to_string(a);
|
||||
arm();
|
||||
rc = bus->write_readv(a, nullptr, 0, nullptr, 0);
|
||||
disarm();
|
||||
} else {
|
||||
done = true;
|
||||
ESP_LOGI(TAG, "SWDONE cases=%u alloc_calls=%u", (unsigned) idx - 1, (unsigned) nalloc);
|
||||
return false;
|
||||
}
|
||||
nalloc += alloc_count::count != 0;
|
||||
uint32_t amb = 0, events = 0, overflow = 0;
|
||||
std::string got = sniffed(amb);
|
||||
#if SWP_SNIFF
|
||||
events = n;
|
||||
overflow = ovf;
|
||||
#endif
|
||||
char rd[3 * 8 + 1] = "";
|
||||
for (int k = 0; k < 8 && label.rfind("wreg", 0) != 0 && label.rfind("probe", 0) != 0; k++)
|
||||
snprintf(rd + 3 * k, 4, "%02X ", rdata[k]);
|
||||
ESP_LOGI(TAG, "SW %s|rc=%d|alloc=%u|ev=%u|amb=%u|ovf=%u|fnv=%08X|%s|rd=%s", label.c_str(), (int) rc,
|
||||
(unsigned) alloc_count::count, (unsigned) events, (unsigned) amb, (unsigned) overflow,
|
||||
(unsigned) fnv1a_hash(got), got.substr(0, 90).c_str(), rd);
|
||||
App.feed_wdt();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Over-long register write and what the bus does afterwards (on arduino-pico this leaves Wire stuck, dev too).
|
||||
// Each step is sniffed; the probe step shows whether a stale buffer goes out.
|
||||
static void wedge_step(const char *what, const std::function<i2c::ErrorCode()> &fn) {
|
||||
uint32_t amb = 0;
|
||||
arm();
|
||||
auto rc = fn();
|
||||
disarm();
|
||||
std::string got = sniffed(amb);
|
||||
ESP_LOGI(TAG, "WEDGE %s rc=%d ev=%u wire=%s", what, (int) rc, (unsigned) got.size(), got.substr(0, 120).c_str());
|
||||
App.feed_wdt();
|
||||
}
|
||||
static void wedge(i2c::I2CDevice *dev) {
|
||||
static uint8_t r[2];
|
||||
wedge_step("read_register before", [dev] { return dev->read_register(SWP_RREG, r, 2); });
|
||||
wedge_step("plain read before", [dev] { return dev->read(r, 1); });
|
||||
wedge_step("write_register len=300", [dev] { return dev->write_register(SWP_WREG, data, 300); });
|
||||
wedge_step("read_register after", [dev] { return dev->read_register(SWP_RREG, r, 2); });
|
||||
wedge_step("plain read after", [dev] { return dev->read(r, 1); });
|
||||
wedge_step("write_register len=2 after", [dev] { return dev->write_register(SWP_WREG, data, 2); });
|
||||
wedge_step("probe 0x50 after", [] { return bus->write_readv(0x50, nullptr, 0, nullptr, 0); });
|
||||
wedge_step("plain read after probe", [dev] { return dev->read(r, 1); });
|
||||
wedge_step("write_register len=2 after probe", [dev] { return dev->write_register(SWP_WREG, data, 2); });
|
||||
}
|
||||
} // namespace swp
|
||||
@@ -0,0 +1,14 @@
|
||||
#!/bin/bash
|
||||
# buildall.sh YAML...: compile each config under the `name:` of its substitutions (the file name when it sets none),
|
||||
# from the tree named by its suffix (`x-pr.yaml` builds from PR_TREE, any other from BASE_TREE).
|
||||
# env: PR_TREE, BASE_TREE, PY, BUILD_LOCK (optional), PIO_CORE (default i2c_wire_ab/pio)
|
||||
# Stops at the first failed build and exits with its status.
|
||||
set -o pipefail
|
||||
D=$(cd "$(dirname "$0")" && pwd); S=$(dirname "$D")
|
||||
for y in "$@"; do
|
||||
b=$(basename "$y" .yaml)
|
||||
case ${b##*-} in pr) T=${PR_TREE:?set PR_TREE} ;; *) T=${BASE_TREE:?set BASE_TREE} ;; esac
|
||||
nm=$(awk '/^substitutions:/{s=1; next} /^[^ #]/{s=0} s && /^ name:/{gsub(/["\x27]/, "", $2); print $2; exit}' "$y")
|
||||
nm=${nm:-$b}
|
||||
TREE=$T PIO_CORE=${PIO_CORE:-$D/pio} bash "$S/pio_build.sh" compile "$nm" "$y" | sed "s/^/$nm /" || exit
|
||||
done
|
||||
@@ -0,0 +1,83 @@
|
||||
esphome:
|
||||
name: ${name}
|
||||
includes:
|
||||
- ${swfile}
|
||||
- ../../../templates/i2c_fake/alloc_count.hpp
|
||||
- ../wiredecode.hpp
|
||||
- snf.hpp
|
||||
platformio_options:
|
||||
build_flags:
|
||||
- -Wl,--wrap=malloc
|
||||
- ${flags}
|
||||
on_boot:
|
||||
- priority: 700
|
||||
then:
|
||||
- lambda: |-
|
||||
gpio_reset_pin(GPIO_NUM_6); gpio_set_direction(GPIO_NUM_6, GPIO_MODE_OUTPUT); gpio_set_level(GPIO_NUM_6, 1);
|
||||
gpio_reset_pin(GPIO_NUM_7); gpio_set_direction(GPIO_NUM_7, GPIO_MODE_OUTPUT); gpio_set_level(GPIO_NUM_7, 0);
|
||||
#ifdef SNF_SW
|
||||
snf::bus = snf::make_sw();
|
||||
id(ads)->set_i2c_bus(snf::bus);
|
||||
#else
|
||||
snf::bus = id(bus_hw);
|
||||
#endif
|
||||
- priority: -100
|
||||
then:
|
||||
- delay: 6s
|
||||
- lambda: |-
|
||||
snf::install();
|
||||
id(started) = true;
|
||||
|
||||
esp32:
|
||||
board: esp32-c2-devkitm-1
|
||||
framework:
|
||||
type: esp-idf
|
||||
sdkconfig_options:
|
||||
CONFIG_XTAL_FREQ_26: y
|
||||
|
||||
logger:
|
||||
level: DEBUG
|
||||
baud_rate: 115200
|
||||
|
||||
globals:
|
||||
- id: started
|
||||
type: bool
|
||||
initial_value: "false"
|
||||
|
||||
i2c:
|
||||
id: bus_hw
|
||||
sda: ${hw_sda}
|
||||
scl: ${hw_scl}
|
||||
frequency: ${freq}
|
||||
scan: true
|
||||
|
||||
ads1115:
|
||||
- address: 0x48
|
||||
id: ads
|
||||
i2c_id: bus_hw
|
||||
|
||||
sensor:
|
||||
- platform: ads1115
|
||||
ads1115_id: ads
|
||||
multiplexer: A2_GND
|
||||
gain: 6.144
|
||||
resolution: 12_BITS
|
||||
name: a2
|
||||
update_interval: 2s
|
||||
on_value:
|
||||
- lambda: ESP_LOGI("rd", "READ a2 %.4f", x);
|
||||
- platform: ads1115
|
||||
ads1115_id: ads
|
||||
multiplexer: A3_GND
|
||||
gain: 6.144
|
||||
resolution: 12_BITS
|
||||
name: a3
|
||||
update_interval: 2s
|
||||
on_value:
|
||||
- lambda: ESP_LOGI("rd", "READ a3 %.4f", x);
|
||||
|
||||
interval:
|
||||
- interval: 20ms
|
||||
then:
|
||||
- lambda: |-
|
||||
if (id(started)) snf::step(id(ads));
|
||||
@@ -0,0 +1,69 @@
|
||||
"""clean.py [--nacks] NAME...: per build, cases with at least one capture (NAME-ser.txt, -ser2, -ser3) that is exactly
|
||||
the expected stream or the expected stream cut by the chip's NACK; also every rc seen per case.
|
||||
--nacks: per capture, count the DIFF cases that are a chip NACK and list the others."""
|
||||
|
||||
import argparse
|
||||
from collections import Counter, defaultdict
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
|
||||
from snlog import CAPTURES, load, nack_cut, runs # noqa: E402
|
||||
|
||||
|
||||
def clean(case: dict) -> bool:
|
||||
if case["verdict"] == "OK":
|
||||
return True
|
||||
return nack_cut(case.get("got", []), case.get("exp", [])) is not None
|
||||
|
||||
|
||||
def nacks(name: str) -> None:
|
||||
for s in CAPTURES:
|
||||
path = pathlib.Path(f"{name}-ser{s}.txt")
|
||||
if not path.exists():
|
||||
continue
|
||||
c: Counter[str] = Counter()
|
||||
other = []
|
||||
for label, case in load(path).items():
|
||||
if case["verdict"] == "OK":
|
||||
continue
|
||||
got, exp = case.get("got", []), case.get("exp", [])
|
||||
if (j := nack_cut(got, exp)) is not None:
|
||||
c[f"chip NACK at token {j}"] += 1
|
||||
else:
|
||||
other.append((label, " ".join(got)[:80], " ".join(exp)[:80]))
|
||||
print(path, dict(c), "other:", len(other))
|
||||
for o in other[:10]:
|
||||
print(" ", o)
|
||||
|
||||
|
||||
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||
ap.add_argument(
|
||||
"--nacks", action="store_true", help="classify the DIFF cases of each capture"
|
||||
)
|
||||
ap.add_argument("names", nargs="+")
|
||||
args = ap.parse_args()
|
||||
if args.nacks:
|
||||
for name in args.names:
|
||||
nacks(name)
|
||||
sys.exit()
|
||||
allrc = defaultdict(set)
|
||||
for name in args.names:
|
||||
caps = runs(name)
|
||||
bad = [k for k in caps[0] if not any(k in r and clean(r[k]) for r in caps)]
|
||||
for r in caps:
|
||||
for k, case in r.items():
|
||||
allrc[k].add(case["rc"])
|
||||
print(
|
||||
name,
|
||||
"captures",
|
||||
len(caps),
|
||||
"cases",
|
||||
len(caps[0]),
|
||||
"with no clean capture:",
|
||||
bad,
|
||||
)
|
||||
print(
|
||||
"cases whose rc differs between any captures/builds:",
|
||||
[k for k, s in allrc.items() if len(s) > 1],
|
||||
)
|
||||
@@ -0,0 +1,10 @@
|
||||
#!/bin/bash
|
||||
# flashrun.sh NAME YAML PORT SECONDS [OUTSUFFIX]: upload from TREE, then capture from a reset into NAME-serOUTSUFFIX.txt
|
||||
# and print the sniffed line count and the SNDONE line. clean.py and maj.py read NAME-ser.txt, -ser2 and -ser3.
|
||||
# env: TREE, PY
|
||||
D=$(cd "$(dirname "$0")" && pwd); S=$(dirname "$(dirname "$D")"); cd "$D" || exit 1
|
||||
N=${1:?name}; Y=${2:?yaml}; P=${3:?port}; SEC=${4:?seconds}; X=${5:-}; PY=${PY:-${TREE:?set TREE}/venv/bin/python}
|
||||
pkill -f "[s]erial_capture.py $P "; sleep 1
|
||||
PIO_CORE=${PIO_CORE:-$D/../pio} bash "$S/pio_build.sh" upload "$N" "$Y" "$P" || exit 1
|
||||
$PY "$S/serial_capture.py" "$P" "$SEC" "$N-ser$X.txt" --reset > /dev/null 2>&1
|
||||
grep -a -c "SN " "$N-ser$X.txt"; grep -a "SNDONE" "$N-ser$X.txt"
|
||||
@@ -0,0 +1,57 @@
|
||||
"""maj.py NAME_BASE NAME_PR: per case majority of rc and wire hash (reads: rc and verdict, since the chip's registers
|
||||
change between runs) over NAME-ser.txt, -ser2 and -ser3 (1 to 3 captures), then base vs PR and the alloc summary."""
|
||||
|
||||
import argparse
|
||||
from collections import Counter
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
|
||||
from snlog import first_alloc, is_read, runs # noqa: E402
|
||||
|
||||
|
||||
def majority(name: str) -> tuple[dict, int, int]:
|
||||
"""Case -> (majority key, votes, max alloc); also the count of unstable cases and of captures."""
|
||||
caps = runs(name)
|
||||
out, unstable = {}, 0
|
||||
for k in caps[0]:
|
||||
c = Counter(
|
||||
(r[k]["rc"], r[k]["verdict"] if is_read(k) else r[k]["fnv"])
|
||||
for r in caps
|
||||
if k in r
|
||||
)
|
||||
v, n = c.most_common(1)[0]
|
||||
unstable += len(c) > 1
|
||||
out[k] = (v, n, max(r[k]["alloc"] for r in caps if k in r))
|
||||
return out, unstable, len(caps)
|
||||
|
||||
|
||||
ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||
ap.add_argument("base")
|
||||
ap.add_argument("pr")
|
||||
args = ap.parse_args()
|
||||
b, ub, nb = majority(args.base)
|
||||
p, up, np_ = majority(args.pr)
|
||||
print(
|
||||
f"cases {len(b)} {len(p)}; captures base {nb}, pr {np_}; cases whose captures disagree: base {ub}, pr {up}"
|
||||
)
|
||||
d = [k for k in b if k not in p or b[k][0] != p[k][0]]
|
||||
print("base vs pr majority differences:", len(d))
|
||||
for k in d[:30]:
|
||||
print(" ", k, "base", b[k][0], "pr", p[k][0] if k in p else "missing")
|
||||
weak = [k for k in b if 2 * b[k][1] <= nb or (k in p and 2 * p[k][1] <= np_)]
|
||||
print("cases without a majority:", weak)
|
||||
for name, maj in (("base", b), ("pr", p)):
|
||||
wr = [k for k in maj if k.startswith("wreg")]
|
||||
allocs = {k: v[2] for k, v in maj.items()}
|
||||
print(
|
||||
name,
|
||||
"write_register calls that allocated:",
|
||||
sum(allocs[k] > 0 for k in wr),
|
||||
"of",
|
||||
len(wr),
|
||||
"| first allocating len:",
|
||||
{s: first_alloc(allocs, s) for s in ("wreg8", "wreg16")},
|
||||
"| other allocs:",
|
||||
[k for k in maj if not k.startswith("wreg") and allocs[k]],
|
||||
)
|
||||
@@ -0,0 +1,21 @@
|
||||
"""mksw.py TREE OUT: the tree's software bus (header + source) as one header for an ESP32 build."""
|
||||
|
||||
from pathlib import Path
|
||||
import sys
|
||||
|
||||
t = Path(sys.argv[1]) / "esphome/components/i2c"
|
||||
h = (
|
||||
(t / "i2c_bus_software.h")
|
||||
.read_text()
|
||||
.replace("#pragma once", "")
|
||||
.replace('#include "i2c_bus.h"', '#include "esphome/components/i2c/i2c_bus.h"')
|
||||
)
|
||||
c = (
|
||||
(t / "i2c_bus_software.cpp")
|
||||
.read_text()
|
||||
.replace('#include "i2c_bus_software.h"', "")
|
||||
)
|
||||
Path(sys.argv[2]).write_text(
|
||||
"#pragma once\n#define USE_LIBRETINY\n" + h + "\n" + c + "\n#undef USE_LIBRETINY\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
@@ -0,0 +1,53 @@
|
||||
esphome:
|
||||
name: ${name}
|
||||
includes:
|
||||
- pdslave.hpp
|
||||
- ../../../templates/i2c_fake/alloc_count.hpp
|
||||
- ../wiredecode.hpp
|
||||
- snf.hpp
|
||||
platformio_options:
|
||||
build_flags:
|
||||
- -Wl,--wrap=malloc
|
||||
- -DSNF_PDSLAVE
|
||||
on_boot:
|
||||
- priority: 700
|
||||
then:
|
||||
- lambda: |-
|
||||
pds::install();
|
||||
snf::bus = id(bus_hw);
|
||||
- priority: -100
|
||||
then:
|
||||
- delay: 4s
|
||||
- lambda: id(started) = true;
|
||||
|
||||
esp32:
|
||||
board: pico32
|
||||
framework:
|
||||
type: esp-idf
|
||||
|
||||
logger:
|
||||
level: DEBUG
|
||||
baud_rate: 115200
|
||||
|
||||
globals:
|
||||
- id: started
|
||||
type: bool
|
||||
initial_value: "false"
|
||||
|
||||
i2c:
|
||||
id: bus_hw
|
||||
sda: GPIO32
|
||||
scl: GPIO33
|
||||
frequency: ${freq}
|
||||
scan: false
|
||||
|
||||
ads1115:
|
||||
- address: 0x48
|
||||
id: ads
|
||||
i2c_id: bus_hw
|
||||
|
||||
interval:
|
||||
- interval: 20ms
|
||||
then:
|
||||
- lambda: |-
|
||||
if (id(started)) snf::step(id(ads));
|
||||
@@ -0,0 +1,187 @@
|
||||
#pragma once
|
||||
// Software I2C target at 0x48 on the classic ESP32 master's own pads (GPIO32 SDA, GPIO33 SCL), after the
|
||||
// `i2c_isr_fault/inasim.hpp` pattern: a GPIO ISR on core 0 spins through each transaction and pulls a line low by
|
||||
// switching the pad's output mux to GPIO output 0. ACKs every byte written to 0x48, answers reads with A0, A1, ...;
|
||||
// NACKs other addresses. Every START, byte (with the ACK bit seen on the wire) and STOP goes into a log.
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include "esphome/core/log.h"
|
||||
#include "driver/gpio.h"
|
||||
#include "soc/gpio_reg.h"
|
||||
#include "soc/gpio_sig_map.h"
|
||||
#include "esp_cpu.h"
|
||||
#include "freertos/FreeRTOS.h"
|
||||
#include "freertos/task.h"
|
||||
|
||||
namespace pds {
|
||||
static const char *const TAG = "pds";
|
||||
constexpr int SDA = 32, SCL = 33;
|
||||
constexpr uint32_t SDA_BIT = 1u << (SDA - 32), SCL_BIT = 1u << (SCL - 32);
|
||||
constexpr uint32_t LOW_VAL = SIG_GPIO_OUT_IDX | GPIO_FUNC0_OEN_SEL;
|
||||
constexpr uint32_t CPU_MHZ = 240;
|
||||
inline volatile uint32_t ®(uint32_t a) { return *reinterpret_cast<volatile uint32_t *>(a); }
|
||||
inline uint32_t out_sel_addr(int pin) { return GPIO_FUNC0_OUT_SEL_CFG_REG + 4 * pin; }
|
||||
inline uint32_t in() { return reg(GPIO_IN1_REG); }
|
||||
inline uint32_t rel_sda = 0;
|
||||
|
||||
// log codes: 1 START, 2 RESTART, 3 STOP, 4 written byte / 6 read byte (next: value, ack), 5 idle abort
|
||||
constexpr size_t LOGN = 4096;
|
||||
inline DRAM_ATTR uint8_t lg[LOGN];
|
||||
inline volatile uint32_t ln = 0, lovf = 0;
|
||||
inline void put(uint8_t v) {
|
||||
if (ln < LOGN)
|
||||
lg[ln++] = v;
|
||||
else
|
||||
lovf = lovf + 1;
|
||||
}
|
||||
|
||||
inline void sda_low(bool low) { reg(out_sel_addr(SDA)) = low ? LOW_VAL : rel_sda; }
|
||||
|
||||
inline void run_transaction() {
|
||||
enum { ADDR, WDATA, RDATA, IGNORE } phase = ADDR;
|
||||
uint32_t prev = in(), last = esp_cpu_get_cycle_count();
|
||||
uint8_t byte = 0, cnt = 0, out = 0, rd = 0, pend_kind = 4, pend_val = 0;
|
||||
bool acked = false;
|
||||
put(1);
|
||||
reg(GPIO_OUT1_W1TC_REG) = SDA_BIT;
|
||||
reg(GPIO_ENABLE1_W1TS_REG) = SDA_BIT;
|
||||
for (;;) {
|
||||
uint32_t v = in();
|
||||
uint32_t now = esp_cpu_get_cycle_count();
|
||||
if (v == prev) {
|
||||
if (now - last > 20000u * CPU_MHZ) {
|
||||
put(5);
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
last = now;
|
||||
uint32_t ch = v ^ prev;
|
||||
prev = v;
|
||||
if (ch & SCL_BIT) {
|
||||
if (v & SCL_BIT) {
|
||||
cnt++;
|
||||
if (cnt <= 8 && phase != RDATA)
|
||||
byte = (byte << 1) | ((v & SDA_BIT) ? 1 : 0);
|
||||
else if (cnt == 9) {
|
||||
// the ACK bit as it is on the wire
|
||||
bool ack = !(v & SDA_BIT);
|
||||
put(pend_kind);
|
||||
put(pend_val);
|
||||
put(ack ? 1 : 0);
|
||||
if (phase == RDATA && !ack)
|
||||
phase = IGNORE;
|
||||
}
|
||||
} else {
|
||||
if (cnt == 8) {
|
||||
pend_kind = phase == RDATA ? 6 : 4;
|
||||
pend_val = phase == RDATA ? out : byte;
|
||||
if (phase == ADDR) {
|
||||
if ((byte >> 1) == 0x48) {
|
||||
sda_low(true);
|
||||
acked = true;
|
||||
phase = (byte & 1) ? RDATA : WDATA;
|
||||
rd = 0;
|
||||
} else {
|
||||
phase = IGNORE;
|
||||
}
|
||||
} else if (phase == WDATA) {
|
||||
sda_low(true);
|
||||
acked = true;
|
||||
} else if (phase == RDATA) {
|
||||
sda_low(false); // master's ACK slot
|
||||
}
|
||||
} else if (cnt == 9) {
|
||||
if (acked) {
|
||||
sda_low(false);
|
||||
acked = false;
|
||||
}
|
||||
if (phase == RDATA) {
|
||||
out = 0xA0 + rd++;
|
||||
sda_low(!(out & 0x80));
|
||||
}
|
||||
cnt = 0;
|
||||
byte = 0;
|
||||
} else if (cnt >= 1 && cnt <= 7 && phase == RDATA) {
|
||||
sda_low(!(out & (0x80 >> cnt)));
|
||||
}
|
||||
}
|
||||
} else if ((ch & SDA_BIT) && (v & SCL_BIT)) {
|
||||
if (v & SDA_BIT) {
|
||||
put(3);
|
||||
break;
|
||||
}
|
||||
put(2);
|
||||
sda_low(false);
|
||||
phase = ADDR;
|
||||
cnt = 0;
|
||||
byte = 0;
|
||||
acked = false;
|
||||
}
|
||||
}
|
||||
sda_low(false);
|
||||
}
|
||||
|
||||
inline void slave_isr(void *) {
|
||||
reg(GPIO_STATUS1_W1TC_REG) = SDA_BIT;
|
||||
uint32_t v = in();
|
||||
if (!(v & SCL_BIT) || (v & SDA_BIT))
|
||||
return;
|
||||
run_transaction();
|
||||
reg(GPIO_STATUS1_W1TC_REG) = SDA_BIT;
|
||||
}
|
||||
|
||||
inline volatile bool installed = false;
|
||||
inline void install_task(void *) {
|
||||
rel_sda = reg(out_sel_addr(SDA));
|
||||
gpio_install_isr_service(0);
|
||||
gpio_set_intr_type((gpio_num_t) SDA, GPIO_INTR_NEGEDGE);
|
||||
esp_err_t e = gpio_isr_handler_add((gpio_num_t) SDA, slave_isr, nullptr);
|
||||
gpio_intr_enable((gpio_num_t) SDA);
|
||||
ESP_LOGI(TAG, "slave on core %d handler %d rel_sda 0x%x", xPortGetCoreID(), e, (unsigned) rel_sda);
|
||||
installed = true;
|
||||
vTaskDelete(nullptr);
|
||||
}
|
||||
inline void install() {
|
||||
xTaskCreatePinnedToCore(install_task, "pdsinst", 3072, nullptr, 5, nullptr, 0);
|
||||
while (!installed)
|
||||
vTaskDelay(1);
|
||||
}
|
||||
|
||||
inline std::string tokens() {
|
||||
std::string s;
|
||||
char t[8];
|
||||
for (uint32_t i = 0; i < ln; i++) {
|
||||
switch (lg[i]) {
|
||||
case 1:
|
||||
s += "S ";
|
||||
break;
|
||||
case 2:
|
||||
s += "Sr ";
|
||||
break;
|
||||
case 3:
|
||||
s += "P ";
|
||||
break;
|
||||
case 5:
|
||||
s += "IDLE ";
|
||||
break;
|
||||
case 4:
|
||||
case 6: {
|
||||
if (i + 2 >= ln) { // byte record cut off by a full log
|
||||
s += "? ";
|
||||
i = ln;
|
||||
break;
|
||||
}
|
||||
uint8_t b = lg[i + 1], a = lg[i + 2];
|
||||
snprintf(t, sizeof t, lg[i] == 6 ? "r%02X%c " : "%02X%c ", b, a ? '+' : '-');
|
||||
i += 2;
|
||||
s += t;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
s += "? ";
|
||||
}
|
||||
}
|
||||
return s;
|
||||
}
|
||||
} // namespace pds
|
||||
@@ -0,0 +1,245 @@
|
||||
#pragma once
|
||||
// esphome#22780 device check: GPIO interrupt sniffer on the I2C pads, a sweep of I2CDevice call shapes, and a
|
||||
// malloc counter (alloc_count.hpp, -Wl,--wrap=malloc). One "SN" line per case: rc, mallocs, decoded wire stream
|
||||
// hash, match with the stream the call should produce.
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <driver/gpio.h>
|
||||
#include <soc/gpio_reg.h>
|
||||
#include <esp_attr.h>
|
||||
#include "esphome/core/application.h"
|
||||
#include "esphome/core/helpers.h"
|
||||
#include "esphome/core/log.h"
|
||||
#include "esphome/components/i2c/i2c.h"
|
||||
#include "alloc_count.hpp"
|
||||
#include "wiredecode.hpp"
|
||||
#ifdef SNF_PDSLAVE
|
||||
// the board is its own target (pdslave.hpp); its token stream replaces the pad sniffer's decode
|
||||
#include "pdslave.hpp"
|
||||
#endif
|
||||
|
||||
namespace snf {
|
||||
static const char *const TAG = "snf";
|
||||
#ifndef SNF_SDA
|
||||
#define SNF_SDA 4
|
||||
#endif
|
||||
#ifndef SNF_SCL
|
||||
#define SNF_SCL 5
|
||||
#endif
|
||||
static constexpr size_t N = 24000;
|
||||
static DRAM_ATTR uint8_t buf[N];
|
||||
static volatile DRAM_ATTR uint32_t n = 0;
|
||||
static volatile DRAM_ATTR uint32_t ovf = 0;
|
||||
static volatile DRAM_ATTR uint8_t last = 3;
|
||||
static volatile DRAM_ATTR bool armed = false;
|
||||
static uint8_t start = 3; // levels when the sniffer was armed
|
||||
|
||||
static void IRAM_ATTR isr(void *) {
|
||||
uint32_t v = REG_READ(GPIO_IN_REG);
|
||||
uint8_t s = ((v >> SNF_SDA) & 1) | (((v >> SNF_SCL) & 1) << 1);
|
||||
if (!armed || s == last)
|
||||
return;
|
||||
last = s;
|
||||
if (n < N)
|
||||
buf[n++] = s;
|
||||
else
|
||||
ovf = ovf + 1;
|
||||
}
|
||||
|
||||
static void install() {
|
||||
gpio_install_isr_service(ESP_INTR_FLAG_IRAM);
|
||||
for (int p : {SNF_SDA, SNF_SCL}) {
|
||||
gpio_set_intr_type((gpio_num_t) p, GPIO_INTR_ANYEDGE);
|
||||
gpio_isr_handler_add((gpio_num_t) p, isr, nullptr);
|
||||
gpio_intr_enable((gpio_num_t) p);
|
||||
}
|
||||
ESP_LOGI(TAG, "sniffer on SDA %d SCL %d", SNF_SDA, SNF_SCL);
|
||||
}
|
||||
|
||||
static i2c::I2CBus *bus = nullptr; // the bus the device uses (hardware or the software copy)
|
||||
|
||||
static void wb(std::string &e, uint8_t b) {
|
||||
char t[8];
|
||||
snprintf(t, sizeof t, "%02X+ ", b);
|
||||
e += t;
|
||||
}
|
||||
static void rb(std::string &e, const uint8_t *r, size_t k) {
|
||||
char t[8];
|
||||
for (size_t i = 0; i < k; i++) {
|
||||
snprintf(t, sizeof t, "r%02X%c ", r[i], i + 1 < k ? '+' : '-');
|
||||
e += t;
|
||||
}
|
||||
}
|
||||
|
||||
static uint8_t data[320];
|
||||
static uint8_t rdata[40];
|
||||
static uint32_t idx = 0, nok = 0, ndiff = 0, namb = 0, nalloc = 0;
|
||||
static bool done = false;
|
||||
|
||||
static void arm() {
|
||||
n = 0;
|
||||
ovf = 0;
|
||||
uint32_t v = REG_READ(GPIO_IN_REG);
|
||||
start = ((v >> SNF_SDA) & 1) | (((v >> SNF_SCL) & 1) << 1);
|
||||
last = start;
|
||||
alloc_count::count = 0;
|
||||
alloc_count::window = true;
|
||||
#ifdef SNF_PDSLAVE
|
||||
pds::ln = 0;
|
||||
pds::lovf = 0;
|
||||
#endif
|
||||
armed = true;
|
||||
}
|
||||
static void disarm() {
|
||||
armed = false;
|
||||
alloc_count::window = false;
|
||||
}
|
||||
|
||||
// Runs one case and returns false when the sweep is over
|
||||
static bool step(i2c::I2CDevice *dev) {
|
||||
if (done)
|
||||
return false;
|
||||
const uint8_t A = 0x48;
|
||||
std::string label, exp;
|
||||
#ifdef SNF_PDSLAVE
|
||||
if (idx == 0) {
|
||||
// warm the target ISR (it runs from flash) so the first case is not lost to a cache miss
|
||||
bus->write_readv(0x48, nullptr, 0, nullptr, 0);
|
||||
delay(5);
|
||||
}
|
||||
#endif
|
||||
uint32_t i = idx++;
|
||||
for (size_t k = 0; k < sizeof data; k++)
|
||||
data[k] = static_cast<uint8_t>(0x11 + i + k * 7);
|
||||
i2c::ErrorCode rc;
|
||||
static constexpr uint32_t W8 = 301, W16 = 301; // write_register lengths 0..300
|
||||
if (i < W8) {
|
||||
size_t len = i;
|
||||
label = "wreg8 len=" + std::to_string(len);
|
||||
arm();
|
||||
rc = dev->write_register(0x02, data, len);
|
||||
disarm();
|
||||
exp = "S ";
|
||||
wb(exp, A << 1);
|
||||
wb(exp, 0x02);
|
||||
for (size_t k = 0; k < len; k++)
|
||||
wb(exp, data[k]);
|
||||
exp += "P ";
|
||||
} else if (i < W8 + W16) {
|
||||
size_t len = i - W8;
|
||||
label = "wreg16 len=" + std::to_string(len);
|
||||
arm();
|
||||
rc = dev->write_register16(0x0203, data, len);
|
||||
disarm();
|
||||
exp = "S ";
|
||||
wb(exp, A << 1);
|
||||
wb(exp, 0x02);
|
||||
wb(exp, 0x03);
|
||||
for (size_t k = 0; k < len; k++)
|
||||
wb(exp, data[k]);
|
||||
exp += "P ";
|
||||
} else if (i < W8 + W16 + 10) {
|
||||
static const size_t ns[] = {1, 2, 3, 4, 8};
|
||||
uint32_t j = i - W8 - W16;
|
||||
size_t k = ns[j % 5];
|
||||
bool sixteen = j >= 5;
|
||||
label = std::string(sixteen ? "rreg16" : "rreg8") + " n=" + std::to_string(k);
|
||||
memset(rdata, 0, sizeof rdata);
|
||||
arm();
|
||||
rc = sixteen ? dev->read_register16(0x0100, rdata, k) : dev->read_register(0x01, rdata, k);
|
||||
disarm();
|
||||
exp = "S ";
|
||||
wb(exp, A << 1);
|
||||
wb(exp, 0x01);
|
||||
if (sixteen)
|
||||
wb(exp, 0x00);
|
||||
exp += "Sr ";
|
||||
wb(exp, (A << 1) | 1);
|
||||
rb(exp, rdata, k);
|
||||
exp += "P ";
|
||||
} else if (i < W8 + W16 + 13) {
|
||||
size_t k = i - (W8 + W16 + 10) + 1;
|
||||
label = "read n=" + std::to_string(k);
|
||||
arm();
|
||||
rc = dev->read(rdata, k);
|
||||
disarm();
|
||||
exp = "S ";
|
||||
wb(exp, (A << 1) | 1);
|
||||
rb(exp, rdata, k);
|
||||
exp += "P ";
|
||||
} else if (i < W8 + W16 + 16) {
|
||||
static const uint8_t p1[] = {0x02};
|
||||
size_t k = i - (W8 + W16 + 13) + 1;
|
||||
label = "write1+read n=" + std::to_string(k);
|
||||
arm();
|
||||
rc = dev->write_read(p1, 1, rdata, k);
|
||||
disarm();
|
||||
exp = "S ";
|
||||
wb(exp, A << 1);
|
||||
wb(exp, 0x02);
|
||||
exp += "Sr ";
|
||||
wb(exp, (A << 1) | 1);
|
||||
rb(exp, rdata, k);
|
||||
exp += "P ";
|
||||
} else if (i < W8 + W16 + 16 + 112) {
|
||||
uint8_t a = 8 + (i - (W8 + W16 + 16));
|
||||
label = "probe " + std::to_string(a);
|
||||
arm();
|
||||
rc = bus->write_readv(a, nullptr, 0, nullptr, 0);
|
||||
disarm();
|
||||
exp = "S ";
|
||||
char t[8];
|
||||
snprintf(t, sizeof t, "%02X%c ", a << 1, a == A ? '+' : '-');
|
||||
exp += t;
|
||||
exp += "P ";
|
||||
} else {
|
||||
done = true;
|
||||
ESP_LOGI(TAG, "SNDONE cases=%u ok=%u diff=%u amb=%u alloc_calls=%u", (unsigned) idx - 1, (unsigned) nok,
|
||||
(unsigned) ndiff, (unsigned) namb, (unsigned) nalloc);
|
||||
return false;
|
||||
}
|
||||
uint32_t amb = 0;
|
||||
#ifdef SNF_PDSLAVE
|
||||
delayMicroseconds(500);
|
||||
std::string got = pds::tokens();
|
||||
ovf = pds::lovf;
|
||||
n = pds::ln;
|
||||
#else
|
||||
std::string got = wiredecode::decode(buf, n, start, amb);
|
||||
#endif
|
||||
bool ok = got == exp && ovf == 0;
|
||||
nok += ok;
|
||||
ndiff += !ok;
|
||||
namb += amb;
|
||||
nalloc += alloc_count::count != 0;
|
||||
ESP_LOGI(TAG, "SN %s|rc=%d|alloc=%u|ev=%u|amb=%u|ovf=%u|fnv=%08X|%s", label.c_str(), (int) rc,
|
||||
(unsigned) alloc_count::count, (unsigned) n, (unsigned) amb, (unsigned) ovf, (unsigned) fnv1a_hash(got),
|
||||
ok ? "OK" : "DIFF");
|
||||
if (!ok) {
|
||||
ESP_LOGI(TAG, "SNGOT %s", got.substr(0, 200).c_str());
|
||||
ESP_LOGI(TAG, "SNEXP %s", exp.substr(0, 200).c_str());
|
||||
}
|
||||
App.feed_wdt();
|
||||
return true;
|
||||
}
|
||||
|
||||
#ifdef SNF_SW
|
||||
static i2c::I2CBus *make_sw() {
|
||||
auto *sda = new esp32::ESP32InternalGPIOPin();
|
||||
sda->set_pin((gpio_num_t) SNF_SDA);
|
||||
sda->set_flags(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
|
||||
auto *scl = new esp32::ESP32InternalGPIOPin();
|
||||
scl->set_pin((gpio_num_t) SNF_SCL);
|
||||
scl->set_flags(gpio::FLAG_INPUT | gpio::FLAG_PULLUP);
|
||||
auto *b = new i2c::SoftwareI2CBus();
|
||||
b->set_sda_pin(sda);
|
||||
b->set_scl_pin(scl);
|
||||
b->set_frequency(SNF_SW_FREQ);
|
||||
b->set_scan(true);
|
||||
b->set_timeout(1000);
|
||||
b->setup();
|
||||
b->dump_config();
|
||||
return b;
|
||||
}
|
||||
#endif
|
||||
} // namespace snf
|
||||
@@ -0,0 +1,81 @@
|
||||
"""compare.py BASE PR: wire and return code per bus and case must match; summarize allocations and IDF job lists."""
|
||||
|
||||
from collections import Counter, defaultdict
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
|
||||
from snlog import first_alloc # noqa: E402
|
||||
|
||||
|
||||
def load(p):
|
||||
rec, jobs = {}, {}
|
||||
with pathlib.Path(p).open(encoding="utf-8") as fh:
|
||||
for line in fh:
|
||||
line = line.rstrip("\n")
|
||||
if line.startswith("ALLOC_PROBE"):
|
||||
continue
|
||||
parts = line.split("|")
|
||||
if parts[0] == "J":
|
||||
jobs[(parts[1], parts[2])] = parts[3].strip()
|
||||
continue
|
||||
bus, case, rc, alloc, wire = parts
|
||||
rec[(bus, case)] = (rc, int(alloc.split("=")[1]), wire.strip())
|
||||
return rec, jobs
|
||||
|
||||
|
||||
b, bj = load(sys.argv[1])
|
||||
p, pj = load(sys.argv[2])
|
||||
assert b.keys() == p.keys(), "case lists differ"
|
||||
diff = [k for k in b if b[k][0] != p[k][0] or b[k][2] != p[k][2]]
|
||||
per_bus = Counter(k[0] for k in b)
|
||||
print("cases per bus:", dict(per_bus))
|
||||
print("wire/rc differences:", len(diff))
|
||||
for k in diff[:40]:
|
||||
print(
|
||||
" DIFF",
|
||||
k,
|
||||
"\n base",
|
||||
b[k][0],
|
||||
b[k][2][:160],
|
||||
"\n pr ",
|
||||
p[k][0],
|
||||
p[k][2][:160],
|
||||
)
|
||||
alloc = defaultdict(
|
||||
lambda: [0, 0, 0, 0]
|
||||
) # base cases with alloc, pr cases with alloc, base total, pr total
|
||||
for k in b:
|
||||
if not k[1].startswith(("wreg8", "wreg16")):
|
||||
continue
|
||||
a = alloc[k[0]]
|
||||
a[0] += b[k][1] > 0
|
||||
a[1] += p[k][1] > 0
|
||||
a[2] += b[k][1]
|
||||
a[3] += p[k][1]
|
||||
print("write_register/16 calls that allocated (base, pr):")
|
||||
for bus, a in alloc.items():
|
||||
print(
|
||||
f" {bus:8s} base {a[0]} calls ({a[2]} mallocs) pr {a[1]} calls ({a[3]} mallocs)"
|
||||
)
|
||||
# first length that allocates, per bus and shape
|
||||
for bus in per_bus:
|
||||
ab = {c: r[1] for (x, c), r in b.items() if x == bus}
|
||||
ap = {c: r[1] for (x, c), r in p.items() if x == bus}
|
||||
for shape in ("wreg8", "wreg16"):
|
||||
fb, fp = first_alloc(ab, shape), first_alloc(ap, shape)
|
||||
print(f" first allocating length {bus} {shape}: base {fb} pr {fp}")
|
||||
other = [
|
||||
k
|
||||
for k in b
|
||||
if not k[1].startswith(("wreg8", "wreg16", "wedge wreg", "absent wreg"))
|
||||
and (b[k][1] or p[k][1])
|
||||
]
|
||||
print("other calls with allocations:", other[:10])
|
||||
jd = Counter()
|
||||
for k in bj:
|
||||
if bj[k] != pj.get(k):
|
||||
jd[(bj[k], pj.get(k))] += 1
|
||||
print("IDF job list changes (base -> pr: count):")
|
||||
for (x, y), n in sorted(jd.items(), key=lambda t: -t[1])[:20]:
|
||||
print(f" {x!r} -> {y!r}: {n}")
|
||||
@@ -0,0 +1,33 @@
|
||||
"""extract.py TREE OUTDIR: copy the write_readv/transfer_ definitions of the Arduino and ESP-IDF buses out of TREE."""
|
||||
|
||||
from pathlib import Path
|
||||
import re
|
||||
import shutil
|
||||
import sys
|
||||
|
||||
tree, out = Path(sys.argv[1]), Path(sys.argv[2])
|
||||
for cls, src, dst in (
|
||||
("ArduinoI2CBus", "i2c_bus_arduino.cpp", "wab_gen_arduino.inc"),
|
||||
("IDFI2CBus", "i2c_bus_esp_idf.cpp", "wab_gen_idf.inc"),
|
||||
):
|
||||
lines = (tree / "esphome/components/i2c" / src).read_text().splitlines()
|
||||
pat = re.compile(rf"^ErrorCode {cls}::(write_readv|transfer_)\(")
|
||||
starts = [i for i, line in enumerate(lines) if pat.match(line)]
|
||||
assert len(starts) == 1, (src, starts)
|
||||
s = starts[0]
|
||||
e = next(i for i in range(s, len(lines)) if lines[i] == "}")
|
||||
(out / dst).write_text("\n".join(lines[s : e + 1]) + "\n")
|
||||
print(dst, lines[s].split("(")[0], e - s + 1, "lines")
|
||||
|
||||
shutil.copy(
|
||||
tree / "esphome/components/i2c/i2c_bus_software.cpp", out / "wab_sw_impl.inc"
|
||||
)
|
||||
shutil.copy(
|
||||
tree / "esphome/components/i2c/i2c_bus_software.h", out / "i2c_bus_software.h"
|
||||
)
|
||||
h = out / "i2c_bus_software.h"
|
||||
h.write_text(
|
||||
h.read_text().replace(
|
||||
'#include "i2c_bus.h"', '#include "esphome/components/i2c/i2c_bus.h"'
|
||||
)
|
||||
)
|
||||
@@ -0,0 +1,22 @@
|
||||
#!/bin/bash
|
||||
# run.sh TREE OUTFILE: copy the harness into TREE's tests/components/i2c, generate the extracted bus bodies, run the
|
||||
# unit test and remove the harness again. env: PY (default TREE's venv python)
|
||||
T=$(cd "${1:?tree}" && pwd); O=$(cd "$(dirname "${2:?out}")" && pwd)/$(basename "$2")
|
||||
H=$(cd "$(dirname "$0")" && pwd); PY=${PY:-$T/venv/bin/python}
|
||||
D=$T/tests/components/i2c
|
||||
# The sources are stored as .cpp.example, .h.example and .hpp so the repo's C++ lints skip them; copy them back.
|
||||
FILES=(wab_common.h wab_ard8266.cpp wab_ardpico.cpp wab_idf.cpp wab_sw.cpp test_wab.cpp benchmark.yaml)
|
||||
G=$(mktemp -d)
|
||||
cleanup() { for f in "${FILES[@]}"; do rm -f "$D/$f"; done; rm -rf "$G"; }
|
||||
trap cleanup EXIT
|
||||
trap 'exit 130' INT TERM
|
||||
cp "$H/wab_common.hpp" "$D/wab_common.h"
|
||||
for f in "${FILES[@]:1:5}"; do cp "$H/$f.example" "$D/$f"; done
|
||||
mkdir -p "$G/gen" "$G/stubs/driver"
|
||||
for f in Arduino.h Wire.h driver/i2c_master.h; do cp "$H/stub/$f.example" "$G/stubs/$f"; done
|
||||
$PY "$H/extract.py" "$T" "$G/gen"
|
||||
printf "esphome:\n build_flags:\n - -I%s\n - -I%s\n - -I%s\n" "$D" "$G/stubs" "$G/gen" > "$D/benchmark.yaml"
|
||||
(cd "$T" && WAB_OUT=$O PYTHONPATH=$T $PY script/cpp_unit_test.py i2c) > "${O%.txt}-build.log" 2>&1
|
||||
rc=$?
|
||||
echo "rc=$rc"; tail -5 "${O%.txt}-build.log"
|
||||
exit $rc
|
||||
@@ -0,0 +1,10 @@
|
||||
#pragma once
|
||||
#include <cstdint>
|
||||
#define INPUT 0x01
|
||||
#define OUTPUT 0x03
|
||||
#define INPUT_PULLUP 0x05
|
||||
#define LOW 0
|
||||
#define HIGH 1
|
||||
inline void pinMode(uint8_t, uint8_t) {}
|
||||
inline void digitalWrite(uint8_t, uint8_t) {}
|
||||
inline int digitalRead(uint8_t) { return HIGH; }
|
||||
@@ -0,0 +1,207 @@
|
||||
#pragma once
|
||||
// TwoWire models of the cores ESPHome uses, with the cores' own buffer rules. Select with WAB_WIRE_ESP8266 or
|
||||
// WAB_WIRE_PICO before including. Bytes go on the wire through wab::wire() with ACKs from wab::slave().
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include "wab_common.h"
|
||||
|
||||
#if defined(WAB_WIRE_ESP8266)
|
||||
#define TwoWire TwoWire8266
|
||||
#define Wire Wire8266
|
||||
// esp8266 core 3.1.2-esphome.3 libraries/Wire: I2C_BUFFER_LENGTH 128
|
||||
class TwoWire {
|
||||
public:
|
||||
static constexpr size_t LEN = 128;
|
||||
void begin(int, int) {}
|
||||
void setClock(uint32_t) {}
|
||||
void setClockStretchLimit(uint32_t) {}
|
||||
void beginTransmission(uint8_t address) {
|
||||
transmitting = 1;
|
||||
txAddress = address;
|
||||
txBufferIndex = 0;
|
||||
txBufferLength = 0;
|
||||
}
|
||||
size_t write(uint8_t data) {
|
||||
if (transmitting) {
|
||||
if (txBufferLength >= LEN)
|
||||
return 0; // setWriteError()
|
||||
txBuffer[txBufferIndex] = data;
|
||||
++txBufferIndex;
|
||||
txBufferLength = txBufferIndex;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
size_t write(const uint8_t *data, size_t quantity) {
|
||||
if (transmitting) {
|
||||
for (size_t i = 0; i < quantity; ++i)
|
||||
if (!write(data[i]))
|
||||
return i;
|
||||
}
|
||||
return quantity;
|
||||
}
|
||||
uint8_t endTransmission(uint8_t sendStop) {
|
||||
// twi_writeTo: 0 ok, 2 address NACK, 3 data NACK; STOP when sendStop (also after a NACK)
|
||||
int8_t ret = 0;
|
||||
auto &w = wab::wire();
|
||||
auto &s = wab::slave();
|
||||
w.start();
|
||||
uint8_t ab = txAddress << 1;
|
||||
bool ack = s.address(ab);
|
||||
w.wbyte(ab, ack);
|
||||
if (!ack) {
|
||||
ret = 2;
|
||||
} else {
|
||||
for (size_t i = 0; i < txBufferLength; i++) {
|
||||
bool a = s.data(txBuffer[i]);
|
||||
w.wbyte(txBuffer[i], a);
|
||||
if (!a) {
|
||||
ret = 3;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (sendStop || ret != 0)
|
||||
w.stop();
|
||||
txBufferIndex = 0;
|
||||
txBufferLength = 0;
|
||||
transmitting = 0;
|
||||
return ret;
|
||||
}
|
||||
size_t requestFrom(uint8_t address, size_t size, bool sendStop) {
|
||||
if (size > LEN)
|
||||
size = LEN;
|
||||
auto &w = wab::wire();
|
||||
auto &s = wab::slave();
|
||||
w.start();
|
||||
uint8_t ab = (address << 1) | 1;
|
||||
bool ack = s.address(ab);
|
||||
w.wbyte(ab, ack);
|
||||
size_t read = 0;
|
||||
if (ack) {
|
||||
for (size_t i = 0; i < size; i++) {
|
||||
rxBuffer[i] = s.next_read();
|
||||
w.rbyte(rxBuffer[i], i + 1 < size);
|
||||
}
|
||||
read = size;
|
||||
}
|
||||
if (sendStop || !ack)
|
||||
w.stop();
|
||||
rxBufferIndex = 0;
|
||||
rxBufferLength = read;
|
||||
return read;
|
||||
}
|
||||
int read() { return rxBufferIndex < rxBufferLength ? rxBuffer[rxBufferIndex++] : -1; }
|
||||
void wab_reset() { transmitting = 0; txBufferLength = txBufferIndex = 0; }
|
||||
|
||||
uint8_t transmitting{0};
|
||||
uint8_t txAddress{0};
|
||||
size_t txBufferIndex{0}, txBufferLength{0}, rxBufferIndex{0}, rxBufferLength{0};
|
||||
uint8_t txBuffer[LEN]{}, rxBuffer[LEN]{};
|
||||
};
|
||||
extern TwoWire Wire;
|
||||
|
||||
#elif defined(WAB_WIRE_PICO)
|
||||
#define TwoWire TwoWirePico
|
||||
#define Wire WirePico
|
||||
#define Wire1 Wire1Pico
|
||||
// arduino-pico 6.3.2 libraries/Wire: WIRE_BUFFER_SIZE 256, one buffer for TX and RX
|
||||
#ifndef WIRE_BUFFER_SIZE
|
||||
#define WIRE_BUFFER_SIZE 256
|
||||
#endif
|
||||
class TwoWire {
|
||||
public:
|
||||
static constexpr size_t LEN = WIRE_BUFFER_SIZE;
|
||||
void setSDA(int) {}
|
||||
void setSCL(int) {}
|
||||
void begin() {}
|
||||
void setClock(uint32_t) {}
|
||||
void setTimeout(uint32_t) {}
|
||||
void beginTransmission(uint8_t addr) {
|
||||
if (!_running || _txBegun)
|
||||
return; // ERROR
|
||||
_addr = addr;
|
||||
_buffLen = 0;
|
||||
_buffOff = 0;
|
||||
_txBegun = true;
|
||||
}
|
||||
size_t write(uint8_t ucData) {
|
||||
if (!_running)
|
||||
return 0;
|
||||
if (!_txBegun || (_buffLen == int(LEN)))
|
||||
return 0;
|
||||
_buff[_buffLen++] = ucData;
|
||||
return 1;
|
||||
}
|
||||
size_t write(const uint8_t *data, size_t quantity) {
|
||||
for (size_t i = 0; i < quantity; ++i)
|
||||
if (!write(data[i]))
|
||||
return i;
|
||||
return quantity;
|
||||
}
|
||||
uint8_t endTransmission(bool stopBit) {
|
||||
if (!_running || !_txBegun)
|
||||
return 4;
|
||||
_txBegun = false;
|
||||
auto &w = wab::wire();
|
||||
auto &s = wab::slave();
|
||||
if (!_buffLen) {
|
||||
// _probe(): its own START, address, STOP
|
||||
w.start();
|
||||
uint8_t ab = _addr << 1;
|
||||
bool ack = s.address(ab);
|
||||
w.wbyte(ab, ack);
|
||||
w.stop();
|
||||
return ack ? 0 : 2;
|
||||
}
|
||||
// i2c_write_blocking_until: abort (with STOP) on any NACK, returns PICO_ERROR_GENERIC
|
||||
w.start();
|
||||
uint8_t ab = _addr << 1;
|
||||
bool ok = s.address(ab);
|
||||
w.wbyte(ab, ok);
|
||||
for (int i = 0; ok && i < _buffLen; i++) {
|
||||
ok = s.data(_buff[i]);
|
||||
w.wbyte(_buff[i], ok);
|
||||
}
|
||||
if (stopBit || !ok)
|
||||
w.stop();
|
||||
_buffLen = 0;
|
||||
return ok ? 0 : 4;
|
||||
}
|
||||
size_t requestFrom(uint8_t address, size_t quantity, bool stopBit) {
|
||||
if (!_running || _txBegun || !quantity || (quantity > LEN))
|
||||
return 0;
|
||||
auto &w = wab::wire();
|
||||
auto &s = wab::slave();
|
||||
w.start();
|
||||
uint8_t ab = (address << 1) | 1;
|
||||
bool ack = s.address(ab);
|
||||
w.wbyte(ab, ack);
|
||||
_buffOff = 0;
|
||||
if (!ack) {
|
||||
w.stop();
|
||||
_buffLen = 0;
|
||||
return 0;
|
||||
}
|
||||
for (size_t i = 0; i < quantity; i++) {
|
||||
_buff[i] = s.next_read();
|
||||
w.rbyte(_buff[i], i + 1 < quantity);
|
||||
}
|
||||
if (stopBit)
|
||||
w.stop();
|
||||
_buffLen = quantity;
|
||||
return quantity;
|
||||
}
|
||||
int read() { return _buffOff < _buffLen ? _buff[_buffOff++] : -1; }
|
||||
void wab_reset() { _txBegun = false; _buffLen = _buffOff = 0; }
|
||||
|
||||
bool _running{true};
|
||||
bool _txBegun{false};
|
||||
uint8_t _addr{0};
|
||||
int _buffLen{0}, _buffOff{0};
|
||||
uint8_t _buff[LEN]{};
|
||||
};
|
||||
extern TwoWire Wire;
|
||||
extern TwoWire Wire1;
|
||||
#else
|
||||
#error "select a Wire model"
|
||||
#endif
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
#pragma once
|
||||
// Types of ESP-IDF 5.5.5 esp_driver_i2c used by i2c_bus_esp_idf, with an execute model that puts the jobs on the
|
||||
// wab wire and applies the driver's own argument checks (command count, NACK before STOP).
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
typedef int esp_err_t;
|
||||
#define ESP_OK 0
|
||||
#define ESP_FAIL -1
|
||||
#define ESP_ERR_INVALID_ARG 0x102
|
||||
#define ESP_ERR_INVALID_STATE 0x103
|
||||
#define ESP_ERR_INVALID_RESPONSE 0x108
|
||||
#define ESP_ERR_TIMEOUT 0x107
|
||||
inline const char *esp_err_to_name(esp_err_t) { return "err"; }
|
||||
typedef int i2c_port_t;
|
||||
typedef enum { I2C_MASTER_WRITE = 0, I2C_MASTER_READ } i2c_rw_t;
|
||||
typedef enum { I2C_ACK_VAL = 0, I2C_NACK_VAL = 1 } i2c_ack_value_t;
|
||||
typedef enum { I2C_MASTER_CMD_START, I2C_MASTER_CMD_WRITE, I2C_MASTER_CMD_READ, I2C_MASTER_CMD_STOP } i2c_master_command_t;
|
||||
typedef struct i2c_master_bus_t *i2c_master_bus_handle_t;
|
||||
typedef struct i2c_master_dev_t *i2c_master_dev_handle_t;
|
||||
typedef struct {
|
||||
i2c_master_command_t command;
|
||||
union {
|
||||
struct {
|
||||
bool ack_check;
|
||||
uint8_t *data;
|
||||
size_t total_bytes;
|
||||
} write;
|
||||
struct {
|
||||
i2c_ack_value_t ack_value;
|
||||
uint8_t *data;
|
||||
size_t total_bytes;
|
||||
} read;
|
||||
};
|
||||
} i2c_operation_job_t;
|
||||
#ifndef SOC_I2C_CMD_REG_NUM
|
||||
#define SOC_I2C_CMD_REG_NUM 8 // C2, C3, C6, S3, P4; 16 on ESP32 and S2
|
||||
#endif
|
||||
esp_err_t i2c_master_execute_defined_operations(i2c_master_dev_handle_t dev, i2c_operation_job_t *ops, size_t n,
|
||||
int timeout_ms);
|
||||
@@ -0,0 +1,208 @@
|
||||
// Drives every I2CDevice call shape through each bus model and writes one line per call to $WAB_OUT.
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <fstream>
|
||||
#include <functional>
|
||||
#include <vector>
|
||||
#ifndef __has_feature
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if defined(__SANITIZE_ADDRESS__) || __has_feature(address_sanitizer)
|
||||
#define WAB_ASAN 1
|
||||
extern "C" int __sanitizer_install_malloc_and_free_hooks(void (*malloc_hook)(const volatile void *, size_t),
|
||||
void (*free_hook)(const volatile void *));
|
||||
#endif
|
||||
#include "esphome/components/i2c/i2c.h"
|
||||
#include "wab_common.h"
|
||||
|
||||
esphome::i2c::I2CBus *wab_make_esp8266();
|
||||
esphome::i2c::I2CBus *wab_make_pico();
|
||||
esphome::i2c::I2CBus *wab_make_idf();
|
||||
esphome::i2c::I2CBus *wab_make_sw();
|
||||
void wab_reset_esp8266();
|
||||
void wab_reset_pico();
|
||||
void wab_reset_sw();
|
||||
|
||||
namespace wab {
|
||||
static volatile bool g_window = false;
|
||||
static volatile size_t g_allocs = 0;
|
||||
#ifdef WAB_ASAN
|
||||
static void on_malloc(const volatile void *, size_t) {
|
||||
if (g_window)
|
||||
g_allocs = g_allocs + 1;
|
||||
}
|
||||
static void on_free(const volatile void *) {}
|
||||
static bool install() {
|
||||
__sanitizer_install_malloc_and_free_hooks(on_malloc, on_free);
|
||||
return true;
|
||||
}
|
||||
#else
|
||||
typedef void(malloc_logger_t)(uint32_t type, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t result,
|
||||
uint32_t num_hot_frames_to_skip);
|
||||
extern "C" malloc_logger_t *malloc_logger;
|
||||
static void on_log(uint32_t type, uintptr_t, uintptr_t, uintptr_t, uintptr_t, uint32_t) {
|
||||
// MALLOC_LOG_TYPE_ALLOCATE = 2
|
||||
if (g_window && (type & 2))
|
||||
g_allocs = g_allocs + 1;
|
||||
}
|
||||
static bool install() {
|
||||
malloc_logger = on_log;
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
static bool g_installed = install();
|
||||
void alloc_window(bool on) {
|
||||
if (on)
|
||||
g_allocs = 0;
|
||||
g_window = on;
|
||||
}
|
||||
size_t alloc_count() { return g_allocs; }
|
||||
} // namespace wab
|
||||
|
||||
namespace esphome::i2c::testing {
|
||||
|
||||
// Zephyr, host and TCA9548A keep the default write_prefixed(): this bus only has write_readv(), like them
|
||||
class DefaultPathBus : public I2CBus {
|
||||
public:
|
||||
ErrorCode write_readv(uint8_t address, const uint8_t *wb, size_t wc, uint8_t *rb, size_t rc) override {
|
||||
auto &w = wab::wire();
|
||||
auto &s = wab::slave();
|
||||
if (wc != 0 || rc == 0) {
|
||||
w.start();
|
||||
bool ok = s.address(address << 1);
|
||||
w.wbyte(address << 1, ok);
|
||||
for (size_t i = 0; ok && i < wc; i++) {
|
||||
ok = s.data(wb[i]);
|
||||
w.wbyte(wb[i], ok);
|
||||
}
|
||||
if (!ok) {
|
||||
w.stop();
|
||||
return ERROR_NOT_ACKNOWLEDGED;
|
||||
}
|
||||
if (rc == 0) {
|
||||
w.stop();
|
||||
return ERROR_OK;
|
||||
}
|
||||
}
|
||||
w.start();
|
||||
bool ok = s.address((address << 1) | 1);
|
||||
w.wbyte((address << 1) | 1, ok);
|
||||
for (size_t i = 0; ok && i < rc; i++) {
|
||||
rb[i] = s.next_read();
|
||||
w.rbyte(rb[i], i + 1 < rc);
|
||||
}
|
||||
w.stop();
|
||||
return ok ? ERROR_OK : ERROR_NOT_ACKNOWLEDGED;
|
||||
}
|
||||
};
|
||||
|
||||
static std::vector<uint8_t> pattern(size_t len, uint8_t seed) {
|
||||
std::vector<uint8_t> v(len);
|
||||
for (size_t i = 0; i < len; i++)
|
||||
v[i] = static_cast<uint8_t>(seed + i * 7);
|
||||
return v;
|
||||
}
|
||||
|
||||
TEST(WireAB, Record) {
|
||||
const char *out = std::getenv("WAB_OUT");
|
||||
ASSERT_NE(out, nullptr);
|
||||
std::ofstream f(out);
|
||||
// Allocation counter sanity: a malloc inside the window must count
|
||||
wab::alloc_window(true);
|
||||
void *volatile probe = malloc(100);
|
||||
wab::alloc_window(false);
|
||||
free(probe);
|
||||
f << "ALLOC_PROBE " << wab::alloc_count() << "\n";
|
||||
ASSERT_EQ(wab::alloc_count(), 1u);
|
||||
|
||||
struct Bus {
|
||||
const char *name;
|
||||
I2CBus *bus;
|
||||
std::function<void()> reset;
|
||||
};
|
||||
std::vector<Bus> buses = {
|
||||
{"esp8266", wab_make_esp8266(), wab_reset_esp8266},
|
||||
{"pico", wab_make_pico(), wab_reset_pico},
|
||||
{"idf", wab_make_idf(), [] {}},
|
||||
{"sw", wab_make_sw(), wab_reset_sw},
|
||||
{"default", new DefaultPathBus(), [] {}},
|
||||
};
|
||||
for (auto &b : buses) {
|
||||
I2CDevice dev;
|
||||
dev.set_i2c_bus(b.bus);
|
||||
auto run = [&](const std::string &label, const std::function<ErrorCode()> &fn, bool reset = true) {
|
||||
if (reset)
|
||||
b.reset();
|
||||
wab::wire().clear();
|
||||
wab::jobs_note().clear();
|
||||
// the recorder must not allocate inside the window
|
||||
wab::wire().text.reserve(16384);
|
||||
wab::jobs_note().reserve(1024);
|
||||
wab::alloc_window(true);
|
||||
ErrorCode rc = fn();
|
||||
wab::alloc_window(false);
|
||||
f << b.name << "|" << label << "|rc=" << rc << "|alloc=" << wab::alloc_count() << "|" << wab::wire().text
|
||||
<< "\n";
|
||||
if (!wab::jobs_note().empty())
|
||||
f << "J|" << b.name << "|" << label << "|" << wab::jobs_note() << "\n";
|
||||
};
|
||||
auto &sl = wab::slave();
|
||||
sl.ack_limit = SIZE_MAX;
|
||||
dev.set_i2c_address(0x48);
|
||||
for (size_t len = 0; len <= 300; len++) {
|
||||
auto d = pattern(len, 0x11);
|
||||
run("wreg8 len=" + std::to_string(len), [&] { return dev.write_register(0x02, d.data(), d.size()); });
|
||||
run("wreg16 len=" + std::to_string(len), [&] { return dev.write_register16(0xBEEF, d.data(), d.size()); });
|
||||
}
|
||||
// nullptr data with len 0, as a caller with no payload may pass
|
||||
run("wreg8 null len=0", [&] { return dev.write_register(0x03, nullptr, 0); });
|
||||
run("wreg16 null len=0", [&] { return dev.write_register16(0x0304, nullptr, 0); });
|
||||
// slave NACKs after k data bytes (k counts the register byte)
|
||||
for (size_t k = 0; k <= 6; k++) {
|
||||
sl.ack_limit = k;
|
||||
auto d = pattern(4, 0x40);
|
||||
run("wreg8 len=4 acklimit=" + std::to_string(k), [&] { return dev.write_register(0x05, d.data(), d.size()); });
|
||||
run("wreg16 len=4 acklimit=" + std::to_string(k),
|
||||
[&] { return dev.write_register16(0x0506, d.data(), d.size()); });
|
||||
}
|
||||
sl.ack_limit = SIZE_MAX;
|
||||
// reads, write+read with repeated start, plain writes, probes
|
||||
for (size_t n : {1, 2, 3, 16, 32}) {
|
||||
std::vector<uint8_t> r(n);
|
||||
run("rreg8 n=" + std::to_string(n), [&] { return dev.read_register(0x01, r.data(), n); });
|
||||
run("rreg16 n=" + std::to_string(n), [&] { return dev.read_register16(0x0102, r.data(), n); });
|
||||
run("read n=" + std::to_string(n), [&] { return dev.read(r.data(), n); });
|
||||
auto w3 = pattern(3, 0x70);
|
||||
run("wr 3+" + std::to_string(n), [&] { return dev.write_read(w3.data(), 3, r.data(), n); });
|
||||
}
|
||||
for (size_t len : {0, 1, 5, 127, 128, 129, 255, 256, 257}) {
|
||||
auto d = pattern(len, 0x22);
|
||||
run("write len=" + std::to_string(len), [&] { return dev.write(d.data(), d.size()); });
|
||||
}
|
||||
// a normal transaction right after an over-long write, without resetting the Wire model in between
|
||||
for (size_t len : {200, 300}) {
|
||||
auto d = pattern(len, 0x33);
|
||||
run("wedge wreg8 len=" + std::to_string(len), [&] { return dev.write_register(0x02, d.data(), d.size()); });
|
||||
std::vector<uint8_t> r(2);
|
||||
run("wedge then rreg8 n=2", [&] { return dev.read_register(0x01, r.data(), 2); }, false);
|
||||
auto s = pattern(2, 0x44);
|
||||
run("wedge then wreg8 len=2", [&] { return dev.write_register(0x02, s.data(), 2); }, false);
|
||||
}
|
||||
// absent device
|
||||
dev.set_i2c_address(0x50);
|
||||
for (size_t len : {0, 1, 5}) {
|
||||
auto d = pattern(len, 0x55);
|
||||
run("absent wreg8 len=" + std::to_string(len), [&] { return dev.write_register(0x02, d.data(), d.size()); });
|
||||
run("absent wreg16 len=" + std::to_string(len),
|
||||
[&] { return dev.write_register16(0x0203, d.data(), d.size()); });
|
||||
}
|
||||
// scan probe over the whole range, as i2c_scan_() does
|
||||
for (uint8_t a = 8; a != 120; a++) {
|
||||
run("probe " + std::to_string(a), [&] { return b.bus->write_readv(a, nullptr, 0, nullptr, 0); });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace esphome::i2c::testing
|
||||
@@ -0,0 +1,34 @@
|
||||
// Arduino bus body of the tree under test on the esp8266 core Wire model
|
||||
#include "esphome/core/application.h"
|
||||
#include "esphome/core/component.h"
|
||||
#include "esphome/core/hal.h"
|
||||
#include "esphome/core/helpers.h"
|
||||
#include "esphome/core/log.h"
|
||||
#include "esphome/components/i2c/i2c_bus.h"
|
||||
#define WAB_WIRE_ESP8266
|
||||
#define USE_ARDUINO
|
||||
#define USE_ESP8266
|
||||
#define ArduinoI2CBus ArduinoI2CBus8266
|
||||
#include "esphome/components/i2c/i2c_bus_arduino.h"
|
||||
TwoWire Wire;
|
||||
namespace esphome::i2c {
|
||||
ESPHOME_LOG_TAG(TAG, "i2c");
|
||||
static constexpr size_t I2C_MAX_LOG_BYTES = 32;
|
||||
void ArduinoI2CBus::setup() {}
|
||||
void ArduinoI2CBus::dump_config() {}
|
||||
void ArduinoI2CBus::set_pins_and_clock_() {}
|
||||
#include "wab_gen_arduino.inc"
|
||||
} // namespace esphome::i2c
|
||||
#undef USE_ESP8266
|
||||
#undef USE_ARDUINO
|
||||
struct A8Init { using type = bool esphome::i2c::ArduinoI2CBus::*; friend type get(A8Init); };
|
||||
struct A8Wire { using type = TwoWire *esphome::i2c::ArduinoI2CBus::*; friend type get(A8Wire); };
|
||||
template struct WabRob<A8Init, &esphome::i2c::ArduinoI2CBus::initialized_>;
|
||||
template struct WabRob<A8Wire, &esphome::i2c::ArduinoI2CBus::wire_>;
|
||||
esphome::i2c::I2CBus *wab_make_esp8266() {
|
||||
auto *b = new esphome::i2c::ArduinoI2CBus();
|
||||
b->*get(A8Init()) = true;
|
||||
b->*get(A8Wire()) = &Wire;
|
||||
return b;
|
||||
}
|
||||
void wab_reset_esp8266() { Wire.wab_reset(); }
|
||||
@@ -0,0 +1,35 @@
|
||||
// Arduino bus body of the tree under test on the arduino-pico Wire model
|
||||
#include "esphome/core/application.h"
|
||||
#include "esphome/core/component.h"
|
||||
#include "esphome/core/hal.h"
|
||||
#include "esphome/core/helpers.h"
|
||||
#include "esphome/core/log.h"
|
||||
#include "esphome/components/i2c/i2c_bus.h"
|
||||
#define WAB_WIRE_PICO
|
||||
#define USE_ARDUINO
|
||||
#define USE_RP2
|
||||
#define ArduinoI2CBus ArduinoI2CBusPico
|
||||
#include "esphome/components/i2c/i2c_bus_arduino.h"
|
||||
TwoWire Wire;
|
||||
TwoWire Wire1;
|
||||
namespace esphome::i2c {
|
||||
ESPHOME_LOG_TAG(TAG, "i2c");
|
||||
static constexpr size_t I2C_MAX_LOG_BYTES = 32;
|
||||
void ArduinoI2CBus::setup() {}
|
||||
void ArduinoI2CBus::dump_config() {}
|
||||
void ArduinoI2CBus::set_pins_and_clock_() {}
|
||||
#include "wab_gen_arduino.inc"
|
||||
} // namespace esphome::i2c
|
||||
#undef USE_RP2
|
||||
#undef USE_ARDUINO
|
||||
struct APInit { using type = bool esphome::i2c::ArduinoI2CBus::*; friend type get(APInit); };
|
||||
struct APWire { using type = TwoWire *esphome::i2c::ArduinoI2CBus::*; friend type get(APWire); };
|
||||
template struct WabRob<APInit, &esphome::i2c::ArduinoI2CBus::initialized_>;
|
||||
template struct WabRob<APWire, &esphome::i2c::ArduinoI2CBus::wire_>;
|
||||
esphome::i2c::I2CBus *wab_make_pico() {
|
||||
auto *b = new esphome::i2c::ArduinoI2CBus();
|
||||
b->*get(APInit()) = true;
|
||||
b->*get(APWire()) = &Wire;
|
||||
return b;
|
||||
}
|
||||
void wab_reset_pico() { Wire.wab_reset(); }
|
||||
@@ -0,0 +1,87 @@
|
||||
#pragma once
|
||||
// Wire-level A/B harness for esphome#22780: every bus model emits the same token stream.
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace wab {
|
||||
|
||||
// Token stream of the bus: "S", "Sr", "P", "AB+" (written byte, slave ACK), "AB-" (NACK), "rAB+"/"rAB-" (read byte,
|
||||
// master ACK/NACK), "ABORT".
|
||||
struct Wire {
|
||||
std::string text;
|
||||
bool open{false};
|
||||
void start() {
|
||||
text += open ? "Sr " : "S ";
|
||||
open = true;
|
||||
}
|
||||
void stop() {
|
||||
text += "P ";
|
||||
open = false;
|
||||
}
|
||||
void wbyte(uint8_t b, bool ack) {
|
||||
char t[8];
|
||||
snprintf(t, sizeof t, "%02X%c ", b, ack ? '+' : '-');
|
||||
text += t;
|
||||
}
|
||||
void rbyte(uint8_t b, bool ack) {
|
||||
char t[8];
|
||||
snprintf(t, sizeof t, "r%02X%c ", b, ack ? '+' : '-');
|
||||
text += t;
|
||||
}
|
||||
void note(const char *s) {
|
||||
text += s;
|
||||
text += ' ';
|
||||
}
|
||||
void clear() {
|
||||
text.clear();
|
||||
open = false;
|
||||
}
|
||||
};
|
||||
inline Wire &wire() {
|
||||
static Wire w;
|
||||
return w;
|
||||
}
|
||||
inline std::string &jobs_note() {
|
||||
static std::string s;
|
||||
return s;
|
||||
}
|
||||
|
||||
// Slave model: present addresses ACK their address and up to ack_limit data bytes after it.
|
||||
struct Slave {
|
||||
uint8_t present[4]{0x48, 0x1A, 0, 0};
|
||||
size_t ack_limit{SIZE_MAX};
|
||||
size_t written{0}; // data bytes written since the address byte
|
||||
size_t read_idx{0};
|
||||
bool is_present(uint8_t addr7) const {
|
||||
for (auto p : present)
|
||||
if (p != 0 && p == addr7)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
// Called for the address byte; returns ACK
|
||||
bool address(uint8_t byte) {
|
||||
this->written = 0;
|
||||
this->read_idx = 0;
|
||||
return this->is_present(byte >> 1);
|
||||
}
|
||||
bool data(uint8_t) { return this->written++ < this->ack_limit; }
|
||||
uint8_t next_read() { return static_cast<uint8_t>(0xA0 + this->read_idx++); }
|
||||
};
|
||||
inline Slave &slave() {
|
||||
static Slave s;
|
||||
return s;
|
||||
}
|
||||
|
||||
// Allocation counter (window opened around one bus call)
|
||||
void alloc_window(bool on);
|
||||
size_t alloc_count();
|
||||
|
||||
} // namespace wab
|
||||
|
||||
// Member access to private fields of final classes (explicit instantiation ignores access checks)
|
||||
template<typename Tag, typename Tag::type M> struct WabRob {
|
||||
friend typename Tag::type get(Tag) { return M; }
|
||||
};
|
||||
@@ -0,0 +1,88 @@
|
||||
// ESP-IDF bus body of the tree under test on the IDF 5.5.5 job model
|
||||
#include <string>
|
||||
#include "esphome/core/application.h"
|
||||
#include "esphome/core/component.h"
|
||||
#include "esphome/core/hal.h"
|
||||
#include "esphome/core/helpers.h"
|
||||
#include "esphome/core/log.h"
|
||||
#include "esphome/components/i2c/i2c_bus.h"
|
||||
#include "wab_common.h"
|
||||
#define USE_ESP32
|
||||
#include "esphome/components/i2c/i2c_bus_esp_idf.h"
|
||||
namespace esphome::i2c {
|
||||
ESPHOME_LOG_TAG(TAG, "i2c.idf");
|
||||
static constexpr size_t I2C_MAX_LOG_BYTES = 32;
|
||||
void IDFI2CBus::setup() {}
|
||||
void IDFI2CBus::dump_config() {}
|
||||
#include "wab_gen_idf.inc"
|
||||
} // namespace esphome::i2c
|
||||
#undef USE_ESP32
|
||||
|
||||
esp_err_t i2c_master_execute_defined_operations(i2c_master_dev_handle_t, i2c_operation_job_t *ops, size_t n, int) {
|
||||
auto &jn = wab::jobs_note();
|
||||
jn.clear();
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
char t[16];
|
||||
switch (ops[i].command) {
|
||||
case I2C_MASTER_CMD_START: jn += "S "; break;
|
||||
case I2C_MASTER_CMD_STOP: jn += "P "; break;
|
||||
case I2C_MASTER_CMD_WRITE: snprintf(t, sizeof t, "W%zu ", ops[i].write.total_bytes); jn += t; break;
|
||||
case I2C_MASTER_CMD_READ: snprintf(t, sizeof t, "R%zu%s ", ops[i].read.total_bytes,
|
||||
ops[i].read.ack_value == I2C_NACK_VAL ? "n" : "a"); jn += t; break;
|
||||
}
|
||||
}
|
||||
auto &w = wab::wire();
|
||||
auto &s = wab::slave();
|
||||
if (n > SOC_I2C_CMD_REG_NUM) {
|
||||
w.note("INVALID_ARG_TOO_MANY_JOBS");
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
for (size_t i = 0; i + 1 < n; i++) {
|
||||
if (ops[i].command == I2C_MASTER_CMD_READ && ops[i + 1].command == I2C_MASTER_CMD_STOP &&
|
||||
ops[i].read.ack_value != I2C_NACK_VAL) {
|
||||
w.note("INVALID_ARG_ACK_BEFORE_STOP");
|
||||
return ESP_ERR_INVALID_ARG;
|
||||
}
|
||||
}
|
||||
bool expect_addr = false;
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
auto &op = ops[i];
|
||||
switch (op.command) {
|
||||
case I2C_MASTER_CMD_START:
|
||||
w.start();
|
||||
expect_addr = true;
|
||||
break;
|
||||
case I2C_MASTER_CMD_STOP:
|
||||
w.stop();
|
||||
break;
|
||||
case I2C_MASTER_CMD_WRITE:
|
||||
for (size_t k = 0; k < op.write.total_bytes; k++) {
|
||||
uint8_t b = op.write.data[k];
|
||||
bool ack = expect_addr ? s.address(b) : s.data(b);
|
||||
expect_addr = false;
|
||||
w.wbyte(b, ack);
|
||||
if (!ack && op.write.ack_check) {
|
||||
w.note("ABORT");
|
||||
w.stop();
|
||||
return ESP_ERR_INVALID_STATE;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case I2C_MASTER_CMD_READ:
|
||||
for (size_t k = 0; k < op.read.total_bytes; k++) {
|
||||
op.read.data[k] = s.next_read();
|
||||
w.rbyte(op.read.data[k], op.read.ack_value == I2C_ACK_VAL);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
struct IdfInit { using type = bool esphome::i2c::IDFI2CBus::*; friend type get(IdfInit); };
|
||||
template struct WabRob<IdfInit, &esphome::i2c::IDFI2CBus::initialized_>;
|
||||
esphome::i2c::I2CBus *wab_make_idf() {
|
||||
auto *b = new esphome::i2c::IDFI2CBus();
|
||||
b->*get(IdfInit()) = true;
|
||||
return b;
|
||||
}
|
||||
@@ -0,0 +1,156 @@
|
||||
// The software bus of the tree under test, whole, on fake open-drain pins with a bit-level slave
|
||||
#include "esphome/core/application.h"
|
||||
#include "esphome/core/component.h"
|
||||
#include "esphome/core/gpio.h"
|
||||
#include "esphome/core/hal.h"
|
||||
#include "esphome/core/helpers.h"
|
||||
#include "esphome/core/log.h"
|
||||
#include "esphome/components/i2c/i2c_bus.h"
|
||||
#include "wab_common.h"
|
||||
|
||||
namespace wab {
|
||||
struct BitSlave {
|
||||
bool m_sda_low{false}, m_scl_low{false}, s_sda_low{false};
|
||||
bool sda{true}, scl{true};
|
||||
enum { IDLE, ADDR, WDATA, RDATA, IGNORE } state{IDLE};
|
||||
enum { BITS, ACK_OUT, ACK_IN } phase{BITS};
|
||||
int bits{0};
|
||||
uint8_t shift{0}, cur{0};
|
||||
bool last_ack{false}, is_read{false}, master_ack{false};
|
||||
void drive_bit() { this->s_sda_low = !(this->cur & (0x80 >> this->bits)); }
|
||||
void update() {
|
||||
auto &w = wire();
|
||||
auto &sl = slave();
|
||||
for (int guard = 0; guard < 4; guard++) {
|
||||
bool nsda = !(this->m_sda_low || this->s_sda_low), nscl = !this->m_scl_low;
|
||||
if (nsda == this->sda && nscl == this->scl)
|
||||
return;
|
||||
bool sda_fell = this->sda && !nsda, sda_rose = !this->sda && nsda;
|
||||
bool scl_rose = !this->scl && nscl, scl_fell = this->scl && !nscl;
|
||||
this->sda = nsda;
|
||||
this->scl = nscl;
|
||||
if (this->scl && !scl_rose && sda_fell) { // START
|
||||
w.start();
|
||||
this->state = ADDR;
|
||||
this->phase = BITS;
|
||||
this->bits = 0;
|
||||
this->shift = 0;
|
||||
this->s_sda_low = false;
|
||||
continue;
|
||||
}
|
||||
if (this->scl && !scl_rose && sda_rose) { // STOP
|
||||
if (w.open)
|
||||
w.stop();
|
||||
this->state = IDLE;
|
||||
this->s_sda_low = false;
|
||||
continue;
|
||||
}
|
||||
if (scl_rose) {
|
||||
if ((this->state == ADDR || this->state == WDATA) && this->phase == BITS) {
|
||||
this->shift = (this->shift << 1) | (this->sda ? 1 : 0);
|
||||
this->bits++;
|
||||
} else if (this->state == RDATA && this->phase == ACK_IN) {
|
||||
this->master_ack = !this->sda;
|
||||
w.rbyte(this->cur, this->master_ack);
|
||||
}
|
||||
} else if (scl_fell) {
|
||||
if ((this->state == ADDR || this->state == WDATA) && this->phase == BITS && this->bits == 8) {
|
||||
if (this->state == ADDR) {
|
||||
this->last_ack = sl.address(this->shift);
|
||||
this->is_read = this->shift & 1;
|
||||
} else {
|
||||
this->last_ack = sl.data(this->shift);
|
||||
}
|
||||
w.wbyte(this->shift, this->last_ack);
|
||||
this->s_sda_low = this->last_ack;
|
||||
this->phase = ACK_OUT;
|
||||
} else if (this->phase == ACK_OUT) {
|
||||
this->s_sda_low = false;
|
||||
this->bits = 0;
|
||||
this->shift = 0;
|
||||
this->phase = BITS;
|
||||
if (!this->last_ack) {
|
||||
this->state = IGNORE;
|
||||
} else if (this->state == ADDR && this->is_read) {
|
||||
this->state = RDATA;
|
||||
this->cur = sl.next_read();
|
||||
this->drive_bit();
|
||||
} else {
|
||||
this->state = WDATA;
|
||||
}
|
||||
} else if (this->state == RDATA && this->phase == BITS) {
|
||||
this->bits++;
|
||||
if (this->bits == 8) {
|
||||
this->s_sda_low = false;
|
||||
this->phase = ACK_IN;
|
||||
} else {
|
||||
this->drive_bit();
|
||||
}
|
||||
} else if (this->state == RDATA && this->phase == ACK_IN) {
|
||||
if (this->master_ack) {
|
||||
this->cur = sl.next_read();
|
||||
this->bits = 0;
|
||||
this->phase = BITS;
|
||||
this->drive_bit();
|
||||
} else {
|
||||
this->state = IGNORE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
inline BitSlave &bitslave() {
|
||||
static BitSlave b;
|
||||
return b;
|
||||
}
|
||||
|
||||
class FakePin : public esphome::GPIOPin {
|
||||
public:
|
||||
explicit FakePin(bool is_sda) : is_sda_(is_sda) {}
|
||||
void setup() override {}
|
||||
void pin_mode(esphome::gpio::Flags flags) override {
|
||||
this->flags_ = flags;
|
||||
this->apply_();
|
||||
}
|
||||
esphome::gpio::Flags get_flags() const override { return this->flags_; }
|
||||
bool digital_read() override { return this->is_sda_ ? bitslave().sda : bitslave().scl; }
|
||||
void digital_write(bool value) override {
|
||||
this->value_ = value;
|
||||
this->apply_();
|
||||
}
|
||||
size_t dump_summary(char *buffer, size_t len) const override { return 0; }
|
||||
|
||||
protected:
|
||||
void apply_() {
|
||||
bool low = (this->flags_ & esphome::gpio::FLAG_OUTPUT) && !this->value_;
|
||||
(this->is_sda_ ? bitslave().m_sda_low : bitslave().m_scl_low) = low;
|
||||
bitslave().update();
|
||||
}
|
||||
bool is_sda_;
|
||||
bool value_{true};
|
||||
esphome::gpio::Flags flags_{esphome::gpio::FLAG_INPUT};
|
||||
};
|
||||
} // namespace wab
|
||||
|
||||
#define USE_LIBRETINY
|
||||
#define InternalGPIOPin wab::FakePin
|
||||
#include "wab_sw_impl.inc"
|
||||
#undef InternalGPIOPin
|
||||
#undef USE_LIBRETINY
|
||||
|
||||
esphome::i2c::I2CBus *wab_make_sw() {
|
||||
static wab::FakePin sda(true), scl(false);
|
||||
auto *b = new esphome::i2c::SoftwareI2CBus();
|
||||
b->set_sda_pin(&sda);
|
||||
b->set_scl_pin(&scl);
|
||||
b->set_frequency(1000000);
|
||||
b->set_scan(false);
|
||||
b->setup();
|
||||
return b;
|
||||
}
|
||||
void wab_reset_sw() {
|
||||
auto &b = wab::bitslave();
|
||||
b.state = wab::BitSlave::IDLE;
|
||||
b.s_sda_low = false;
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
"""Readers for the sweep lines of dev/snf.hpp (SN) and ard/swp.hpp (SW), shared by the comparers."""
|
||||
|
||||
from collections.abc import Mapping
|
||||
import pathlib
|
||||
import re
|
||||
|
||||
ANSI = re.compile(r"\x1b\[[0-9;]*m")
|
||||
FIELDS = r"\|rc=(-?\d+)\|alloc=(\d+)\|ev=\d+\|amb=\d+\|ovf=\d+\|fnv=([0-9A-F]+)\|(.*)$"
|
||||
CAPTURES = ("", "2", "3")
|
||||
|
||||
|
||||
def load(path: str | pathlib.Path, tag: str = "SN") -> dict[str, dict]:
|
||||
"""Case label -> rc, alloc, fnv and the rest of the line.
|
||||
|
||||
SN lines get `verdict` (OK or DIFF) and, on a DIFF, the `got` and `exp` token lists of the SNGOT and SNEXP lines
|
||||
that follow. SW lines get `wire` (the decoded stream) and `rd` (read data).
|
||||
"""
|
||||
line_re = re.compile(rf"{tag} (.+?){FIELDS}")
|
||||
cases: dict[str, dict] = {}
|
||||
cur: dict | None = None
|
||||
text = pathlib.Path(path).read_text(encoding="utf-8", errors="replace")
|
||||
for line in text.splitlines():
|
||||
line = ANSI.sub("", line).rstrip()
|
||||
if m := line_re.search(line):
|
||||
label, rc, alloc, fnv, rest = m.groups()
|
||||
cur = cases[label] = {"rc": int(rc), "alloc": int(alloc), "fnv": fnv}
|
||||
if tag == "SW":
|
||||
wire, _, rd = rest.partition("|rd=")
|
||||
cur.update(wire=wire.strip(), rd=rd.strip())
|
||||
else:
|
||||
cur["verdict"] = rest
|
||||
elif cur is not None and (m := re.search(r"SN(GOT|EXP) (.*)$", line)):
|
||||
cur["got" if m.group(1) == "GOT" else "exp"] = m.group(2).split()
|
||||
return cases
|
||||
|
||||
|
||||
def is_read(label: str) -> bool:
|
||||
"""Reads return chip data, so their wire hash changes between runs."""
|
||||
return label.startswith(("rreg", "read", "write1+read"))
|
||||
|
||||
|
||||
def nack_cut(got: list[str], exp: list[str]) -> int | None:
|
||||
"""Index of the token the chip NACKed when `got` is `exp` cut there (then STOP), else None.
|
||||
|
||||
Only address and write tokens count as a chip NACK; a read token ("r..") NACKed early stays a difference.
|
||||
"""
|
||||
j = next(
|
||||
(j for j, t in enumerate(got) if t.endswith("-") and not t.startswith("r")),
|
||||
None,
|
||||
)
|
||||
if (
|
||||
j is not None
|
||||
and got[:j] == exp[:j]
|
||||
and got[j][:-1] == exp[j][:-1]
|
||||
and got[j + 1 :] == ["P"]
|
||||
):
|
||||
return j
|
||||
return None
|
||||
|
||||
|
||||
def runs(name: str) -> list[dict[str, dict]]:
|
||||
"""The captures NAME-ser.txt, NAME-ser2.txt and NAME-ser3.txt that exist (at least one)."""
|
||||
found = [pathlib.Path(f"{name}-ser{s}.txt") for s in CAPTURES]
|
||||
loaded = [load(p) for p in found if p.exists()]
|
||||
if not loaded:
|
||||
raise SystemExit(f"no capture {name}-ser.txt")
|
||||
return loaded
|
||||
|
||||
|
||||
def first_alloc(allocs: Mapping[str, int], shape: str, limit: int = 400) -> int | None:
|
||||
"""First length of `shape` (wreg8, wreg16) whose call allocated; allocs maps case label -> malloc count."""
|
||||
return next(
|
||||
(n for n in range(limit) if allocs.get(f"{shape} len={n}", 0) > 0), None
|
||||
)
|
||||
@@ -0,0 +1,51 @@
|
||||
#pragma once
|
||||
// Wire decoder shared by dev/snf.hpp and ard/swp.hpp. Each sample is a level state: SDA in bit 0, SCL in bit 1.
|
||||
#include <cstdint>
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
|
||||
namespace wiredecode {
|
||||
// Decodes `count` level states that follow `start` into tokens (`S`, `Sr`, `P`, `90+`, `rA0-`); adds to amb the
|
||||
// samples where both lines changed at once.
|
||||
inline std::string decode(const uint8_t *buf, uint32_t count, uint8_t start, uint32_t &amb) {
|
||||
std::string out;
|
||||
uint8_t prev = start;
|
||||
bool open = false, first = false, reading = false;
|
||||
int bits = -1; // -1: no frame; 0..8 bit index in the current 9-bit unit
|
||||
uint16_t sh = 0;
|
||||
char t[8];
|
||||
for (uint32_t i = 0; i < count; i++) {
|
||||
uint8_t cur = buf[i];
|
||||
bool psda = prev & 1, pscl = prev & 2, sda = cur & 1, scl = cur & 2;
|
||||
if ((psda != sda) && (pscl != scl))
|
||||
amb++;
|
||||
if (pscl && scl && psda && !sda) {
|
||||
out += open ? "Sr " : "S ";
|
||||
open = true;
|
||||
bits = 0;
|
||||
sh = 0;
|
||||
first = true;
|
||||
} else if (pscl && scl && !psda && sda) {
|
||||
out += "P ";
|
||||
open = false;
|
||||
bits = -1;
|
||||
} else if (!pscl && scl && bits >= 0) {
|
||||
if (bits < 8) {
|
||||
sh = (sh << 1) | (sda ? 1 : 0);
|
||||
bits++;
|
||||
} else {
|
||||
uint8_t b = sh & 0xFF;
|
||||
if (first)
|
||||
reading = b & 1;
|
||||
snprintf(t, sizeof t, (!first && reading) ? "r%02X%c " : "%02X%c ", b, sda ? '-' : '+');
|
||||
out += t;
|
||||
first = false;
|
||||
bits = 0;
|
||||
sh = 0;
|
||||
}
|
||||
}
|
||||
prev = cur;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
} // namespace wiredecode
|
||||
@@ -0,0 +1,18 @@
|
||||
# Package for Improv tests: Wi-Fi with no network saved, web_server and improv_serial with a next_url, and an ALIVE
|
||||
# line every 5 s. Substitution: name. Drop web_server on a LibreTiny board with no ap: (it boot-loops, see
|
||||
# reference/recipes/improv.md).
|
||||
esphome:
|
||||
name: ${name}
|
||||
|
||||
wifi:
|
||||
power_save_mode: none
|
||||
|
||||
web_server:
|
||||
|
||||
improv_serial:
|
||||
next_url: https://example.com/?device_name={{device_name}}&ip_address={{ip_address}}
|
||||
|
||||
interval:
|
||||
- interval: 5s
|
||||
then:
|
||||
- logger.log: "ALIVE"
|
||||
@@ -0,0 +1,15 @@
|
||||
# Classic ESP32 devkit with Improv over serial (UART0, shared with the log) and BLE. Copy it per build with its own
|
||||
# name; run.sh wants the file name to match name.
|
||||
substitutions:
|
||||
name: improv32
|
||||
packages:
|
||||
common: !include common.yaml
|
||||
esp32:
|
||||
board: esp32dev
|
||||
framework:
|
||||
type: esp-idf
|
||||
logger:
|
||||
hardware_uart: UART0
|
||||
improv_ble:
|
||||
authorizer: none
|
||||
next_url: https://example.com/?device_name={{device_name}}&ip_address={{ip_address}}
|
||||
@@ -0,0 +1,96 @@
|
||||
"""Improv over BLE: find the device by name, send WIFI_SETTINGS and print state, errors and the RPC result URLs.
|
||||
usage: improvble.py NAME SECRETS (needs bleak; the device needs improv_ble authorizer: none and a next_url)"""
|
||||
|
||||
import asyncio
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
from bleak import BleakClient, BleakScanner
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
|
||||
from improvcli import load_wifi_secrets, strings # noqa: E402
|
||||
|
||||
BASE = "00467768-6228-2272-4663-2774782680"
|
||||
STATE, ERROR, RPC, RESULT = BASE + "01", BASE + "02", BASE + "03", BASE + "04"
|
||||
STATES = {1: "awaiting_auth", 2: "authorized", 3: "provisioning", 4: "provisioned"}
|
||||
|
||||
|
||||
def pkt(cmd: int, data: bytes) -> bytes:
|
||||
b = bytes([cmd, len(data)]) + data
|
||||
return b + bytes([sum(b) & 0xFF])
|
||||
|
||||
|
||||
async def main(name: str, secrets: str) -> None:
|
||||
ssid, pw = (x.encode() for x in load_wifi_secrets(secrets))
|
||||
dev = await BleakScanner.find_device_by_name(name, timeout=30)
|
||||
if dev is None:
|
||||
sys.exit(
|
||||
"FAIL: device not found (a provisioned board stops advertising Improv)"
|
||||
)
|
||||
loop = asyncio.get_running_loop()
|
||||
t0 = loop.time()
|
||||
done = asyncio.Event()
|
||||
errors: list = []
|
||||
states: list[int] = []
|
||||
async with BleakClient(dev) as c:
|
||||
|
||||
def on_state(_, d: bytearray) -> None:
|
||||
if not d:
|
||||
errors.append("empty state")
|
||||
return
|
||||
states.append(d[0])
|
||||
print(f"{loop.time() - t0:6.2f} STATE {STATES.get(d[0], d[0])}", flush=True)
|
||||
|
||||
def on_error(_, d: bytearray) -> None:
|
||||
if not d:
|
||||
errors.append("empty error")
|
||||
elif d[0]:
|
||||
errors.append(d[0])
|
||||
print(f"{loop.time() - t0:6.2f} ERROR {d[0]}", flush=True)
|
||||
|
||||
def on_result(_, d: bytearray) -> None:
|
||||
if len(d) < 3 or d[1] != len(d) - 3 or sum(d[:-1]) & 0xFF != d[-1]:
|
||||
errors.append("bad result frame")
|
||||
print(
|
||||
f"{loop.time() - t0:6.2f} BAD RESULT {bytes(d).hex()}", flush=True
|
||||
)
|
||||
return
|
||||
try:
|
||||
strs = strings(bytes(d[2:-1]))
|
||||
except ValueError:
|
||||
errors.append("string overruns the result")
|
||||
strs = []
|
||||
print(f"{loop.time() - t0:6.2f} RESULT cmd={d[0]} {strs}", flush=True)
|
||||
if (
|
||||
d[0] == 1
|
||||
): # the WIFI_SETTINGS reply; the example sets next_url, so it carries a URL
|
||||
if not any(x.startswith("http") for x in strs):
|
||||
errors.append("no URL in result")
|
||||
done.set()
|
||||
|
||||
await c.start_notify(STATE, on_state)
|
||||
await c.start_notify(ERROR, on_error)
|
||||
await c.start_notify(RESULT, on_result)
|
||||
s = await c.read_gatt_char(STATE)
|
||||
print(f"initial state {STATES.get(s[0], s[0]) if s else 'empty'}")
|
||||
if not s or s[0] == 4:
|
||||
sys.exit(
|
||||
"FAIL: board already provisioned or no state; erase the flash first"
|
||||
)
|
||||
payload = bytes([len(ssid)]) + ssid + bytes([len(pw)]) + pw
|
||||
await c.write_gatt_char(RPC, pkt(1, payload), response=True)
|
||||
try:
|
||||
await asyncio.wait_for(done.wait(), 45)
|
||||
except TimeoutError:
|
||||
print("no result within 45 s")
|
||||
await asyncio.sleep(1)
|
||||
last = await c.read_gatt_char(STATE)
|
||||
states.append(last[0] if last else 0)
|
||||
if not done.is_set() or errors or states[-1] != 4:
|
||||
sys.exit(
|
||||
f"FAIL (errors {errors}, last state {STATES.get(states[-1], states[-1])})"
|
||||
)
|
||||
print("PASS")
|
||||
|
||||
|
||||
asyncio.run(main(sys.argv[1], sys.argv[2]))
|
||||
@@ -0,0 +1,339 @@
|
||||
"""Improv serial client that reads frames out of the log stream on the same port.
|
||||
usage: improvcli.py PORT OUT --secrets FILE [--baud N] [--keep-dtr] [--settle S] [--skip-bad] [--allow-reset]
|
||||
Runs: 300 stray bytes, state, info, network state, scan, provision with a bad password, provision with the real one,
|
||||
state and network state again. Prints parsed frames; the raw stream overwrites OUT.
|
||||
Exit 2 when the port does not open or the secrets file lacks a key. Exit 1 when any request goes unanswered, an
|
||||
unexpected error or a malformed frame arrives, or the port resets or the log shows a reboot (unless --allow-reset).
|
||||
Credentials come from the secrets file (wifi_ssid, wifi_password) and are never printed; the SSID is masked in scan
|
||||
results."""
|
||||
|
||||
import argparse
|
||||
import pathlib
|
||||
import random
|
||||
import sys
|
||||
import time
|
||||
|
||||
import serial
|
||||
import yaml
|
||||
|
||||
STATES = {
|
||||
0: "stopped",
|
||||
1: "awaiting_auth",
|
||||
2: "authorized",
|
||||
3: "provisioning",
|
||||
4: "provisioned",
|
||||
}
|
||||
ERRORS = {
|
||||
0: "none",
|
||||
1: "invalid_rpc",
|
||||
2: "unknown_rpc",
|
||||
3: "unable_to_connect",
|
||||
4: "not_authorized",
|
||||
0xFF: "unknown",
|
||||
}
|
||||
|
||||
|
||||
def frame(cmd: int, payload: bytes = b"") -> bytes:
|
||||
data = bytes([cmd, len(payload)]) + payload
|
||||
body = b"IMPROV" + bytes([1, 3, len(data)]) + data
|
||||
return body + bytes([sum(body) & 0xFF])
|
||||
|
||||
|
||||
BOOT_MARKER = (
|
||||
b"Running through setup()" # ESPHome logs it once per boot on every platform
|
||||
)
|
||||
|
||||
|
||||
def rpc_strings(data: bytes) -> bytes:
|
||||
return data[2 : 2 + data[1]]
|
||||
|
||||
|
||||
def strings(p: bytes) -> list[str]:
|
||||
"""Split length-prefixed strings; raise ValueError when a prefix runs past the end."""
|
||||
out = []
|
||||
while p:
|
||||
if 1 + p[0] > len(p):
|
||||
raise ValueError("string overruns the payload")
|
||||
out.append(p[1 : 1 + p[0]].decode(errors="replace"))
|
||||
p = p[1 + p[0] :]
|
||||
return out
|
||||
|
||||
|
||||
def load_wifi_secrets(path: str) -> tuple[str, str]:
|
||||
"""wifi_ssid and wifi_password from a secrets file; exits 2 (setup error) when it cannot be used."""
|
||||
try:
|
||||
with pathlib.Path(path).open(encoding="utf-8") as f:
|
||||
sec = yaml.safe_load(f)
|
||||
except (OSError, yaml.YAMLError) as exc:
|
||||
print(f"cannot read secrets file: {exc}", file=sys.stderr)
|
||||
sys.exit(2)
|
||||
try:
|
||||
raw = (sec["wifi_ssid"], sec["wifi_password"])
|
||||
except (KeyError, TypeError) as exc:
|
||||
print(f"secrets file lacks {exc}", file=sys.stderr)
|
||||
sys.exit(2)
|
||||
if not all(
|
||||
isinstance(x, (str, int, float)) and not isinstance(x, bool) for x in raw
|
||||
):
|
||||
print("wifi_ssid and wifi_password must be plain values", file=sys.stderr)
|
||||
sys.exit(2)
|
||||
return str(raw[0]), str(raw[1]) # YAML reads an unquoted number as int
|
||||
|
||||
|
||||
class Dev:
|
||||
def __init__(
|
||||
self, port: str, baud: int, out: str, keep_dtr: bool, ssid: str
|
||||
) -> None:
|
||||
self.ser = serial.Serial()
|
||||
self.ser.port, self.ser.baudrate, self.ser.timeout = port, baud, 0.05
|
||||
if not keep_dtr:
|
||||
self.ser.dtr = False
|
||||
self.ser.rts = False
|
||||
self.reopen(setup=True)
|
||||
self.buf = bytearray()
|
||||
try:
|
||||
self.log = pathlib.Path(out).open("wb") # noqa: SIM115
|
||||
except OSError as exc:
|
||||
print(f"cannot open output file: {exc}", file=sys.stderr)
|
||||
sys.exit(2)
|
||||
self.t0 = time.time()
|
||||
self.events: list[tuple[float, int, bytes, bool]] = []
|
||||
self.loglines = 0
|
||||
self.reopens = 0
|
||||
self.boots = 0
|
||||
self.tail = b""
|
||||
self.ssid = ssid
|
||||
|
||||
def reopen(self, setup: bool = False) -> None:
|
||||
# Native USB ports re-enumerate on reset; wait up to 10 s for them.
|
||||
err: Exception | None = None
|
||||
for _ in range(40):
|
||||
try:
|
||||
if self.ser.is_open:
|
||||
self.ser.close()
|
||||
self.ser.open()
|
||||
return
|
||||
except (serial.SerialException, OSError) as exc:
|
||||
err = exc
|
||||
time.sleep(0.25)
|
||||
print(
|
||||
f"port did not {'open' if setup else 'come back'}: {err}", file=sys.stderr
|
||||
)
|
||||
sys.exit(2 if setup else 1)
|
||||
|
||||
def pump(self, dur: float) -> None:
|
||||
end = time.time() + dur
|
||||
while time.time() < end:
|
||||
try:
|
||||
d = self.ser.read(4096)
|
||||
except serial.SerialException:
|
||||
# A dropped native USB port usually means the board reset; make that visible.
|
||||
self.reopens += 1
|
||||
print(
|
||||
f"{time.time() - self.t0:7.2f} PORT RESET (reopen {self.reopens})",
|
||||
flush=True,
|
||||
)
|
||||
self.reopen()
|
||||
continue
|
||||
if d:
|
||||
seen = self.tail + d
|
||||
self.boots += seen.count(BOOT_MARKER)
|
||||
self.tail = seen[-(len(BOOT_MARKER) - 1) :]
|
||||
self.log.write(d)
|
||||
self.log.flush()
|
||||
self.buf += d
|
||||
self.parse()
|
||||
|
||||
def parse(self) -> None:
|
||||
while True:
|
||||
i = self.buf.find(b"IMPROV")
|
||||
if i < 0:
|
||||
keep = max(0, len(self.buf) - 6)
|
||||
self.loglines += self.buf[:keep].count(b"\n")
|
||||
del self.buf[:keep]
|
||||
return
|
||||
self.loglines += self.buf[:i].count(b"\n")
|
||||
del self.buf[:i]
|
||||
if len(self.buf) < 9:
|
||||
return
|
||||
if self.buf[6] != 1: # not a version 1 header: "IMPROV" in log text
|
||||
del self.buf[:6]
|
||||
continue
|
||||
ln = self.buf[8]
|
||||
if len(self.buf) < 10 + ln:
|
||||
return
|
||||
body, ck = bytes(self.buf[: 9 + ln]), self.buf[9 + ln]
|
||||
del self.buf[: 10 + ln]
|
||||
typ, data = body[7], body[9:]
|
||||
ok = (sum(body) & 0xFF) == ck
|
||||
# A malformed frame is counted as bad, so the predicates never index past it.
|
||||
short = len(data) < {1: 1, 2: 1, 4: 2}.get(typ, 0)
|
||||
if typ == 4 and not short:
|
||||
try:
|
||||
# ESPHome sends one trailing byte after the strings (an unused checksum slot).
|
||||
short = data[1] > len(data) - 2
|
||||
strings(rpc_strings(data))
|
||||
except ValueError:
|
||||
short = True
|
||||
self.events.append((time.time() - self.t0, typ, data, ok and not short))
|
||||
self.show(typ, data, ok, short)
|
||||
|
||||
def show(self, typ: int, data: bytes, ok: bool, short: bool) -> None:
|
||||
t = f"{time.time() - self.t0:7.2f}"
|
||||
tag = "" if ok else " BADCHECKSUM"
|
||||
if short:
|
||||
print(f"{t} TYPE{typ} {data.hex()} MALFORMED{tag}")
|
||||
elif typ == 1:
|
||||
print(f"{t} STATE {STATES.get(data[0], data[0])}{tag}")
|
||||
elif typ == 2:
|
||||
print(f"{t} ERROR {ERRORS.get(data[0], data[0])}{tag}")
|
||||
elif typ == 4:
|
||||
strs = [
|
||||
"<ssid>" if x == self.ssid else x for x in strings(rpc_strings(data))
|
||||
]
|
||||
print(f"{t} RPC cmd={data[0]} len={data[1]} {strs}{tag}")
|
||||
else:
|
||||
print(f"{t} TYPE{typ} {data.hex()}{tag}")
|
||||
|
||||
def send(self, cmd: int, payload: bytes = b"", wait: float = 2.0) -> None:
|
||||
self.ser.write(frame(cmd, payload))
|
||||
self.ser.flush()
|
||||
self.pump(wait)
|
||||
|
||||
def wait_for(self, pred, timeout: float, start: int) -> tuple | None:
|
||||
end = time.time() + timeout
|
||||
while time.time() < end:
|
||||
self.pump(0.2)
|
||||
for e in self.events[start:]:
|
||||
if pred(e):
|
||||
return e
|
||||
return None
|
||||
|
||||
|
||||
def ask(
|
||||
d: Dev, label: str, cmd: int, pred, timeout: float = 1.5, payload: bytes = b""
|
||||
) -> bool:
|
||||
"""Send one request and require a reply matching pred; any other nonzero ERROR frame fails it."""
|
||||
print(f"== {label}")
|
||||
start = len(d.events) # before sending, so an immediate reply counts
|
||||
t = time.time()
|
||||
d.send(cmd, payload, wait=0)
|
||||
e = d.wait_for(pred, timeout, start)
|
||||
print(
|
||||
f"reply after {time.time() - t:.1f}s"
|
||||
if e
|
||||
else f"NO reply within {timeout:.0f}s"
|
||||
)
|
||||
errs = [
|
||||
x for x in d.events[start:] if x[1] == 2 and x[3] and x[2][0] and not pred(x)
|
||||
]
|
||||
if errs:
|
||||
print(f"unexpected errors: {[ERRORS.get(x[2][0], x[2][0]) for x in errs]}")
|
||||
return e is not None and not errs
|
||||
|
||||
|
||||
def rpc(cmd: int):
|
||||
return lambda e: e[1] == 4 and e[3] and e[2][0] == cmd
|
||||
|
||||
|
||||
def state(e: tuple) -> bool:
|
||||
return e[1] == 1 and e[3]
|
||||
|
||||
|
||||
def main() -> None:
|
||||
a = argparse.ArgumentParser()
|
||||
a.add_argument("port")
|
||||
a.add_argument("out")
|
||||
a.add_argument("--baud", type=int, default=115200)
|
||||
a.add_argument(
|
||||
"--keep-dtr",
|
||||
action="store_true",
|
||||
help="leave DTR asserted (Pico 2 W CDC sends nothing without)",
|
||||
)
|
||||
a.add_argument("--secrets", required=True)
|
||||
a.add_argument("--settle", type=float, default=3)
|
||||
a.add_argument("--skip-bad", action="store_true")
|
||||
a.add_argument(
|
||||
"--allow-reset",
|
||||
action="store_true",
|
||||
help="a port reset or a reboot in the log does not fail the run",
|
||||
)
|
||||
o = a.parse_args()
|
||||
ssid, pw = load_wifi_secrets(o.secrets)
|
||||
s, w = ssid.encode(), pw.encode()
|
||||
print(f"password length {len(w)} bytes")
|
||||
d = Dev(o.port, o.baud, o.out, o.keep_dtr, ssid)
|
||||
d.pump(o.settle)
|
||||
boots_at_start = d.boots
|
||||
before = d.loglines
|
||||
print("== stray bytes")
|
||||
j = len(d.events)
|
||||
junk = bytes(
|
||||
random.choice([b for b in range(256) if b != 0x49]) for _ in range(300)
|
||||
)
|
||||
d.ser.write(junk)
|
||||
d.ser.flush()
|
||||
d.pump(1.0)
|
||||
# Stray bytes must be ignored silently; the state reply below shows the parser recovered.
|
||||
ok = not any(e[1] == 2 and e[3] and e[2][0] for e in d.events[j:])
|
||||
# A saved network skips provisioning: the board must start unprovisioned.
|
||||
ok &= ask(d, "state", 2, lambda e: state(e) and e[2][0] != 4)
|
||||
if any(state(e) and e[2][0] == 4 for e in d.events[j:]):
|
||||
# The rest of the flow means nothing on a provisioned board; stop before re-provisioning it.
|
||||
print(
|
||||
"board is already provisioned: erase the flash first (a new config name keeps the saved network)"
|
||||
)
|
||||
print("FAIL")
|
||||
sys.exit(1)
|
||||
ok &= ask(d, "info", 3, rpc(3))
|
||||
ok &= ask(d, "netstate", 7, rpc(7))
|
||||
# The scan sends one reply per network and ends with an empty one.
|
||||
ok &= ask(d, "scan", 4, lambda e: rpc(4)(e) and e[2][1] == 0, timeout=10)
|
||||
seen = any(e[1] == 4 and e[3] and e[2][0] == 4 and s in e[2] for e in d.events)
|
||||
print(f"target network in scan: {seen}")
|
||||
creds = bytes([len(s)]) + s
|
||||
if not o.skip_bad:
|
||||
bad_pw = b"wrong-password-0123456789"
|
||||
ok &= ask(
|
||||
d,
|
||||
"provision bad password",
|
||||
1,
|
||||
lambda e: e[1] == 2 and e[3] and e[2][0] == 3,
|
||||
timeout=60,
|
||||
payload=creds + bytes([len(bad_pw)]) + bad_pw,
|
||||
)
|
||||
d.pump(2)
|
||||
# common.yaml sets next_url, so the provisioned reply must carry a URL.
|
||||
ok &= ask(
|
||||
d,
|
||||
"provision good",
|
||||
1,
|
||||
lambda e: (
|
||||
rpc(1)(e) and any(x.startswith("http") for x in strings(rpc_strings(e[2])))
|
||||
),
|
||||
timeout=60,
|
||||
payload=creds + bytes([len(w)]) + w,
|
||||
)
|
||||
d.pump(3)
|
||||
ok &= ask(d, "state is provisioned", 2, lambda e: state(e) and e[2][0] == 4)
|
||||
ok &= ask(d, "netstate", 7, rpc(7))
|
||||
d.pump(2)
|
||||
bad = sum(1 for e in d.events if not e[3])
|
||||
# Errors outside an ask() window, boot included: only the bad password case may report one.
|
||||
errors = sum(1 for e in d.events if e[1] == 2 and e[3] and e[2][0])
|
||||
if errors > (0 if o.skip_bad else 1):
|
||||
print(f"unexpected error frames: {errors}")
|
||||
ok = False
|
||||
reboots = d.boots - boots_at_start
|
||||
if (d.reopens or reboots) and not o.allow_reset:
|
||||
ok = False
|
||||
print(
|
||||
f"frames={len(d.events)} badframes={bad} reopens={d.reopens} reboots={reboots} loglines={d.loglines} "
|
||||
f"(before stray {before})"
|
||||
)
|
||||
print("PASS" if ok and not bad else "FAIL")
|
||||
sys.exit(0 if ok and not bad else 1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+23
@@ -0,0 +1,23 @@
|
||||
#!/bin/bash
|
||||
# run.sh NAME [improvcli.py args...]: build NAME.yaml (next to this script, or a path) from TREE, erase the flash so no
|
||||
# credentials are saved, flash it over serial and run improvcli.py on PORT. Output lands in out-NAME/.
|
||||
# env: TREE (checkout under test), PORT, PY (checkout python), SECRETS (secrets.yaml with wifi_ssid, wifi_password),
|
||||
# BUILD_LOCK (optional); builds go through ../pio_build.sh with a private PlatformIO directory
|
||||
# ESP chips only (esptool erase). On LibreTiny or RP2040 erase and flash with that platform's tools, then run
|
||||
# improvcli.py directly. Exit status is improvcli.py's: 0 pass, 1 fail, 2 setup failed.
|
||||
set -o pipefail
|
||||
D=$(cd "$(dirname "$0")" && pwd); N=${1:?name}; shift
|
||||
W=${TREE:?set TREE}; PORT=${PORT:?set PORT}; S=${SECRETS:?set SECRETS}; PY=${PY:-$W/venv/bin/python}
|
||||
Y=$N; [ -f "$Y" ] || Y=$D/$N.yaml; Y=$(cd "$(dirname "$Y")" && pwd)/$(basename "$Y"); N=$(basename "$Y" .yaml)
|
||||
O=$D/out-$N; mkdir -p "$O"
|
||||
REV=$(git -C "$W" rev-parse --short=10 HEAD) || { echo "TREE is not a git checkout: $W"; exit 2; }
|
||||
echo "== $N $REV"
|
||||
# the erase runs while the firmware compiles
|
||||
$PY -m esptool --port "$PORT" erase_flash > "$O/erase.log" 2>&1 &
|
||||
ERASE=$!
|
||||
"$(dirname "$D")/pio_build.sh" compile "$N" "$Y" || { wait $ERASE; exit 2; }
|
||||
wait $ERASE || { echo "$N erase failed"; exit 2; }
|
||||
"$(dirname "$D")/pio_build.sh" upload "$N" "$Y" "$PORT" || exit 2
|
||||
sleep 1
|
||||
rm -f "$O/raw.bin"
|
||||
$PY "$D/improvcli.py" "$PORT" "$O/raw.bin" --secrets "$S" "$@" 2>&1 | tee "$O/improv.txt"
|
||||
@@ -0,0 +1,20 @@
|
||||
# XIAO nRF54LM20A with every nPM1300 entity: dumps the registers and switch states 8 s after boot, then runs the
|
||||
# toggles script. Name set with -s name.
|
||||
esphome:
|
||||
name: ${name}
|
||||
on_boot:
|
||||
- priority: -100
|
||||
then:
|
||||
- delay: 8s
|
||||
- script.execute: regdump
|
||||
- script.execute: swdump
|
||||
- delay: 2s
|
||||
- script.execute: toggles
|
||||
nrf52:
|
||||
board: xiao_nrf54lm20a
|
||||
logger:
|
||||
level: DEBUG
|
||||
hardware_uart: UART0
|
||||
packages:
|
||||
regdump: !include regdump.yaml
|
||||
common: !include npmcommon.yaml
|
||||
@@ -0,0 +1,179 @@
|
||||
# nPM1300 hub with every entity, a 500 mA VBUS limit, the charger settings, BUCK2 at 3.3 V and LDO1 as a 3.3 V LDO,
|
||||
# state log lines from on_value and on_state lambdas, a register and switch dump every 60 s, and a toggles script
|
||||
# (charger off and on, LDO1 off and on). Never switch BUCK2 off on the XIAO nRF54LM20A: it powers the board.
|
||||
i2c:
|
||||
- id: pmic_bus
|
||||
sda: P1.18
|
||||
scl: P1.17
|
||||
npm1300:
|
||||
id: pmic
|
||||
i2c_id: pmic_bus
|
||||
update_interval: 5s
|
||||
vbus_current_limit: 500mA
|
||||
thermistor_resistance: 10kOhm
|
||||
thermistor_beta: 3380
|
||||
charger:
|
||||
charge_current: 150mA
|
||||
termination_voltage: 4.2V
|
||||
warm_termination_voltage: 4.0V
|
||||
termination_current: 20%
|
||||
trickle_voltage: 2.5V
|
||||
discharge_current_limit: 1000mA
|
||||
recharge: true
|
||||
buck2:
|
||||
voltage: 3.3V
|
||||
ldo1:
|
||||
voltage: 3.3V
|
||||
mode: ldo
|
||||
enabled: true
|
||||
ldo2:
|
||||
mode: load_switch
|
||||
enabled: false
|
||||
globals:
|
||||
- id: txt_count
|
||||
type: int
|
||||
initial_value: '0'
|
||||
sensor:
|
||||
- platform: npm1300
|
||||
battery_voltage:
|
||||
name: VBAT
|
||||
on_value:
|
||||
- lambda: 'ESP_LOGI("st", "SENS VBAT=%.4f", x);'
|
||||
battery_current:
|
||||
name: IBAT
|
||||
on_value:
|
||||
- lambda: 'ESP_LOGI("st", "SENS IBAT=%.4f", x);'
|
||||
battery_temperature:
|
||||
name: TBAT
|
||||
on_value:
|
||||
- lambda: 'ESP_LOGI("st", "SENS TBAT=%.4f", x);'
|
||||
die_temperature:
|
||||
name: TDIE
|
||||
on_value:
|
||||
- lambda: 'ESP_LOGI("st", "SENS TDIE=%.4f", x);'
|
||||
system_voltage:
|
||||
name: VSYS
|
||||
on_value:
|
||||
- lambda: 'ESP_LOGI("st", "SENS VSYS=%.4f", x);'
|
||||
vbus_voltage:
|
||||
name: VBUS
|
||||
on_value:
|
||||
- lambda: 'ESP_LOGI("st", "SENS VBUS=%.4f", x);'
|
||||
vbus_current_limit:
|
||||
name: ILIM
|
||||
on_value:
|
||||
- lambda: 'ESP_LOGI("st", "SENS ILIM=%.4f", x);'
|
||||
binary_sensor:
|
||||
- platform: npm1300
|
||||
vbus_present:
|
||||
name: VBUS Present
|
||||
trigger_on_initial_state: true
|
||||
on_state:
|
||||
- lambda: 'ESP_LOGI("st", "BIN vbus_present=%s", x ? "ON" : "OFF");'
|
||||
vbus_current_limit_active:
|
||||
name: ILIM Active
|
||||
trigger_on_initial_state: true
|
||||
on_state:
|
||||
- lambda: 'ESP_LOGI("st", "BIN vbus_current_limit_active=%s", x ? "ON" : "OFF");'
|
||||
charging:
|
||||
name: Charging
|
||||
trigger_on_initial_state: true
|
||||
on_state:
|
||||
- lambda: 'ESP_LOGI("st", "BIN charging=%s", x ? "ON" : "OFF");'
|
||||
charge_complete:
|
||||
name: Charge Complete
|
||||
trigger_on_initial_state: true
|
||||
on_state:
|
||||
- lambda: 'ESP_LOGI("st", "BIN charge_complete=%s", x ? "ON" : "OFF");'
|
||||
battery_detected:
|
||||
name: Battery Detected
|
||||
trigger_on_initial_state: true
|
||||
on_state:
|
||||
- lambda: 'ESP_LOGI("st", "BIN battery_detected=%s", x ? "ON" : "OFF");'
|
||||
charger_error:
|
||||
name: Charger Error
|
||||
trigger_on_initial_state: true
|
||||
on_state:
|
||||
- lambda: 'ESP_LOGI("st", "BIN charger_error=%s", x ? "ON" : "OFF");'
|
||||
text_sensor:
|
||||
- platform: npm1300
|
||||
charger_status:
|
||||
name: Charger Status
|
||||
on_value:
|
||||
- lambda: |-
|
||||
id(txt_count) += 1;
|
||||
ESP_LOGI("st", "TXT #%d charger_status='%s'", id(txt_count), x.c_str());
|
||||
switch:
|
||||
- platform: npm1300
|
||||
charger:
|
||||
id: sw_charger
|
||||
name: Charger
|
||||
restore_mode: DISABLED
|
||||
on_state:
|
||||
- lambda: 'ESP_LOGI("st", "SW charger=%s", x ? "ON" : "OFF");'
|
||||
buck1:
|
||||
id: sw_buck1
|
||||
name: BUCK1
|
||||
restore_mode: DISABLED
|
||||
on_state:
|
||||
- lambda: 'ESP_LOGI("st", "SW buck1=%s", x ? "ON" : "OFF");'
|
||||
buck2:
|
||||
id: sw_buck2
|
||||
name: BUCK2
|
||||
restore_mode: DISABLED
|
||||
on_state:
|
||||
- lambda: 'ESP_LOGI("st", "SW buck2=%s", x ? "ON" : "OFF");'
|
||||
ldo1:
|
||||
id: sw_ldo1
|
||||
name: LDO1
|
||||
restore_mode: DISABLED
|
||||
on_state:
|
||||
- lambda: 'ESP_LOGI("st", "SW ldo1=%s", x ? "ON" : "OFF");'
|
||||
ldo2:
|
||||
id: sw_ldo2
|
||||
name: LDO2
|
||||
restore_mode: DISABLED
|
||||
on_state:
|
||||
- lambda: 'ESP_LOGI("st", "SW ldo2=%s", x ? "ON" : "OFF");'
|
||||
script:
|
||||
- id: swdump
|
||||
then:
|
||||
- lambda: |-
|
||||
ESP_LOGI("st", "SWSTATE charger=%d buck1=%d buck2=%d ldo1=%d ldo2=%d txt_count=%d", id(sw_charger).state,
|
||||
id(sw_buck1).state, id(sw_buck2).state, id(sw_ldo1).state, id(sw_ldo2).state, id(txt_count));
|
||||
- id: toggles
|
||||
then:
|
||||
- logger.log: "STEP charger off"
|
||||
- switch.turn_off: sw_charger
|
||||
- delay: 1s
|
||||
- script.execute: regdump
|
||||
- component.update: pmic
|
||||
- delay: 1s
|
||||
- script.execute: swdump
|
||||
- logger.log: "STEP charger on"
|
||||
- switch.turn_on: sw_charger
|
||||
- delay: 1s
|
||||
- script.execute: regdump
|
||||
- component.update: pmic
|
||||
- delay: 1s
|
||||
- script.execute: swdump
|
||||
- logger.log: "STEP ldo1 off"
|
||||
- switch.turn_off: sw_ldo1
|
||||
- delay: 1s
|
||||
- script.execute: regdump
|
||||
- component.update: pmic
|
||||
- delay: 1s
|
||||
- script.execute: swdump
|
||||
- logger.log: "STEP ldo1 on"
|
||||
- switch.turn_on: sw_ldo1
|
||||
- delay: 1s
|
||||
- script.execute: regdump
|
||||
- component.update: pmic
|
||||
- delay: 1s
|
||||
- script.execute: swdump
|
||||
- logger.log: "STEP done"
|
||||
interval:
|
||||
- interval: 60s
|
||||
then:
|
||||
- script.execute: regdump
|
||||
- script.execute: swdump
|
||||
@@ -0,0 +1,38 @@
|
||||
# XIAO nRF54LM20A probe build: the hub with no regulator or charger settings, a bus scan and a register dump every
|
||||
# 20 s, to see the power-on state before writing anything. Name set with -s name.
|
||||
esphome:
|
||||
name: ${name}
|
||||
on_boot:
|
||||
- priority: -100
|
||||
then:
|
||||
- delay: 3s
|
||||
- script.execute: regdump
|
||||
nrf52:
|
||||
board: xiao_nrf54lm20a
|
||||
logger:
|
||||
level: DEBUG
|
||||
hardware_uart: UART0
|
||||
packages:
|
||||
regdump: !include regdump.yaml
|
||||
i2c:
|
||||
- id: pmic_bus
|
||||
sda: P1.18
|
||||
scl: P1.17
|
||||
scan: true
|
||||
npm1300:
|
||||
id: pmic
|
||||
i2c_id: pmic_bus
|
||||
sensor:
|
||||
- platform: npm1300
|
||||
system_voltage:
|
||||
name: VSYS
|
||||
vbus_voltage:
|
||||
name: VBUS
|
||||
battery_voltage:
|
||||
name: VBAT
|
||||
die_temperature:
|
||||
name: Die
|
||||
interval:
|
||||
- interval: 20s
|
||||
then:
|
||||
- script.execute: regdump
|
||||
@@ -0,0 +1,16 @@
|
||||
# Register dump of the nPM1300 with id(pmic).read_register16; "!" marks a failed read.
|
||||
script:
|
||||
- id: regdump
|
||||
then:
|
||||
- lambda: |-
|
||||
static const uint16_t REGS[] = {0x0201, 0x0202, 0x0207, 0x0304, 0x0308, 0x0309, 0x030C, 0x0334, 0x0336,
|
||||
0x0408, 0x040A, 0x040F, 0x0410, 0x0411, 0x0434, 0x0804, 0x0807, 0x0808,
|
||||
0x0809, 0x080C, 0x080D, 0x050A};
|
||||
char buf[400];
|
||||
size_t pos = 0;
|
||||
for (uint16_t r : REGS) {
|
||||
uint8_t v = 0;
|
||||
auto err = id(pmic).read_register16(r, &v, 1);
|
||||
pos += snprintf(buf + pos, sizeof(buf) - pos, " %04X=%s%02X", r, err == i2c::ERROR_OK ? "" : "!", v);
|
||||
}
|
||||
ESP_LOGI("regs", "REGS%s", buf);
|
||||
+28
@@ -0,0 +1,28 @@
|
||||
#!/bin/bash
|
||||
# runone.sh NAME CONFIG PORT [SECS]: flash CONFIG as NAME with `esphome run --no-logs` (pyOCD through the XIAO's
|
||||
# CMSIS-DAP probe) from TREE while a serial capture of SECS (default 240) stays open on the probe's PORT. The first
|
||||
# seconds of the capture are the old firmware; cut at "Log initialized". A failed compile, flash or timeout, or no
|
||||
# "compiled on" line with this build's time in the capture, exits 1. env: TREE, PY, PIO_CORE
|
||||
D=$(cd "$(dirname "$0")" && pwd); S=$(dirname "$D"); N=${1:?name}; C=${2:?config}; P=${3:?port}; SECS=${4:-240}
|
||||
T=${TREE:?set TREE}; PY=${PY:-$T/venv/bin/python}
|
||||
export PLATFORMIO_CORE_DIR=${PIO_CORE:-$D/pio} PYTHONPATH=$T PYTHONUNBUFFERED=1
|
||||
$PY "$S/serial_capture.py" "$P" "$SECS" "$D/$N-cap.txt" > /dev/null 2> "$D/$N-cap.err" &
|
||||
CAP=$!
|
||||
sleep 2
|
||||
if ! (cd "$T" && timeout 300 $PY -m esphome -s name "$N" run --no-logs "$D/$C" --device "$P") > "$D/$N-run.log" 2>&1
|
||||
then
|
||||
# The capture holds the old firmware only; stop it so it is not read as a run of the new build.
|
||||
tail -1 "$D/$N-run.log"; kill $CAP 2>/dev/null; wait $CAP 2>/dev/null
|
||||
echo "FAIL: $N run failed (see $D/$N-run.log)"; exit 1
|
||||
fi
|
||||
tail -1 "$D/$N-run.log"
|
||||
# A capture that ended during the flash holds only the old firmware
|
||||
kill -0 $CAP 2>/dev/null || { echo "FAIL: the capture ended before the flash finished (see $D/$N-cap.err; if empty, raise SECS)"; exit 1; }
|
||||
wait $CAP
|
||||
# a flash that returned 0 but never booted the new image leaves only the old firmware in the capture, so look for
|
||||
# this build's own compile time, which every boot logs
|
||||
BI=$D/.esphome/build/$N/src/esphome/core/build_info_data.cpp
|
||||
BT=$(sed -n 's/.*ESPHOME_BUILD_TIME_STR\[\][^"]*"\(.*\)";.*/\1/p' "$BI" 2>/dev/null | head -1)
|
||||
[ -n "$BT" ] || { echo "FAIL: no build time in $BI"; exit 1; }
|
||||
grep -a -q -F "compiled on $BT" "$D/$N-cap.txt" ||
|
||||
{ echo "FAIL: no boot of the build from $BT in $D/$N-cap.txt"; exit 1; }
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
#!/bin/bash
|
||||
# pio_build.sh compile|upload NAME YAML [DEVICE] [esphome options...]: esphome compile or upload of YAML with
|
||||
# `-s name NAME`, built from TREE with a private PlatformIO core directory. Logs to <yaml dir>/NAME-<action>.log and
|
||||
# prints the RAM and Flash lines (compile) or the upload result. Exits 1 on a failure or when esphome would not import
|
||||
# from TREE. A config that sets `name: ${name}` builds one copy per NAME, so a PR and a dev build of the same file
|
||||
# never share a build directory.
|
||||
# env: TREE (checkout under test), PY (default $TREE/venv/bin/python), PIO_CORE (default <yaml dir>/pio),
|
||||
# BUILD_LOCK (optional command prefix that serialises builds on a shared machine; compile only)
|
||||
A=${1:?compile|upload}; N=${2:?name}; Y=${3:?yaml}; shift 3
|
||||
T=${TREE:?set TREE}; PY=${PY:-$T/venv/bin/python}
|
||||
Y=$(cd "$(dirname "$Y")" && pwd)/$(basename "$Y"); D=$(dirname "$Y")
|
||||
export PLATFORMIO_CORE_DIR=${PIO_CORE:-$D/pio} PYTHONPATH=$T PYTHONUNBUFFERED=1
|
||||
L=$D/$N-$A.log
|
||||
F=$(cd "$T" && $PY -c 'import esphome, os; print(os.path.dirname(esphome.__file__))')
|
||||
[ "$F" = "$(cd "$T" && pwd)/esphome" ] || { echo "esphome imports from $F, not $T"; exit 1; }
|
||||
echo "esphome from $F" > "$L"
|
||||
case $A in
|
||||
compile)
|
||||
(cd "$T" && ${BUILD_LOCK:-} timeout 1500 $PY -m esphome -s name "$N" "$@" compile "$Y") >> "$L" 2>&1
|
||||
RC=$?; grep -a -E "^(RAM|Flash):" "$L"; [ $RC = 0 ] || { echo "$N compile failed (see $L)"; exit 1; } ;;
|
||||
upload)
|
||||
DEV=${1:?device}; shift
|
||||
(cd "$T" && timeout 600 $PY -m esphome -s name "$N" "$@" upload "$Y" --device "$DEV") >> "$L" 2>&1 ||
|
||||
{ echo "$N upload failed (see $L)"; tail -3 "$L"; exit 1; }
|
||||
grep -a -E "OTA successful|Successfully uploaded" "$L" | tail -1 ;;
|
||||
*) echo "unknown action $A"; exit 1 ;;
|
||||
esac
|
||||
@@ -1,8 +1,16 @@
|
||||
# Shared by pa.yaml and pc.yaml: Pico 2 W, pioscope.hpp, an ALIVE line every 2 s and the s_ws_p0 strip on pin 2.
|
||||
# Shared by pa.yaml and pc.yaml: Pico 2 W, pioscope.hpp, PIO1 memory cleared at boot, an ALIVE line every 2 s and
|
||||
# the s_ws_p0 strip on pin 2.
|
||||
esphome:
|
||||
name: ${name}
|
||||
includes:
|
||||
- pioscope.hpp
|
||||
on_boot:
|
||||
# PIO instruction memory survives a reflash; clear PIO1 so a program left by the previous firmware cannot hide a
|
||||
# missing pio_add_program
|
||||
- priority: 1000
|
||||
then:
|
||||
- lambda: |-
|
||||
for (int i = 0; i < 32; i++) pio1->instr_mem[i] = 0;
|
||||
|
||||
rp2040:
|
||||
board: rpipico2w
|
||||
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
#!/bin/bash
|
||||
# resolve.sh NAME [TRIES]: print the address of NAME.local once it resolves and answers a ping, retrying every 3 s
|
||||
# (default 30 tries). Exits 1 when it never does.
|
||||
for _ in $(seq 1 "${2:-30}"); do
|
||||
IP=$(python3 -c 'import socket, sys; print(socket.gethostbyname(sys.argv[1]))' "$1.local" 2>/dev/null) &&
|
||||
ping -c 1 "$IP" > /dev/null 2>&1 && { echo "$IP"; exit 0; }
|
||||
sleep 3
|
||||
done
|
||||
echo "$1.local did not resolve or answer" >&2
|
||||
exit 1
|
||||
@@ -0,0 +1,19 @@
|
||||
# RP2 scheduler lock under IRQ and lwIP load (#22688)
|
||||
|
||||
On RP2, lwIP callbacks and pico-sdk timers can call into the scheduler from IRQ context while the main loop is inside
|
||||
it. `components/irq_sched_stress/` reproduces that on purpose: a 300 us pico-sdk repeating timer calls `defer()` and
|
||||
`set_timeout()` while the main loop does the same. Judge it by counts: every defer runs, and exactly 10 of 400 named
|
||||
timeouts on 10 shared names run. RP2 is `ESPHOME_THREAD_SINGLE`, so `defer()` order is not FIFO on any build; the
|
||||
out of order count is informational. Keep `esphome: debug_scheduler:` off, it logs from the IRQ.
|
||||
|
||||
- `stress.yaml`: the component, `run_test`, `run_defer` and `run_cancel` API actions, REST entities for the churn
|
||||
loops and a 16 ms interval that logs its gaps. `race.yaml` ports the removed item race integration fixture.
|
||||
`picow.yaml` and `evb.yaml` add them to the `../rp2_web_ble/` role configs (encrypted API, web_server, diagnostics);
|
||||
put `secrets.yaml` here or next to the role configs.
|
||||
- `flow.sh NAME CONFIG HOST [SERIAL_PORT]`: upload, then the actions, connstress, REST churn and both together; ends
|
||||
with PASS or FAIL. `svcrun.py HOST ACTION DONE_REGEX TIMEOUT` runs one action and prints its result lines.
|
||||
- `restchurn.sh HOST SECS OUT`: 4 parallel REST POST loops. `looptime.sh NAME HOST SECS`: 16 ms interval gaps and
|
||||
50 ms re-arms with the API and page loads running, to compare the cost of the lock between builds.
|
||||
|
||||
Build both heads with `../pio_build.sh` under different names. Dev before #22688 failed the defer count on the Pico W;
|
||||
the PR passed every action.
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
"""Test only: a pico-sdk repeating timer calls defer() and set_timeout() from IRQ context while the main loop
|
||||
does the same, like the host scheduler fixtures do from std::thread workers (RP2040/RP2350 only)."""
|
||||
|
||||
import esphome.codegen as cg
|
||||
import esphome.config_validation as cv
|
||||
from esphome.const import CONF_ID
|
||||
from esphome.types import ConfigType
|
||||
|
||||
DOMAIN = "irq_sched_stress"
|
||||
irq_sched_stress_ns = cg.esphome_ns.namespace("irq_sched_stress")
|
||||
IrqSchedStress = irq_sched_stress_ns.class_("IrqSchedStress", cg.Component)
|
||||
|
||||
CONFIG_SCHEMA = cv.Schema({cv.GenerateID(): cv.declare_id(IrqSchedStress)}).extend(
|
||||
cv.COMPONENT_SCHEMA
|
||||
)
|
||||
|
||||
|
||||
async def to_code(config: ConfigType) -> None:
|
||||
var = cg.new_Pvariable(config[CONF_ID])
|
||||
await cg.register_component(var, config)
|
||||
+124
@@ -0,0 +1,124 @@
|
||||
#pragma once
|
||||
// Test only. run_defer(): N defer() calls from a 300 us repeating timer IRQ plus N from the main loop; every one must
|
||||
// run. run_cancel(): NC set_timeout() calls on 10 shared names from each side inside one 150 ms window; exactly 10
|
||||
// must run, the rest are implicit cancellations. Results are logged as "DEFER RESULT" and "CANCEL RESULT".
|
||||
// Keep esphome: debug_scheduler off, it logs from the IRQ.
|
||||
#include "esphome/core/component.h"
|
||||
#include "esphome/core/hal.h"
|
||||
#include "esphome/core/log.h"
|
||||
#include <pico/time.h>
|
||||
|
||||
namespace esphome::irq_sched_stress {
|
||||
|
||||
class IrqSchedStress : public Component {
|
||||
public:
|
||||
void loop() override {
|
||||
if (this->mode_ == IDLE || this->finishing_)
|
||||
return;
|
||||
// Issue the main loop share in one tight burst while the IRQ issues its share, so every operation lands inside
|
||||
// the 150 ms timeout window and the IRQ interleaves with the main loop inside the scheduler.
|
||||
// The time limit keeps a stalled timer IRQ from wedging the main loop; the result then reports the shortfall.
|
||||
uint32_t lim = this->mode_ == DEFER ? N : NC;
|
||||
while ((this->main_issued_ < lim || this->irq_issued_ < lim) && millis() - this->start_ms_ < ISSUE_LIMIT_MS) {
|
||||
if (this->main_issued_ < lim)
|
||||
this->step_(false);
|
||||
delayMicroseconds(60);
|
||||
}
|
||||
cancel_repeating_timer(&this->timer_);
|
||||
this->issue_ms_ = millis() - this->start_ms_;
|
||||
this->finishing_ = true;
|
||||
this->set_timeout(1000, [this]() { this->finish_(); });
|
||||
}
|
||||
|
||||
void run_defer() { this->start_(DEFER); }
|
||||
void run_cancel() { this->start_(CANCEL); }
|
||||
|
||||
protected:
|
||||
enum Mode : uint8_t { IDLE, DEFER, CANCEL };
|
||||
static constexpr uint32_t N = 500; // per source, defer mode
|
||||
static constexpr uint32_t NC = 200; // per source, cancel mode
|
||||
static constexpr uint32_t ISSUE_LIMIT_MS = 2000;
|
||||
static constexpr const char *NAMES[10] = {"shared_0", "shared_1", "shared_2", "shared_3", "shared_4",
|
||||
"shared_5", "shared_6", "shared_7", "shared_8", "shared_9"};
|
||||
|
||||
static bool irq_tick_(repeating_timer_t *t) {
|
||||
static_cast<IrqSchedStress *>(t->user_data)->step_(true);
|
||||
return true;
|
||||
}
|
||||
|
||||
void start_(Mode mode) {
|
||||
if (this->mode_ != IDLE) {
|
||||
// a request during a running test is dropped; say so instead of leaving the caller to time out
|
||||
ESP_LOGW("irq_sched_stress", "%s RESULT FAIL busy", mode == DEFER ? "DEFER" : "CANCEL");
|
||||
return;
|
||||
}
|
||||
this->irq_issued_ = this->main_issued_ = this->irq_exec_ = this->main_exec_ = 0;
|
||||
this->fifo_viol_ = this->cancel_exec_ = 0;
|
||||
this->irq_last_ = this->main_last_ = -1;
|
||||
this->finishing_ = false;
|
||||
this->start_ms_ = millis();
|
||||
ESP_LOGI("irq_sched_stress", "%s test start", mode == DEFER ? "defer" : "cancel");
|
||||
this->mode_ = mode;
|
||||
if (!add_repeating_timer_us(-300, &IrqSchedStress::irq_tick_, this, &this->timer_)) {
|
||||
this->mode_ = IDLE;
|
||||
ESP_LOGE("irq_sched_stress", "%s RESULT FAIL timer not started", mode == DEFER ? "DEFER" : "CANCEL");
|
||||
}
|
||||
}
|
||||
|
||||
// One operation from the IRQ (irq true) or the main loop.
|
||||
void step_(bool irq) {
|
||||
volatile uint32_t &issued = irq ? this->irq_issued_ : this->main_issued_;
|
||||
if (this->mode_ == DEFER && issued < N) {
|
||||
int32_t id = issued;
|
||||
issued = issued + 1;
|
||||
if (irq) {
|
||||
this->defer([this, id]() { this->ran_(this->irq_last_, this->irq_exec_, id); });
|
||||
} else {
|
||||
this->defer([this, id]() { this->ran_(this->main_last_, this->main_exec_, id); });
|
||||
}
|
||||
} else if (this->mode_ == CANCEL && issued < NC) {
|
||||
uint32_t i = issued;
|
||||
issued = issued + 1;
|
||||
this->set_timeout(NAMES[i % 10], 150, [this]() { this->cancel_exec_ = this->cancel_exec_ + 1; });
|
||||
}
|
||||
}
|
||||
|
||||
void ran_(volatile int32_t &last, volatile uint32_t &exec, int32_t id) {
|
||||
if (id != last + 1)
|
||||
this->fifo_viol_ = this->fifo_viol_ + 1;
|
||||
last = id;
|
||||
exec = exec + 1;
|
||||
}
|
||||
|
||||
void finish_() {
|
||||
unsigned total = this->irq_issued_ + this->main_issued_;
|
||||
if (this->mode_ == DEFER) {
|
||||
bool ok = this->irq_exec_ == N && this->main_exec_ == N;
|
||||
ESP_LOGI("irq_sched_stress", "DEFER RESULT %s irq_exec=%u/%u main_exec=%u/%u out_of_order=%u issued_in=%u ms",
|
||||
ok ? "PASS" : "FAIL", (unsigned) this->irq_exec_, (unsigned) N, (unsigned) this->main_exec_,
|
||||
(unsigned) N, (unsigned) this->fifo_viol_, (unsigned) this->issue_ms_);
|
||||
} else {
|
||||
// Without every set_timeout() issued from both sides the race never ran; 10 executions alone prove nothing.
|
||||
bool ok = this->cancel_exec_ == 10 && this->irq_issued_ == NC && this->main_issued_ == NC;
|
||||
ESP_LOGI("irq_sched_stress", "CANCEL RESULT %s scheduled=%u executed=%u (expect 10) issued_in=%u ms",
|
||||
ok ? "PASS" : "FAIL", total, (unsigned) this->cancel_exec_, (unsigned) this->issue_ms_);
|
||||
}
|
||||
this->mode_ = IDLE;
|
||||
}
|
||||
|
||||
repeating_timer_t timer_{};
|
||||
volatile Mode mode_{IDLE};
|
||||
volatile uint32_t irq_issued_{0};
|
||||
volatile uint32_t main_issued_{0};
|
||||
volatile uint32_t irq_exec_{0};
|
||||
volatile uint32_t main_exec_{0};
|
||||
volatile int32_t irq_last_{-1};
|
||||
volatile int32_t main_last_{-1};
|
||||
volatile uint32_t fifo_viol_{0};
|
||||
volatile uint32_t cancel_exec_{0};
|
||||
uint32_t start_ms_{0};
|
||||
uint32_t issue_ms_{0};
|
||||
bool finishing_{false};
|
||||
};
|
||||
|
||||
} // namespace esphome::irq_sched_stress
|
||||
@@ -0,0 +1,5 @@
|
||||
# W5100S-EVB-Pico on wired Ethernet with the scheduler lock packages (name set with -s name).
|
||||
packages:
|
||||
board: !include ../rp2_web_ble/evb.yaml
|
||||
stress: !include stress.yaml
|
||||
race: !include race.yaml
|
||||
@@ -0,0 +1,65 @@
|
||||
#!/bin/zsh
|
||||
# flow.sh NAME CONFIG HOST [SERIAL_PORT]: the RP2 scheduler lock flow (#22688). Uploads CONFIG (picow.yaml or evb.yaml)
|
||||
# as NAME to DEVICE (default HOST, an OTA), captures SERIAL_PORT for the whole run when given, polls the Fast counter,
|
||||
# then runs the removed item race, IRQ defer and IRQ cancel actions, connstress 500x4 and 500x2, 90 s of REST churn,
|
||||
# REST churn and connstress together, and the IRQ actions again. PASS needs every action to pass, connstress 500x2
|
||||
# without a failure, at least half of each REST churn answered 200, at least 90% of the counter polls answered, no
|
||||
# reboot (counter reset) and, with SERIAL_PORT, no crash or assert line and a capture that lasted the run; exits 1
|
||||
# otherwise. connstress at 4 is diagnostic: the API has 3 sockets on these builds, so 4 at a time always shows some
|
||||
# "dropped after hello" failures.
|
||||
# env: TREE, PY, DEVICE, API_KEY (unset for a plaintext API)
|
||||
D=${0:A:h}; N=$1; C=$2; H=$3; SP=$4; S=$D/..; cd $D
|
||||
T=${TREE:?set TREE}; PY=${PY:-$T/venv/bin/python}; L=$D/$N-flow.txt; : > $L
|
||||
FAILS=0; fail() { echo "FAIL: $*" | tee -a $L; FAILS=$((FAILS + 1)); }
|
||||
log() { echo "$*" | tee -a $L; }
|
||||
# restchurn.sh prints "REST 200:n 404:m ..."; fail when fewer than half of the POSTs answered 200.
|
||||
restok() {
|
||||
local ok all
|
||||
read ok all < <(echo "$2" | tr ' ' '\n' | awk -F: 'NF == 2 {a += $2; if ($1 == 200) o = $2} END {print o+0, a+0}')
|
||||
[ "$all" -gt 0 ] && [ $((ok * 2)) -ge "$all" ] || fail "$1: $ok of $all POSTs answered 200"; }
|
||||
heap() { curl -s -m 4 "http://$H/sensor/Heap%20free" | grep -o '"value":[0-9]*' | cut -d: -f2; }
|
||||
# Portable TCP check of the API port (nc -G is macOS only): apiopen TIMEOUT_S
|
||||
apiopen() { $PY -c 'import socket, sys; socket.create_connection((sys.argv[1], 6053), float(sys.argv[2])).close()' $H $1 2>/dev/null; }
|
||||
up() { for _ in $(seq 1 60); do apiopen 1 && return 0; sleep 2; done; return 1; }
|
||||
$S/pio_build.sh upload $N $D/$C ${DEVICE:-$H} || exit 1
|
||||
up || { echo "FAIL: API port never opened"; exit 1; }; sleep 8
|
||||
if [ -n "$SP" ]; then $PY $S/serial_capture.py $SP 3600 $D/$N-serial.log 2> $D/$N-cap.err & CAP=$!; sleep 3; fi
|
||||
( while true; do echo "$(date +%s) $(curl -s -m 3 "http://$H/sensor/Fast%20counter" | grep -o '"value":[0-9]*')"; sleep 2; done ) > $D/$N-ctr.txt 2>&1 &
|
||||
CTR=$!; trap 'kill $CTR $CAP 2>/dev/null' EXIT
|
||||
actions() {
|
||||
for a in "run_test:Test Complete:20" "run_defer:DEFER RESULT:30" "run_cancel:CANCEL RESULT:30"; do
|
||||
IFS=: read s pat t <<< "$a"; [ "$1" = again ] && [ $s = run_test ] && continue
|
||||
out=$($PY -I $D/svcrun.py $H $s "$pat" $t 2>&1) || fail "$s ($1)"; log "$out"; sleep 2
|
||||
done
|
||||
}
|
||||
log "heap at start: $(heap)"
|
||||
actions first
|
||||
$PY -I $S/api/connstress.py $H 500 4 > $D/$N-cs4.txt 2>&1; log "connstress 500x4: $(grep -a -E '^Success|^RESULT' $D/$N-cs4.txt | tr '\n' ' ')"
|
||||
sleep 5
|
||||
$PY -I $S/api/connstress.py $H 500 2 > $D/$N-cs2.txt 2>&1 || fail "connstress 500x2"
|
||||
log "connstress 500x2: $(grep -a -E '^Success|^RESULT' $D/$N-cs2.txt | tr '\n' ' ')"
|
||||
sleep 5; R=$($D/restchurn.sh $H 90 $D/$N-rest.txt); log "REST churn 90 s: $R"; restok "REST churn 90 s" "$R"
|
||||
sleep 5; log "heap after REST churn: $(heap)"
|
||||
$D/restchurn.sh $H 120 $D/$N-rest2.txt > $D/$N-rest2.sum & RP=$!
|
||||
$PY -I $S/api/connstress.py $H 500 4 > $D/$N-csrest.txt 2>&1
|
||||
log "connstress 500x4 during REST churn: $(grep -a -E '^Success|^RESULT' $D/$N-csrest.txt | tr '\n' ' ')"
|
||||
wait $RP; R=$(cat $D/$N-rest2.sum); log "REST during connstress: $R"; restok "REST during connstress" "$R"
|
||||
sleep 5; log "heap at end: $(heap)"
|
||||
actions again
|
||||
[ -n "$SP" ] && { kill -0 $CAP 2>/dev/null || fail "the capture ended before the run did (see $D/$N-cap.err)"; }
|
||||
kill $CTR $CAP 2>/dev/null; wait $CAP 2>/dev/null; trap - EXIT
|
||||
RESETS=$(grep -o 'value":[0-9]*' $D/$N-ctr.txt | cut -d: -f2 | awk 'NR>1 && $1<p {r++} {p=$1} END {print r+0}')
|
||||
POLLS=$(wc -l < $D/$N-ctr.txt | tr -d ' '); BADPOLLS=$(grep -vc value $D/$N-ctr.txt)
|
||||
log "counter resets (reboots): $RESETS, failed counter polls: $BADPOLLS of $POLLS"
|
||||
[ "$RESETS" = 0 ] || fail "$RESETS reboots"
|
||||
# A wedged web_server or a board that is down answers no polls, which would otherwise read as no reboot.
|
||||
[ "$POLLS" -gt 0 ] && [ $((BADPOLLS * 10)) -le "$POLLS" ] || fail "$BADPOLLS of $POLLS counter polls failed"
|
||||
if [ -n "$SP" ]; then
|
||||
CRASH=$(grep -a -c -i -E 'CRASH|panic|HardFault|assert' $D/$N-serial.log)
|
||||
log "serial: crash lines $CRASH, boots $(grep -a -c 'Log initialized' $D/$N-serial.log)"
|
||||
# a live capture that read nothing would pass the crash check without proving anything
|
||||
[ "$(grep -a -c -v '^\[[0-9:.]*\]\[capture\]' $D/$N-serial.log)" -gt 0 ] || fail "no firmware lines in $D/$N-serial.log"
|
||||
[ "$CRASH" = 0 ] || fail "$CRASH crash or assert lines"
|
||||
fi
|
||||
[ $FAILS = 0 ] || exit 1
|
||||
log PASS
|
||||
@@ -0,0 +1,22 @@
|
||||
#!/bin/zsh
|
||||
# looptime.sh NAME HOST SECS: the API connected (logs and states) plus a page load every 2 s for SECS, then a summary of
|
||||
# the 16 ms interval gap lines from stress.yaml (average, worst) and the 50 ms re-arms per 5 s. Diagnostic only;
|
||||
# compare two builds. Exits 1 when apilog.py fails, fewer than 2 windows were logged or most page loads did not
|
||||
# return 200, so a broken or unloaded run is not read as a comparison.
|
||||
# env: TREE or PY, API_KEY (unset for a plaintext API)
|
||||
D=${0:A:h}; N=$1; H=$2; S=$3; PY=${PY:-${TREE:?set TREE or PY}/venv/bin/python}; cd $D
|
||||
# apilog.py appends, so start from an empty log or an earlier run's windows count for this one
|
||||
: > $D/$N-lt-api.log
|
||||
$PY -I ../rp2_web_ble/apilog.py $H $S $D/$N-lt-api.log > /dev/null & AP=$!
|
||||
( end=$(( $(date +%s) + S ))
|
||||
while (( $(date +%s) < end )); do curl -s -o /dev/null -m 5 -w '%{http_code}\n' http://$H/; sleep 2; done
|
||||
) > $N-lt-web.txt & PP=$!
|
||||
wait $AP; RC=$?; kill $PP 2>/dev/null
|
||||
[ $RC = 0 ] || { echo "$N: apilog.py failed ($RC), see $N-lt-api.log"; exit 1; }
|
||||
WOK=$(grep -c '^200$' $N-lt-web.txt); WALL=$(wc -l < $N-lt-web.txt | tr -d ' ')
|
||||
[ "$WALL" -gt 0 ] && [ $((WOK * 2)) -ge "$WALL" ] ||
|
||||
{ echo "$N: NOT LOADED, $WOK of $WALL page loads returned 200"; exit 1; }
|
||||
grep -a -o "n=[0-9]* avg_gap_us=[0-9]* max_gap_us=[0-9]* btn=[0-9]* rearms=[0-9]*" $N-lt-api.log | tail -n +2 > $N-lt.txt
|
||||
awk -v n=$N '{split($2,b,"="); split($3,c,"="); split($5,d,"="); k++; sa+=b[2]; if (c[2]>mx) mx=c[2]; sm+=c[2]; if (k>1) rr+=d[2]-pr; pr=d[2]}
|
||||
END {if (k < 2) {print n ": fewer than 2 windows"; exit 1}
|
||||
printf "%s: %d windows of 5 s, 16 ms interval avg gap %.0f us, mean window max %.0f us, worst %d us, re-arms per 5 s %.1f\n", n, k, sa/k, sm/k, mx, rr/(k-1)}' $N-lt.txt
|
||||
@@ -0,0 +1,10 @@
|
||||
# Pico W on the station network with the scheduler lock packages (name set with -s name).
|
||||
rp2:
|
||||
board: rpipicow
|
||||
wifi:
|
||||
ssid: !secret wifi_ssid
|
||||
password: !secret wifi_password
|
||||
packages:
|
||||
common: !include ../rp2_web_ble/rp-common.yaml
|
||||
stress: !include stress.yaml
|
||||
race: !include race.yaml
|
||||
@@ -0,0 +1,40 @@
|
||||
# The removed item race from tests/integration/fixtures/scheduler_removed_item_race.yaml, run on the board through
|
||||
# the run_test action: cancelled timeouts behind a live one at the front of the heap must never run.
|
||||
globals:
|
||||
- id: removed_item_executed
|
||||
type: int
|
||||
initial_value: '0'
|
||||
- id: normal_item_executed
|
||||
type: int
|
||||
initial_value: '0'
|
||||
sensor:
|
||||
- platform: template
|
||||
id: race_sensor
|
||||
update_interval: never
|
||||
lambda: return 0.0;
|
||||
script:
|
||||
- id: run_test_script
|
||||
then:
|
||||
- lambda: |-
|
||||
id(removed_item_executed) = 0;
|
||||
id(normal_item_executed) = 0;
|
||||
auto *c = id(race_sensor);
|
||||
auto normal = []() { id(normal_item_executed)++; };
|
||||
auto removed = []() { id(removed_item_executed)++; };
|
||||
App.scheduler.set_timeout(c, "blocker", 1, normal);
|
||||
App.scheduler.set_timeout(c, "cancel_1", 1, removed);
|
||||
App.scheduler.set_timeout(c, "cancel_2", 1, removed);
|
||||
App.scheduler.set_timeout(c, "cancel_3", 1, removed);
|
||||
App.scheduler.set_timeout(c, "normal_1", 1, normal);
|
||||
App.scheduler.set_timeout(c, "normal_2", 1, normal);
|
||||
App.scheduler.set_timeout(c, "normal_3", 1, normal);
|
||||
App.scheduler.process_to_add();
|
||||
App.scheduler.cancel_timeout(c, "cancel_1");
|
||||
App.scheduler.cancel_timeout(c, "cancel_2");
|
||||
App.scheduler.cancel_timeout(c, "cancel_3");
|
||||
- delay: 20ms
|
||||
- lambda: |-
|
||||
bool ok = id(removed_item_executed) == 0 && id(normal_item_executed) == 4;
|
||||
ESP_LOGI("test", "%s: normal %d (expect 4), removed %d (expect 0)", ok ? "TEST PASSED" : "TEST FAILED",
|
||||
id(normal_item_executed), id(removed_item_executed));
|
||||
ESP_LOGI("test", "=== Test Complete ===");
|
||||
@@ -0,0 +1,10 @@
|
||||
#!/bin/zsh
|
||||
# restchurn.sh HOST SECS OUT: 4 parallel loops of REST POSTs (Sw toggle, Lt on with a brightness, Num set, Btn press
|
||||
# from stress.yaml) for SECS; writes "time code" lines to OUT and prints the count per HTTP code.
|
||||
H=$1; S=$2; O=$3; : > $O; : > $O.1; : > $O.2; : > $O.3; : > $O.4; end=$(( $(date +%s) + S ))
|
||||
# $1 is expanded per request outside the command substitution, so each $RANDOM in it is a new value
|
||||
loop() { while (( $(date +%s) < end )); do u=${(e)1}; echo "$(date +%s) $(curl -s -o /dev/null -m 3 -w '%{http_code}' -X POST "http://$H$u")"; done >> $O.$2; }
|
||||
loop '/switch/Sw/toggle' 1 & loop '/light/Lt/turn_on?brightness=$((RANDOM % 255))' 2 &
|
||||
loop '/number/Num/set?value=$((RANDOM % 100))' 3 & loop '/button/Btn/press' 4 & wait
|
||||
cat $O.1 $O.2 $O.3 $O.4 | sort -n > $O; rm -f $O.1 $O.2 $O.3 $O.4
|
||||
echo "REST $(awk '{c[$2]++} END {for (k in c) printf "%s:%d ", k, c[k]}' $O)"
|
||||
@@ -0,0 +1,91 @@
|
||||
# RP2 scheduler lock check (#22688): the IRQ stress component with its API actions, REST entities for the churn
|
||||
# loops (Sw, Lt, Num, Btn), a 50 ms self re-arming script and a 16 ms interval that logs its gaps every 5 s as
|
||||
# "n=... avg_gap_us=... max_gap_us=... btn=... rearms=..." (read by looptime.sh).
|
||||
external_components:
|
||||
- source:
|
||||
type: local
|
||||
path: components
|
||||
components: [irq_sched_stress]
|
||||
irq_sched_stress:
|
||||
id: irqss
|
||||
api:
|
||||
actions:
|
||||
- action: run_test
|
||||
then:
|
||||
- script.execute: run_test_script
|
||||
- action: run_defer
|
||||
then:
|
||||
- lambda: id(irqss)->run_defer();
|
||||
- action: run_cancel
|
||||
then:
|
||||
- lambda: id(irqss)->run_cancel();
|
||||
switch:
|
||||
- platform: template
|
||||
name: Sw
|
||||
optimistic: true
|
||||
output:
|
||||
- platform: template
|
||||
id: lt_out
|
||||
type: float
|
||||
write_action:
|
||||
- lambda: id(lt_level) = state;
|
||||
light:
|
||||
- platform: monochromatic
|
||||
name: Lt
|
||||
output: lt_out
|
||||
default_transition_length: 0s
|
||||
number:
|
||||
- platform: template
|
||||
name: Num
|
||||
optimistic: true
|
||||
min_value: 0
|
||||
max_value: 100
|
||||
step: 1
|
||||
globals:
|
||||
- id: lt_level
|
||||
type: float
|
||||
initial_value: '0'
|
||||
- id: btn_presses
|
||||
type: uint32_t
|
||||
initial_value: '0'
|
||||
- id: rearms
|
||||
type: uint32_t
|
||||
initial_value: '0'
|
||||
button:
|
||||
- platform: template
|
||||
name: Btn
|
||||
on_press:
|
||||
- lambda: id(btn_presses)++;
|
||||
script:
|
||||
- id: rearm
|
||||
mode: restart
|
||||
then:
|
||||
- delay: 50ms
|
||||
- lambda: id(rearms)++;
|
||||
- script.execute: rearm
|
||||
esphome:
|
||||
on_boot:
|
||||
- script.execute: rearm
|
||||
interval:
|
||||
- interval: 16ms
|
||||
then:
|
||||
- lambda: |-
|
||||
static uint32_t last = 0, n = 0, sum = 0, mx = 0, t0 = 0;
|
||||
uint32_t now = micros();
|
||||
if (last != 0) {
|
||||
uint32_t g = now - last;
|
||||
n++;
|
||||
sum += g;
|
||||
if (g > mx)
|
||||
mx = g;
|
||||
}
|
||||
last = now;
|
||||
if (t0 == 0)
|
||||
t0 = now;
|
||||
if (now - t0 >= 5000000) {
|
||||
ESP_LOGI("lt", "n=%u avg_gap_us=%u max_gap_us=%u btn=%u rearms=%u level=%.2f", (unsigned) n,
|
||||
(unsigned) (n ? sum / n : 0), (unsigned) mx, (unsigned) id(btn_presses),
|
||||
(unsigned) id(rearms), id(lt_level));
|
||||
n = sum = mx = 0;
|
||||
t0 = now;
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
"""svcrun.py HOST ACTION DONE_REGEX TIMEOUT: run a user defined API action, collect the logs until DONE_REGEX matches
|
||||
or TIMEOUT seconds pass, and print the result lines. env: API_KEY (unset for a plaintext API).
|
||||
Exits 1 on a timeout, when a result line says FAIL, FAILED or crash, or when no result line says PASS or PASSED."""
|
||||
|
||||
import asyncio
|
||||
import pathlib
|
||||
import re
|
||||
import sys
|
||||
import time
|
||||
|
||||
from aioesphomeapi import LogLevel
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
from apiconn import connect, log_text # noqa: E402
|
||||
|
||||
RESULT = re.compile(
|
||||
r"RESULT|TEST PASSED|TEST FAILED|Test Complete|crash", re.IGNORECASE
|
||||
)
|
||||
|
||||
|
||||
async def main(host: str, action: str, done: str, timeout: float) -> int:
|
||||
cli = await connect(host, tries=30, timeout=15)
|
||||
lines: list[str] = []
|
||||
finished = asyncio.Event()
|
||||
rx = re.compile(done)
|
||||
|
||||
def on_log(msg) -> None:
|
||||
line = log_text(msg)
|
||||
lines.append(line)
|
||||
if rx.search(line):
|
||||
finished.set()
|
||||
|
||||
cli.subscribe_logs(on_log, log_level=LogLevel.LOG_LEVEL_DEBUG)
|
||||
_, services = await cli.list_entities_services()
|
||||
svc = next((s for s in services if s.name == action), None)
|
||||
if svc is None:
|
||||
sys.exit(f"no action {action} on {host}")
|
||||
await asyncio.sleep(0.5)
|
||||
t0 = time.monotonic()
|
||||
await cli.execute_service(svc, {})
|
||||
try:
|
||||
await asyncio.wait_for(finished.wait(), timeout)
|
||||
status = "DONE"
|
||||
except TimeoutError:
|
||||
status = "TIMEOUT"
|
||||
found = [line for line in lines if RESULT.search(line)]
|
||||
for line in found:
|
||||
print(" " + line)
|
||||
print(f"{action}: {status} after {time.monotonic() - t0:.1f} s")
|
||||
await cli.disconnect()
|
||||
failed = any(
|
||||
re.search(r"\bFAIL(ED)?\b|crash", line, re.IGNORECASE) for line in found
|
||||
)
|
||||
# a missing PASS line (dropped log, a check that never ran) is not a pass
|
||||
passed = any(re.search(r"\bPASS(ED)?\b", line) for line in found)
|
||||
return 1 if status != "DONE" or failed or not passed else 0
|
||||
|
||||
|
||||
sys.exit(asyncio.run(main(sys.argv[1], sys.argv[2], sys.argv[3], float(sys.argv[4]))))
|
||||
@@ -0,0 +1,31 @@
|
||||
# RP2040/RP2350 web_server, API and BLE proxy A/B (#22671)
|
||||
|
||||
Configs take their name from the command line (`-s name ...` through `../pio_build.sh`), so a PR build and a dev build
|
||||
of the same file never share a build directory: `picow.yaml` (Pico W with an active bluetooth_proxy), `pico2w.yaml`,
|
||||
`evb.yaml` (W5100S-EVB-Pico on Ethernet), `picow-ap.yaml` (fallback AP with the AP client count from `appeek.hpp`) and
|
||||
`client.yaml` (ESP32 that provisions it). `rp-common.yaml` adds the encrypted API, web_server and a restart button to
|
||||
`templates/diagnostics.yaml`. Put `secrets.yaml` and `apikey.txt` (the `api_key` secret) in this directory; both are
|
||||
git-ignored.
|
||||
|
||||
The runners read `TREE` and `PY` from the environment, plus `PICO_SN` (the Pico's USB serial number), `PEER_MAC` (the
|
||||
`ble_notify/server.yaml` GATT server) and `CLIENT_PORT`/`CLIENT_TREE` where noted. `staflow.sh`, `bleseq.sh`,
|
||||
`apflow.sh` and `churn.sh` end with PASS or FAIL and exit 1 on FAIL; `sseabc.sh` and `sserun.sh` are diagnostic and
|
||||
only print counts.
|
||||
|
||||
- `staflow.sh NAME CONFIG BLE`: USB flash, API soak with page loads, 30 s SSE, OTA, restart, short soak, and with
|
||||
BLE=1 a 180 s GATT hold.
|
||||
- `bleseq.sh NAME`: 180 s GATT hold through the Pico W proxy (`gatthold.py`), then 4 short reconnects.
|
||||
- `apflow.sh NAME`: fallback AP on the Pico W, the ESP32 client provisions it, the AP client count is logged.
|
||||
- `sseabc.sh HOST TAG`: SSE alone, with the API soak, and with page loads (state events per 5 s).
|
||||
- `sserun.sh HOST TAG SECS MODE N`: N SSE streams with a pcap, a netstat poll, the API log (`apilog.py`) and probes
|
||||
after each; `pcapsum.py PCAP IP` summarizes the pcap and `stallctr.py PCAP IP APILOG` lines the RPAsyncTCP counters
|
||||
up with each stall.
|
||||
- `H=<device ip> churn.sh TAG SECS`: `/events` connect and disconnect churn, reboots from the reported uptime, then
|
||||
the crash report through `../crash_report/peek.py`.
|
||||
- `soak.py HOST SECONDS LOG`: states, drops, uptime resets, reset reason, crash and assert lines from the API logs.
|
||||
- `churnflow.sh NAME CONFIG HOST`: upload, then rounds of `churn.sh` with the heap before, after and settled and a
|
||||
main loop check; uploads again by OTA when a round left the board in safe mode. PASS or FAIL.
|
||||
- `leakflow.sh NAME CONFIG HOST`: rounds of 300 `/events` connects that never complete (`neverconn.py HOST N
|
||||
rst|head`: reset right after the GET, or after reading the first bytes of the head), heap before, after and
|
||||
settled. PASS when each round completes most GETs (head mode: with an HTTP/1.1 200 status), the board does not
|
||||
reboot and the settled heap stays near idle.
|
||||
@@ -0,0 +1,39 @@
|
||||
#!/bin/zsh
|
||||
# apflow.sh NAME: Pico W fallback AP (picow-ap.yaml as NAME; use a fresh NAME per build) and an ESP32 client
|
||||
# (client.yaml) that provisions it through /wifisave. Prints the AP client count changes, the provisioning and crash
|
||||
# or reboot markers. PASS needs a client on the AP, status 200 for the real save, the DUT on the station network
|
||||
# with its AP disabled, no crash line and a capture that lasted the run; exits 1 otherwise.
|
||||
# env: TREE, PY, PICO_SN, CLIENT_PORT, CLIENT_TREE (checkout for the client build)
|
||||
D=${0:A:h}; N=$1; S=$D/..; T=${TREE:?set TREE}; PY=${PY:-$T/venv/bin/python}
|
||||
SN=${PICO_SN:?set PICO_SN}; CPORT=${CLIENT_PORT:?set CLIENT_PORT}; CTREE=${CLIENT_TREE:?set CLIENT_TREE}
|
||||
FAILS=0; fail() { echo "FAIL: $*"; FAILS=$((FAILS + 1)); }
|
||||
# both builds first, so the DUT capture only has to cover the provisioning
|
||||
$S/pio_build.sh compile $N $D/picow-ap.yaml || exit 1
|
||||
TREE=$CTREE $S/pio_build.sh compile $N-client $D/client.yaml || exit 1
|
||||
PORT=$($PY $S/ports.py --wait 2e8a --serial $SN --timeout 30) || { echo "FAIL: no pico"; exit 1; }
|
||||
$S/pio_build.sh upload $N $D/picow-ap.yaml $PORT || exit 1
|
||||
PORT=$($PY $S/ports.py --wait 2e8a --serial $SN --timeout 60) || { echo "FAIL: pico gone after the upload"; exit 1; }
|
||||
L=$D/$N-serial.log; CL=$D/$N-client.log
|
||||
$PY $S/serial_capture.py $PORT 600 $L 2> $D/$N-cap.err &
|
||||
CAP=$!; trap 'kill $CAP $CCAP 2>/dev/null' EXIT
|
||||
n=0; until grep -a -q "Starting fallback AP\|Captive portal" $L; do sleep 2; n=$((n+2)); [ $n -ge 150 ] && { echo "FAIL: the AP never came up"; exit 1; }; done
|
||||
echo "AP up after ${n}s"
|
||||
TREE=$CTREE $S/pio_build.sh upload $N-client $D/client.yaml $CPORT || exit 1
|
||||
$PY $S/serial_capture.py $CPORT 200 $CL --reset 2> $D/$N-ccap.err &
|
||||
CCAP=$!
|
||||
n=0; until grep -a -q "real save status" $CL; do sleep 2; n=$((n+2)); [ $n -ge 180 ] && { echo "FAIL: the client never saved"; exit 1; }; done
|
||||
echo "client posted after ${n}s; settling 60s"; sleep 60
|
||||
kill -0 $CAP 2>/dev/null || fail "the DUT capture ended before the run did (see $D/$N-cap.err)"
|
||||
kill $CAP $CCAP 2>/dev/null; wait 2>/dev/null; trap - EXIT
|
||||
echo "--- DUT"
|
||||
grep -a -E "AP clients|Starting fallback AP|Requested WiFi|Connected\$|IP Address|Disabling AP|CRASH|panic|HardFault|Log initialized|port lost" $L | sed -E 's/(IP Address: )[0-9.]+/\1<ip>/' | cut -c1-120 | head -40
|
||||
echo "--- client"
|
||||
grep -a -E "connected, ip|save status|posting" $CL | sed -E 's/ip [0-9.]+/ip <ip>/' | head
|
||||
grep -a -q "AP clients [1-9]" $L || fail "the DUT never counted a client on its AP"
|
||||
grep -a -q "real save status 200" $CL || fail "the real save did not return 200"
|
||||
grep -a -q "Disabling AP" $L || fail "the DUT never disabled its AP"
|
||||
# the fallback AP logs its own 192.168.4.x address too, so only another address shows the station side
|
||||
grep -a "IP Address" $L | grep -v -q "192\.168\.4\." || fail "the DUT never got a station address"
|
||||
CRASH=$(grep -a -c -E "CRASH|panic|HardFault" $L); [ "$CRASH" = 0 ] || fail "$CRASH crash lines"
|
||||
[ $FAILS = 0 ] || exit 1
|
||||
echo PASS
|
||||
@@ -0,0 +1,55 @@
|
||||
"""apilog.py HOST SECONDS OUT: subscribe VERBOSE logs and states for SECONDS with ms timestamps, reconnecting on a drop.
|
||||
env: API_KEY (unset for a plaintext API). Prints the state and drop counts at the end; exits 1 on a drop or when no
|
||||
state arrived, so an unexercised API is not read as a working one."""
|
||||
|
||||
import asyncio
|
||||
import contextlib
|
||||
import pathlib
|
||||
import sys
|
||||
import time
|
||||
|
||||
from aioesphomeapi import LogLevel
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
from apiconn import connect, log_text, stop_event # noqa: E402
|
||||
|
||||
|
||||
def ts() -> str:
|
||||
return f"{time.time():.3f}"
|
||||
|
||||
|
||||
async def main(host: str, secs: float, outf: str) -> None:
|
||||
end = time.monotonic() + secs
|
||||
states = drops = 0
|
||||
with pathlib.Path(outf).open("a", encoding="utf-8") as out:
|
||||
|
||||
def w(line: str) -> None:
|
||||
out.write(f"{ts()} {line}\n")
|
||||
out.flush()
|
||||
|
||||
def on_state(_s) -> None:
|
||||
nonlocal states
|
||||
states += 1
|
||||
|
||||
while time.monotonic() < end:
|
||||
stopped, on_stop = stop_event()
|
||||
cli = await connect(host, tries=60, timeout=15, on_stop=on_stop)
|
||||
w(f"API connected {(await cli.device_info()).name}")
|
||||
cli.subscribe_states(on_state)
|
||||
cli.subscribe_logs(
|
||||
lambda m: w(log_text(m)), log_level=LogLevel.LOG_LEVEL_VERBOSE
|
||||
)
|
||||
with contextlib.suppress(TimeoutError):
|
||||
await asyncio.wait_for(stopped.wait(), max(0.0, end - time.monotonic()))
|
||||
if stopped.is_set():
|
||||
drops += 1
|
||||
w("API DROPPED")
|
||||
with contextlib.suppress(Exception):
|
||||
await cli.disconnect()
|
||||
w(f"API done states={states} drops={drops}")
|
||||
print(f"api states={states} drops={drops}")
|
||||
if drops or not states:
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
asyncio.run(main(sys.argv[1], float(sys.argv[2]), sys.argv[3]))
|
||||
@@ -0,0 +1,14 @@
|
||||
#pragma once
|
||||
// Reads the protected WiFiComponent::ap_clients_ for the test: explicit instantiation skips access checks.
|
||||
#include "esphome/components/wifi/wifi_component.h"
|
||||
namespace appeek {
|
||||
struct Tag {
|
||||
using type = uint8_t esphome::wifi::WiFiComponent::*;
|
||||
friend type get(Tag);
|
||||
};
|
||||
template<typename T, typename T::type M> struct Rob {
|
||||
friend typename T::type get(T) { return M; }
|
||||
};
|
||||
template struct Rob<Tag, &esphome::wifi::WiFiComponent::ap_clients_>;
|
||||
inline int ap_clients() { return esphome::wifi::global_wifi_component->*get(Tag{}); }
|
||||
} // namespace appeek
|
||||
@@ -0,0 +1,33 @@
|
||||
#!/bin/zsh
|
||||
# bleseq.sh NAME: 180 s GATT hold through the Pico W proxy NAME (built by staflow.sh), then 4 short holds 10 s apart,
|
||||
# with the serial log captured. PASS needs every hold to pass, no crash line, boot or port loss and a capture that
|
||||
# lasted the run.
|
||||
# env: TREE, PY, PICO_SN, PEER_MAC (the ble_notify server); apikey.txt here
|
||||
D=${0:A:h}; N=$1; S=$D/..; T=${TREE:?set TREE}; PY=${PY:-$T/venv/bin/python}; H=$(cat $D/$N-host.txt)
|
||||
FAILS=0; fail() { echo "FAIL: $*"; FAILS=$((FAILS + 1)); }
|
||||
export API_KEY=$(cat $D/apikey.txt)
|
||||
PORT=$($PY $S/ports.py --wait 2e8a --serial ${PICO_SN:?set PICO_SN} --timeout 10) || { echo "FAIL: no pico"; exit 1; }
|
||||
L=$D/$N-bleseq-serial.log
|
||||
$PY $S/serial_capture.py $PORT 420 $L 2> $D/$N-bleseq-cap.err &
|
||||
CAP=$!; trap 'kill $CAP 2>/dev/null' EXIT
|
||||
sleep 2
|
||||
timeout 300 $PY -I $D/gatthold.py $H ${PEER_MAC:?set PEER_MAC} 180 > $D/$N-hold.txt 2>&1 || fail "the 180 s hold"
|
||||
grep -v '^uuids' $D/$N-hold.txt
|
||||
for i in 1 2 3 4; do
|
||||
sleep 10
|
||||
timeout 90 $PY -I $D/gatthold.py $H $PEER_MAC 15 > $D/$N-hold$i.txt 2>&1 || fail "short hold $i"
|
||||
grep -E "PASS|FAIL|held" $D/$N-hold$i.txt | tr '\n' ' '; echo
|
||||
done
|
||||
sleep 3
|
||||
kill -0 $CAP 2>/dev/null || fail "the capture ended before the run did (see $D/$N-bleseq-cap.err)"
|
||||
[ "$(grep -a -c -v '^\[[0-9:.]*\]\[capture\]' $L)" -gt 0 ] || fail "no firmware lines in $L"
|
||||
kill $CAP; wait $CAP 2>/dev/null; trap - EXIT
|
||||
CRASH=$(grep -a -c -i -E 'CRASH|panic|HardFault|assert' $L)
|
||||
echo "serial: crash/assert $CRASH boots $(grep -a -c 'ESPHome version' $L) notify-response warnings $(grep -a -c 'Failed to send notify' $L) connects $(grep -a -c 'Connecting v3' $L)"
|
||||
grep -a -E "Disconnected, reason|Connection failed|status" $L | cut -c1-120 | sort | uniq -c | sort -rn | head -5
|
||||
[ "$CRASH" = 0 ] || fail "$CRASH crash lines"
|
||||
# the capture opens on a running proxy, so any boot or USB drop is a reboot the next hold's retry would hide
|
||||
BOOTS=$(grep -a -c 'ESPHome version' $L); LOSSES=$(grep -a -c 'port lost' $L)
|
||||
[ "$BOOTS" = 0 ] && [ "$LOSSES" = 0 ] || fail "$BOOTS boots and $LOSSES port losses during the holds"
|
||||
[ $FAILS = 0 ] || exit 1
|
||||
echo PASS
|
||||
@@ -0,0 +1,24 @@
|
||||
#!/bin/zsh
|
||||
# H=<device ip> churn.sh TAG SECS: 4 parallel loops of short /events connections (0.2 to 1.5 s) for SECS, logging the
|
||||
# uptime each stream reports; counts reboots from the uptime going backwards, then reads the crash report over the API
|
||||
# with crash_report/peek.py. PASS needs streams that got data (at least as many as got nothing), no reboot and no
|
||||
# replayed crash record; exits 1 otherwise. env: H, TREE or PY, API_KEY (unset for a plaintext API)
|
||||
D=${0:A:h}; T=$1; S=$2; H=${H:?set H to the device address}; PY=${PY:-${TREE:?set TREE or PY}/venv/bin/python}; cd $D
|
||||
rm -f $T-churn*.txt
|
||||
end=$(( $(date +%s) + S ))
|
||||
for k in 1 2 3 4; do
|
||||
( while (( $(date +%s) < end )); do m=0.$(( RANDOM % 9 + 2 )); [[ $((RANDOM % 3)) == 0 ]] && m=1.5
|
||||
r=$(curl -s -N --connect-timeout 1 -m $m http://$H/events 2>/dev/null | grep -a -o '"uptime":[0-9]*' | head -1)
|
||||
echo "$(date +%s) ${r:-none}"; done > $T-churn$k.txt ) &
|
||||
done; wait
|
||||
cat $T-churn*.txt | sort -n > $T-churn.txt
|
||||
FAILS=0; fail() { echo "FAIL: $*"; FAILS=$((FAILS + 1)); }
|
||||
read -r OK NONE REBOOTS < <(awk '$2 ~ /uptime/ {split($2,a,":"); b=$1-a[2]; if (pb!="" && b-pb>3) n++; pb=b; c++} $2=="none"{x++} END{print c+0, x+0, n+0}' $T-churn.txt)
|
||||
echo "streams_with_ping=$OK none=$NONE reboots=$REBOOTS"
|
||||
[ "$OK" -gt 0 ] && [ "$OK" -ge "$NONE" ] || fail "most streams got nothing (the stimulus did not reach the device)"
|
||||
[ "$REBOOTS" = 0 ] || fail "$REBOOTS reboots"
|
||||
PEEK=$($PY -I $D/../crash_report/peek.py $H) || fail "reading the crash report"
|
||||
echo "crash report: $PEEK"
|
||||
[[ $PEEK == *"replay lines 0"* ]] || fail "a crash record was replayed"
|
||||
[ $FAILS = 0 ] || exit 1
|
||||
echo PASS
|
||||
@@ -0,0 +1,31 @@
|
||||
#!/bin/zsh
|
||||
# churnflow.sh NAME CONFIG HOST: upload CONFIG as NAME to DEVICE (default HOST, an OTA), then ROUNDS (default 2) rounds
|
||||
# of `churn.sh` for 90 s with the free heap before, right after and after a 30 s settle, and a main loop check (the
|
||||
# Fast counter must advance). A board that fell into safe mode (API port closed) gets NAME again by OTA and the round
|
||||
# fails. PASS needs every churn.sh round to pass, the loop to keep running and no safe mode; exits 1 otherwise.
|
||||
# env: TREE, PY, DEVICE, ROUNDS, API_KEY
|
||||
D=${0:A:h}; N=$1; C=$2; H=$3; S=$D/..; cd $D
|
||||
T=${TREE:?set TREE}; export PY=${PY:-$T/venv/bin/python}; FAILS=0
|
||||
val() { curl -s -m 4 "http://$H/sensor/$1" | grep -o '"value":[0-9]*' | cut -d: -f2; }
|
||||
loopchk() { local a b; a=$(val Fast%20counter); sleep 3; b=$(val Fast%20counter); [[ -n $a && -n $b && $b -gt $a ]]; }
|
||||
# Portable TCP check of the API port (nc -G is macOS only): apiopen TIMEOUT_S
|
||||
apiopen() { $PY -c 'import socket, sys; socket.create_connection((sys.argv[1], 6053), float(sys.argv[2])).close()' $H $1 2>/dev/null; }
|
||||
ready() { for _ in $(seq 1 40); do [ -n "$(val Uptime)" ] && return 0; sleep 3; done; return 1; }
|
||||
$S/pio_build.sh upload $N $D/$C ${DEVICE:-$H} || exit 1
|
||||
ready || { echo "FAIL: $N never answered"; exit 1; }
|
||||
echo "$N idle heap: $(val Heap%20free)"
|
||||
for r in $(seq 1 ${ROUNDS:-2}); do
|
||||
sleep 10; hb=$(val Heap%20free)
|
||||
res=$(H=$H $D/churn.sh $N-churn$r 90 2>&1) || FAILS=$((FAILS + 1))
|
||||
sleep 5; ha=$(val Heap%20free); sleep 30; hs=$(val Heap%20free)
|
||||
loopchk && lp="loop ok" || { lp="LOOP STUCK"; FAILS=$((FAILS + 1)); }
|
||||
echo "$N round $r: $(echo $res | tr '\n' ' ') | heap before $hb, after $ha, settled $hs | $lp"
|
||||
if ! apiopen 2; then
|
||||
sleep 15
|
||||
apiopen 2 || { echo "$N: API port closed after round $r (safe mode?), uploading again"; FAILS=$((FAILS + 1))
|
||||
$S/pio_build.sh upload $N $D/$C $H && ready || { echo "$N: recovery after round $r failed, stopping"
|
||||
FAILS=$((FAILS + 1)); break; }; }
|
||||
fi
|
||||
done
|
||||
[ $FAILS = 0 ] || { echo FAIL; exit 1; }
|
||||
echo PASS
|
||||
@@ -0,0 +1,12 @@
|
||||
# Classic ESP32 that joins the Pico W's fallback AP and provisions it once through /wifisave (name set with -s name).
|
||||
substitutions:
|
||||
ap_ssid: rp2webap
|
||||
real_ssid: !secret wifi_ssid
|
||||
real_psk: !secret wifi_password
|
||||
bogus_saves: "1"
|
||||
esp32:
|
||||
board: pico32
|
||||
framework:
|
||||
type: esp-idf
|
||||
packages:
|
||||
hwtest: !include ../../templates/client-wifisave.yaml
|
||||
@@ -0,0 +1,13 @@
|
||||
# WIZnet W5100S-EVB-Pico on wired Ethernet (name set with -s name).
|
||||
rp2:
|
||||
board: wiznet_5100s_evb_pico
|
||||
ethernet:
|
||||
type: W5100
|
||||
clk_pin: 18
|
||||
mosi_pin: 19
|
||||
miso_pin: 16
|
||||
cs_pin: 17
|
||||
interrupt_pin: 21
|
||||
reset_pin: 20
|
||||
packages:
|
||||
common: !include rp-common.yaml
|
||||
@@ -0,0 +1,89 @@
|
||||
"""Through a bluetooth_proxy: connect to the ble_notify GATT server (server.yaml), read both characteristics, enable
|
||||
notify on both (writing the CCCD like Home Assistant), hold for HOLD seconds re-reading every 3 s, then disconnect.
|
||||
usage: gatthold.py PROXY PEER_MAC HOLD env: API_KEY, ALLOW_UUID_REMAP=1 (accept the pre-#22679 short UUIDs).
|
||||
Prints counts; exits 1 on a lost link, a failed read or a short UUID reported in place of the real one."""
|
||||
|
||||
import asyncio
|
||||
import os
|
||||
import pathlib
|
||||
import sys
|
||||
import time
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
from apiconn import ble_connect, connect, enable_notify # noqa: E402
|
||||
|
||||
NUM = "5ec10001-0000-1000-8000-00805f9b34fb"
|
||||
TXT = "5ec10002-0000-1000-8000-00805f9b34fb"
|
||||
|
||||
|
||||
async def main(host: str, peer: str, hold: float) -> None:
|
||||
addr = int(peer.replace(":", ""), 16)
|
||||
cli = await connect(host)
|
||||
lost: list[tuple[float, int]] = []
|
||||
closing = False
|
||||
|
||||
def on_lost(err: int) -> None:
|
||||
if not closing:
|
||||
lost.append((time.monotonic(), err))
|
||||
print(f"LINK LOST err={err}", flush=True)
|
||||
|
||||
t = time.monotonic()
|
||||
c, mtu, err, cancel = await ble_connect(cli, addr, on_lost)
|
||||
if not c:
|
||||
sys.exit(f"FAIL connect err={err}")
|
||||
print(f"connected in {time.monotonic() - t:.1f}s mtu={mtu}", flush=True)
|
||||
svcs = await cli.bluetooth_gatt_get_services(addr)
|
||||
chars = {ch.uuid.lower(): ch for s in svcs.services for ch in s.characteristics}
|
||||
print("uuids", sorted(chars), flush=True)
|
||||
print(f"services {len(svcs.services)} characteristics {len(chars)}", flush=True)
|
||||
# before #22679 the rp2 proxy reported a 32-bit base UUID as its low 16 bits (5ec10001 -> 00000001)
|
||||
remapped = 0
|
||||
for u in (NUM, TXT):
|
||||
if u not in chars and "0000" + u[4:] in chars:
|
||||
remapped += 1
|
||||
print(f"UUID {u[:8]} reported as {'0000' + u[4:8]}", flush=True)
|
||||
chars[u] = chars["0000" + u[4:]]
|
||||
got = {NUM: 0, TXT: 0}
|
||||
reads = fails = empty = 0
|
||||
samples: list[bytes] = []
|
||||
for u in (NUM, TXT):
|
||||
if not await enable_notify(
|
||||
cli, addr, chars[u], lambda h, d, u=u: got.__setitem__(u, got[u] + 1)
|
||||
):
|
||||
sys.exit(f"FAIL: {u[:8]} lists no CCCD")
|
||||
end = time.monotonic() + hold
|
||||
while time.monotonic() < end and not lost:
|
||||
for u in (NUM, TXT):
|
||||
try:
|
||||
v = bytes(await cli.bluetooth_gatt_read(addr, chars[u].handle))
|
||||
reads += 1
|
||||
empty += not v
|
||||
if v and len(samples) < 4:
|
||||
samples.append(v)
|
||||
except Exception as e: # noqa: BLE001
|
||||
fails += 1
|
||||
print(f"read {u[4:8]} FAILED {type(e).__name__}: {e}", flush=True)
|
||||
# 3 s, so a hold covers several of the server's 10 s empty-value cycles
|
||||
await asyncio.sleep(3)
|
||||
print(
|
||||
f"held {hold:.0f}s: notifications num={got[NUM]} txt={got[TXT]} reads ok={reads} failed={fails} "
|
||||
f"link losses={len(lost)} empty reads={empty} uuid_remapped={remapped} samples={samples}",
|
||||
flush=True,
|
||||
)
|
||||
closing = True
|
||||
await cli.bluetooth_device_disconnect(addr)
|
||||
await asyncio.sleep(2)
|
||||
cancel()
|
||||
await cli.disconnect()
|
||||
# server.yaml empties both values on every 5th 2 s round, so about one read in five is legitimately empty; the
|
||||
# client cannot tell which round it hit, so only a majority of empty reads counts as a proxy returning no data
|
||||
if remapped and os.environ.get("ALLOW_UUID_REMAP") != "1":
|
||||
sys.exit(
|
||||
f"FAIL: {remapped} UUIDs reported in short form (ALLOW_UUID_REMAP=1 accepts them)"
|
||||
)
|
||||
if lost or fails or not got[NUM] or not got[TXT] or empty * 2 > reads:
|
||||
sys.exit("FAIL")
|
||||
print("PASS", flush=True)
|
||||
|
||||
|
||||
asyncio.run(main(sys.argv[1], sys.argv[2], float(sys.argv[3])))
|
||||
@@ -0,0 +1,25 @@
|
||||
#!/bin/zsh
|
||||
# leakflow.sh NAME CONFIG HOST: upload CONFIG as NAME to DEVICE (default HOST, an OTA), then 3 rounds of 300 /events
|
||||
# connects reset right after the GET and 1 round of 300 that read the response head first (neverconn.py), with the
|
||||
# free heap before, right after and after a 30 s settle. PASS needs every neverconn.py round to pass (MIN_OK of the
|
||||
# GETs completed), the Uptime to advance by the wall time of each round (no reboot) and every settled heap within
|
||||
# LEAK_TOL bytes (default 4096) of the idle heap; exits 1 otherwise. env: TREE, PY, DEVICE, LEAK_TOL, MIN_OK
|
||||
D=${0:A:h}; N=$1; C=$2; H=$3; S=$D/..; cd $D
|
||||
T=${TREE:?set TREE}; PY=${PY:-$T/venv/bin/python}; TOL=${LEAK_TOL:-4096}; FAILS=0
|
||||
val() { curl -s -m 4 "http://$H/sensor/$1" | grep -o '"value":[0-9]*' | cut -d: -f2; }
|
||||
heap() { val Heap%20free; }
|
||||
$S/pio_build.sh upload $N $D/$C ${DEVICE:-$H} || exit 1
|
||||
for _ in $(seq 1 40); do curl -s -m 3 -o /dev/null http://$H/ && break; sleep 3; done; sleep 15
|
||||
IDLE=$(heap); echo "$N idle heap: $IDLE"; [ -n "$IDLE" ] || { echo "FAIL: no Heap free reading"; exit 1; }
|
||||
for r in rst rst rst head; do
|
||||
ub=$(val Uptime); t0=$SECONDS; hb=$(heap)
|
||||
res=$($PY -I $D/neverconn.py $H 300 $r 2>&1) || { echo "FAIL: neverconn.py $r"; FAILS=$((FAILS + 1)); }
|
||||
sleep 3; ha=$(heap); sleep 30; hs=$(heap); ua=$(val Uptime)
|
||||
echo "$N $r: ${res//$'\n'/ } | before $hb | after $ha | settled $hs | uptime $ub -> $ua"
|
||||
# A reboot during the round leaves the uptime short of the wall time that passed.
|
||||
[ -n "$ub" ] && [ -n "$ua" ] && [ $((ua - ub)) -ge $((SECONDS - t0 - 10)) ] ||
|
||||
{ echo "FAIL: uptime ${ub:-none} -> ${ua:-none} in $((SECONDS - t0)) s (reboot?)"; FAILS=$((FAILS + 1)); }
|
||||
[ -n "$hs" ] && [ $((IDLE - hs)) -le $TOL ] || { echo "FAIL: settled heap ${hs:-none} vs idle $IDLE"; FAILS=$((FAILS + 1)); }
|
||||
done
|
||||
[ $FAILS = 0 ] || exit 1
|
||||
echo PASS
|
||||
@@ -0,0 +1,67 @@
|
||||
"""neverconn.py HOST N [rst|head]: open N /events connections that never complete the SSE connect.
|
||||
|
||||
rst (default) sends the GET and resets at once (SO_LINGER 0), before the response head is ACKed, after one probe
|
||||
GET confirms /events answers HTTP/1.1 200 (a refused path would make every reset count); head reads the
|
||||
status line of the response head, then resets. Prints the counts of completed GETs (head: with a 200 status) and of
|
||||
each failure; exits 1 when fewer than MIN_OK (default 90%) of the N connections completed.
|
||||
env: MIN_OK (fraction)
|
||||
"""
|
||||
|
||||
from collections import Counter
|
||||
import os
|
||||
import socket
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
|
||||
host, n = sys.argv[1], int(sys.argv[2])
|
||||
mode = sys.argv[3] if len(sys.argv) > 3 else "rst"
|
||||
ok = 0
|
||||
errs: Counter[str] = Counter()
|
||||
if mode == "rst":
|
||||
try:
|
||||
with socket.create_connection((host, 80), timeout=3) as p:
|
||||
p.sendall(
|
||||
b"GET /events HTTP/1.1\r\nHost: x\r\nAccept: text/event-stream\r\n\r\n"
|
||||
)
|
||||
got = b""
|
||||
while len(got) < 12 and (d := p.recv(16 - len(got))):
|
||||
got += d
|
||||
except OSError as e:
|
||||
sys.exit(f"FAIL: the /events probe failed: {e}")
|
||||
if not got.startswith(b"HTTP/1.1 200"):
|
||||
sys.exit(
|
||||
f"FAIL: /events answered {got!r}, so the resets would not reach the SSE path"
|
||||
)
|
||||
for _ in range(n):
|
||||
s = socket.socket()
|
||||
s.settimeout(3)
|
||||
step = "connect"
|
||||
try:
|
||||
s.connect((host, 80))
|
||||
step = "send"
|
||||
s.sendall(
|
||||
b"GET /events HTTP/1.1\r\nHost: x\r\nAccept: text/event-stream\r\n\r\n"
|
||||
)
|
||||
if mode == "head":
|
||||
step = "recv"
|
||||
got = b""
|
||||
while len(got) < 12 and (d := s.recv(16 - len(got))):
|
||||
got += d
|
||||
if not got:
|
||||
errs["recv_eof"] += 1
|
||||
continue
|
||||
# a refused stream (401, 503) never ran the SSE path under test
|
||||
if not got.startswith(b"HTTP/1.1 200"):
|
||||
errs["status"] += 1
|
||||
continue
|
||||
s.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack("ii", 1, 0))
|
||||
ok += 1
|
||||
except OSError:
|
||||
errs[step] += 1
|
||||
finally:
|
||||
s.close()
|
||||
time.sleep(0.15)
|
||||
print(f"completed={ok}/{n} failed={dict(errs)}")
|
||||
if ok < n * float(os.environ.get("MIN_OK", "0.9")):
|
||||
sys.exit(f"FAIL: only {ok}/{n} {mode} connections completed")
|
||||
@@ -0,0 +1,112 @@
|
||||
"""pcapsum.py PCAP DEVICE_IP: per TCP connection to port 80, device data segments, last data time and seq, retransmits,
|
||||
FIN/RST and who sent them, windows, and anything sent by the device after its last data. Uses tcpdump -tt text.
|
||||
Exits 1 when the capture has no TCP packet. packets() is shared with stallctr.py."""
|
||||
|
||||
from collections.abc import Iterator
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
RX = re.compile(
|
||||
r"^(\d+\.\d+) IP (\S+)\.(\d+) > (\S+)\.(\d+): Flags \[([^\]]*)\](?:, seq (\d+)(?::(\d+))?)?(?:, ack (\d+))?, win (\d+).*length (\d+)"
|
||||
)
|
||||
|
||||
|
||||
def packets(pcap: str, dev: str) -> Iterator[dict]:
|
||||
"""Each TCP packet in PCAP as a dict; port is the host side's port, from_dev tells the direction."""
|
||||
r = subprocess.run(
|
||||
["tcpdump", "-n", "-tt", "-S", "-r", pcap],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
check=False,
|
||||
)
|
||||
if r.returncode != 0:
|
||||
sys.exit(f"tcpdump -r {pcap} failed: {r.stderr.strip()}")
|
||||
skipped = parsed = 0
|
||||
for line in r.stdout.splitlines():
|
||||
m = RX.match(line)
|
||||
if not m:
|
||||
skipped += " IP " in line and "Flags [" in line
|
||||
continue
|
||||
parsed += 1
|
||||
t, sip, sp, _dip, dp, fl, s1, s2, ack, win, ln = m.groups()
|
||||
from_dev = sip == dev
|
||||
yield {
|
||||
"t": float(t),
|
||||
"from_dev": from_dev,
|
||||
"port": dp if from_dev else sp,
|
||||
"flags": fl,
|
||||
"seq": (s1, s2),
|
||||
"ack": int(ack) if ack else None,
|
||||
"win": int(win),
|
||||
"len": int(ln),
|
||||
"line": line,
|
||||
}
|
||||
if skipped:
|
||||
# on stdout, so a summary built from part of the capture says so
|
||||
print(f"warning: {skipped} TCP lines did not parse", flush=True)
|
||||
if skipped and not parsed:
|
||||
sys.exit("no TCP line parsed; the tcpdump output format differs")
|
||||
|
||||
|
||||
def main(pcap: str, dev: str) -> None:
|
||||
conns: dict[str, dict] = {}
|
||||
for k in packets(pcap, dev):
|
||||
t = k["t"]
|
||||
c = conns.setdefault(
|
||||
k["port"],
|
||||
{
|
||||
"t0": t,
|
||||
"data": 0,
|
||||
"bytes": 0,
|
||||
"last_data": None,
|
||||
"last_seq": None,
|
||||
"seen": set(),
|
||||
"retx": 0,
|
||||
"fin": [],
|
||||
"rst": [],
|
||||
"cwin": [],
|
||||
"dwin": [],
|
||||
"after": [],
|
||||
"last_ack_from_client": None,
|
||||
"http": None,
|
||||
},
|
||||
)
|
||||
if "GET /" in k["line"] and not k["from_dev"]:
|
||||
c["http"] = k["line"].split("HTTP: ")[-1][:20]
|
||||
if k["from_dev"]:
|
||||
c["dwin"].append(k["win"])
|
||||
if k["len"] > 0:
|
||||
if k["seq"] in c["seen"]:
|
||||
c["retx"] += 1
|
||||
c["seen"].add(k["seq"])
|
||||
c["data"] += 1
|
||||
c["bytes"] += k["len"]
|
||||
c["last_data"] = t
|
||||
c["last_seq"] = int(k["seq"][1])
|
||||
c["after"] = []
|
||||
else:
|
||||
c["after"].append((round(t - c["t0"], 3), k["flags"]))
|
||||
else:
|
||||
c["cwin"].append(k["win"])
|
||||
if k["ack"] is not None:
|
||||
c["last_ack_from_client"] = k["ack"]
|
||||
who = "dev" if k["from_dev"] else "host"
|
||||
if "F" in k["flags"]:
|
||||
c["fin"].append((who, round(t - c["t0"], 3)))
|
||||
if "R" in k["flags"]:
|
||||
c["rst"].append((who, round(t - c["t0"], 3)))
|
||||
if not conns:
|
||||
sys.exit(f"no TCP packets in {pcap}")
|
||||
for p, c in conns.items():
|
||||
ld = round(c["last_data"] - c["t0"], 3) if c["last_data"] else None
|
||||
print(
|
||||
f"port {p} {c['http']}: dev data segs={c['data']} bytes={c['bytes']} last_data=+{ld}s "
|
||||
f"last_dev_seq_end={c['last_seq']} host_last_ack={c['last_ack_from_client']} retx={c['retx']} "
|
||||
f"FIN={c['fin']} RST={c['rst']} host_win=[{min(c['cwin'] or [0])},{max(c['cwin'] or [0])}] "
|
||||
f"dev_win=[{min(c['dwin'] or [0])},{max(c['dwin'] or [0])}] dev_ctrl_after_last_data={c['after'][:4]}"
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main(sys.argv[1], sys.argv[2])
|
||||
@@ -0,0 +1,8 @@
|
||||
# Pico 2 W on the station network (name set with -s name).
|
||||
rp2:
|
||||
board: rpipico2w
|
||||
wifi:
|
||||
ssid: !secret wifi_ssid
|
||||
password: !secret wifi_password
|
||||
packages:
|
||||
common: !include rp-common.yaml
|
||||
Loaded 100 of 707 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user