9 Commits
Author SHA1 Message Date
jimmyandCursor 2961ad2a29 test(editor): web serial readuntil buffer regression
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-05-25 22:00:20 +12:00
jimmyandCursor 35c0df8f88 docs: update readme for serial baud and deploy paths
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-05-25 22:00:20 +12:00
jimmyandCursor 5c97fa0d0b feat(editor): add bridge ap ip and password fields
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-05-25 22:00:20 +12:00
jimmyandCursor 179ac9c540 feat(cli): add --serial-baudrate for bridge uart uplink
Co-authored-by: Cursor <cursoragent@cursor.com>
2026-05-25 22:00:14 +12:00
jimmyandCursor bd4d2060ae fix(led-tool): harden Web Serial raw REPL connect
Improve boot wait, readUntil buffer handling, and settings editor
host/Web Serial flows after device reset.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-05-19 00:23:08 +12:00
jimmyandCursor f74e21f206 feat(led-tool): browser settings editor with Web Serial
Add static editor, host_ports filtering, Flask /editor and REST APIs
for ports and led-cli read/write; document standalone and embedded use.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-05-18 14:54:15 +12:00
jimmyandCursor 1edcb8b1f7 feat(cli): skip unchanged files using device file_hashes.json
Read and update file_hashes.json on deploy; add --force-upload and tests.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-05-17 19:14:51 +12:00
jimmyandCursor ccc215acbd fix(cli): lazy settings fetch and full device erase
Download settings only for --show or when applying edits; skip upload
when unchanged; erase entire device root including settings.json.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-05-16 21:14:54 +12:00
jimmyandCursor 580fd11aca fix(cli): skip redundant settings uploads when unchanged
Only upload settings when edited values differ from current device settings to avoid unnecessary resets.

Co-authored-by: Cursor <cursoragent@cursor.com>
2026-05-04 22:48:54 +12:00
15 changed files with 1900 additions and 1188 deletions

No files matched your search

+40 -144
View File
@@ -1,164 +1,60 @@
# led-tool
Command-line tool for the LED drivers. It configures both firmwares found in this repo, and updates their firmware:
CLI helpers for MicroPython LED devices: **`settings.json`** download/upload via **mpremote**, resets, follow/tail, recursive uploads, optional firmware flash, and **led-driver**-oriented flags (presets, transport, Wi-Fi fields).
- **ESP-IDF led-driver** (ESP32-C3): settings, patterns and presets over **USB** or **Wi-Fi**. Changes apply live, so no reset is needed.
- **MicroPython driver**: `settings.json`, presets and files over USB (via mpremote). Changes need a reset to apply.
Connection is always via **`-p` / `--port`** (default `/dev/ttyACM0`). There is **no** separate “server IP” flag; the Pi or PC address is configured on the device in **`settings.json`** when using Wi-Fi mode.
The tool detects the firmware on the serial port. Use `--driver idf` or `--driver mpy` to skip detection.
## Common flags
Run `python cli.py -h` for every flag, grouped by firmware, with examples at the end.
| Flag | Purpose |
|------|--------|
| `-p`, `--port` | Serial device (default `/dev/ttyACM0`) |
| `-s`, `--show` | Print current settings from the device |
| `-n`, `--name` | Device **name** |
| `--reset-device-name` | Set **name** to firmware default (`led-` + STA MAC hex, same as `Settings.set_defaults` on led-driver) |
| `--id` | Numeric device id (ESP-NOW, 0–255) |
| `--pin` | LED GPIO (`led_pin`) |
| `-b`, `--brightness` | Brightness 0–255 |
| `-l`, `--leds` | LED count (`num_leds`) |
| `-d`, `--debug` | Debug 0 or 1 |
| `-o`, `--order` | LED colour order (`rgb`, `grb`, …) |
| `--preset` / `--pattern` | Create or replace a named preset in **led-driver** `presets.json` |
| `--default` | Startup preset name |
| `--transport` | `espnow` or `wifi` (`transport_type` on led-driver) |
| `--serial-baudrate` | Bridge UART1 baud for Pi serial link (e.g. `921600`; also sets GPIO UART pins) |
| `--ssid`, `--wifi-password`, `--wifi-channel` | Wi-Fi / channel fields for the driver |
| `-r`, `--reset` | Reset the device |
| `-f`, `--follow` | Follow serial output (optional timeout seconds) |
| `--pause` | Sleep N seconds (for chained actions) |
| `-u`, `--upload` | Recursive upload: `-u SRC [DEST]` (skips unchanged files via `file_hashes.json` on device) |
| `--src`, `--lib`, `--all` | Deploy `src/` to device root and `lib/` to `/lib` (led-driver, espnow-sender, …) |
| `--force-upload` | Upload every file; ignore `file_hashes.json` |
| `-e`, `--erase` | Erase everything at device root (including `settings.json` and `presets.json`) |
| `--rm` | Remove a path on the device |
| `--flash` | Flash a firmware binary (uses **esptool** on the host) |
## Connecting
**Settings I/O:** With no arguments, **`led-cli`** prints help (no device access). **`--show`** downloads `settings.json` and prints it (read-only). Setting fields (`--name`, `-b`, …) download once, merge, print, and **upload only when a value actually changed**. **`--preset`** alone only touches **`presets.json`** (no `settings.json` download). Ordered actions (`--reset`, `--upload`, `-e`, …) run without touching settings unless you also pass **`--show`** or setting / preset edits as above.
| Connection | Flag | Notes |
|---|---|---|
| USB serial (default) | `-p`, `--port` | Default `/dev/ttyACM0`. Opening the port keeps DTR high and RTS low, so the C3 is not reset on connect. |
| Wi-Fi | `--host ADDR` | IP or name of an ESP-IDF driver, for example `--host 192.168.4.20` or `--host bar1.local`. Port 80. |
Run **`python cli.py -h`** for the full epilog and argument list.
Over `--host` every settings, pattern and preset flag works the same as over USB. Two flags need USB: `-r` (reboot) and `-f` (follow the serial log). MicroPython is USB only.
## Web UI (`static/` + `web.py`)
## ESP-IDF led-driver
Edit **`settings.json`** in the browser:
### Settings (USB or Wi-Fi)
- **Web Serial** — USB on the machine running the browser (Chrome/Edge). Use **Connect USB**, then **Download** / **Upload**.
- **Host serial** — USB on the Pi/PC running **`led-cli`** (port list + **`led-cli`** merge/upload).
| Flag | Setting |
|---|---|
| `--pin`, `-l`, `-o`, `--max-brightness` | LED GPIO, LED count, colour order, global ceiling |
| `-b` | Brightness |
| `-n NAME`, `--reset-device-name` | Hostname (mDNS `NAME.local`); reset gives `led` |
| `--ap on\|off`, `--ap-ssid NAME`, `--ap-password PASS` | Access point (empty name: `led-XXXXXX`; empty password: open) |
| `--ddp on\|off` | Receive DDP pixels and frame sync |
| `--dhcp`, `--static IP NETMASK GATEWAY [DNS]`, `--dns ADDR` | Wi-Fi client address |
| `--ssid SSID`, `--wifi-password PASS` | Wi-Fi network to join; the device reconnects |
| `--default NAME` | Startup preset (runs at boot) |
| `--scan` | List the Wi-Fi networks the device can see |
`-s` shows the settings: hardware, brightness, network, Wi-Fi SSID and the startup preset. It is printed after any change.
Network changes can move the device to a new address. If you change `--static` or `--dhcp` over `--host`, the next command needs the new address.
### Patterns and presets (USB or Wi-Fi)
Presets are saved on the device. Patterns named with `--play` or `--pattern` are the driver's own names; see `--list-patterns`.
| Flag | Does |
|---|---|
| `--list-patterns` | Print the pattern names the driver has |
| `--list-presets` | Print the saved preset names, with the startup one marked |
| `--preset NAME [--pattern P] [options]` | Create or replace a saved preset. Only the fields given are changed. |
| `--play PATTERN [options]` | Show a pattern now, without saving it |
| `--select NAME` | Show a saved preset now |
| `--delete NAME` | Delete a saved preset |
| `--preset-order NAME [NAME ...]` | Set the order of the saved presets |
| `--presets-defaults` | Add the default presets that are missing |
Options for `--preset` and `--play`:
| Option | Meaning |
|---|---|
| `--colors HEX [HEX ...]` | Colours, for example `#ff0000 #00ff00` |
| `--background HEX` | Background colour |
| `--delay MS` | Delay between steps |
| `--preset-brightness 0-255` | Brightness of this preset (not the global level) |
| `--fade MS` | Fade time |
| `--reverse on\|off` | Run in reverse |
| `--auto on\|off` | Autorun flag |
| `--beat-time on\|off` | Time the pattern to the beat |
`--preset` and `--play` cannot be used together. Options given without one of them are an error.
Not yet exposed: the preset's numeric parameters `n1`–`n4` and `mode`.
```bash
python cli.py --list-presets
python cli.py --preset warm --pattern chase --colors '#ff0000' '#00ff00' --delay 50 --default warm
python cli.py --select warm
python cli.py --play rainbow --fade 200
python cli.py --host 192.168.4.20 --preset warm --pattern solid --colors '#ffa000'
```
### Reboot and logs (USB only)
```bash
python cli.py -r # reboot
python cli.py -f # follow the serial log, Ctrl+C to stop
python cli.py -r --pause 2 -f
```
## Firmware updates
Both update over Wi-Fi with the driver's `/ota` endpoint. The image is always given explicitly for LED drivers.
| Flag | Does |
|---|---|
| `--ota HOST [IMAGE]` | Update one **v2 controller** (ESP32-S3, Ethernet). Image defaults to `led_controller_v2.bin` under `./v2/build`, `./build` or `../v2/build`. |
| `--ota-drivers [TARGET ...]` | Find ESP-IDF LED drivers in the given targets and update them in parallel. Default `auto` is this machine's `/24`. See the target forms below. |
| `--ota-image PATH` | Driver firmware for `--ota-drivers`. **Required**, for example `../led-driver/build/led_driver.bin`. |
| `--ota-jobs N` | Simultaneous uploads (default 4). |
| `--ota-list` | Only find and list the drivers; do not update. |
Targets:
| Form | Scans |
|---|---|
| `auto` | This machine's `/24` (default) |
| `192.168.4` | The `/24`, the same as `192.168.4.0/24` |
| `10.0.0.0/23` | A CIDR network (up to 4096 addresses per run) |
| `192.168.4.10-40` or `192.168.4.10-192.168.4.40` | An inclusive address range |
| `192.168.4.25` | One address |
Give several targets separated by spaces or commas. Duplicates are scanned once. A run can probe at most 4096 addresses; larger targets are refused, so narrow them.
**Standalone (Flask):**
```bash
cd led-tool
python cli.py --ota-drivers --ota-image ../led-driver/build/led_driver.bin
python cli.py --ota-drivers 192.168.4.10-40 --ota-list
python cli.py --ota-drivers 192.168.4.0/24 10.0.0.0/25 --ota-jobs 2 --ota-image ../led-driver/build/led_driver.bin
python cli.py --ota-drivers 192.168.4.10-40,192.168.5.7 --ota-image ../led-driver/build/led_driver.bin
python web.py
# open http://<host>:5000/editor
```
`--ota-drivers` probes `GET /ota` on each address in the targets, so it only finds devices that run the driver firmware. Drivers are reported with their partition and build; a driver that comes back on the same partition is reported as a failure.
**Embedded in led-controller:** open **Settings → LED Tool** in the main UI (Edit mode), or visit **`/led-tool/editor`**.
Build the driver image first with `make build` in `led-driver`.
## MicroPython driver
These flags apply to the MicroPython driver only, and are rejected when an ESP-IDF driver answers.
| Flag | Does |
|---|---|
| `-n NAME`, `-l N`, `-b`, `-o`, `--pin` | Settings written to `settings.json` |
| `--preset NAME --pattern P` | Create or replace a preset in `presets.json` (patterns: off, on, blink, rainbow, pulse, transition, chase, circle) |
| `--default NAME` | Startup preset |
| `--transport espnow\|wifi`, `--ssid`, `--wifi-password`, `--wifi-channel`, `--id`, `-d` | Transport and radio settings |
| `-u SRC [DEST]`, `--src [DIR]`, `--lib [DIR]`, `--patterns [DIR]`, `--all` | Upload directories to the device |
| `--ls`, `--rm PATH`, `-e` | List, delete or erase files on the device |
| `--flash BINARY` | Flash a firmware binary with esptool (path, or a filename in `bin/`) |
| `--reset-device-name` | Name becomes `led-` + the STA MAC |
Without setting edits, the tool downloads `settings.json` and prints the merged view. It uploads again only when you pass edits, `--preset`, or an upload, flash or erase action. Actions run in the order given on the command line, for example `--reset --pause 2 --follow`.
## Installing
`install.sh` installs the Python dependencies with pipenv, builds `dist/led-cli` with PyInstaller, and copies it to `~/.local/bin`.
```bash
./install.sh
```
Run from source with `python cli.py` after `pipenv install`.
## Files
| File | Purpose |
|---|---|
| `cli.py` | Argument parsing and the commands for both firmwares |
| `idf_device.py` | ESP-IDF API over USB (`@api` lines on the serial port) |
| `http_device.py` | The same ESP-IDF API over Wi-Fi (`--host`) |
| `device.py` | MicroPython device access via mpremote |
| `ota.py` | Firmware upload to one device, used by `--ota` and `--ota-drivers` |
| `driver_ota.py` | Discovery of ESP-IDF drivers on a subnet and parallel update |
Legacy Flask form UI remains at **`/`** on port 5000; prefer **`/editor`** for Web Serial support.
## License
+208 -551
View File
File diff suppressed because it is too large. Load diff
+45
View File
@@ -0,0 +1,45 @@
"""
Host-side helpers for file_hashes.json (same format as led-driver/src/file_hashes.py).
"""
import hashlib
import json
import os
MANIFEST_VERSION = 1
MANIFEST_FILENAME = "file_hashes.json"
HASH_ALGO = "sha256"
def normalize_remote_path(remote_file: str) -> str:
"""Device-relative path with forward slashes (no leading slash)."""
return remote_file.replace("\\", "/").lstrip("/")
def sha256_hex_file(path: str) -> str:
h = hashlib.sha256()
with open(path, "rb") as f:
for chunk in iter(lambda: f.read(65536), b""):
h.update(chunk)
return h.hexdigest()
def parse_manifest(data: bytes) -> dict:
"""Return path -> hash map from manifest bytes."""
try:
doc = json.loads(data.decode("utf-8"))
except (UnicodeDecodeError, json.JSONDecodeError, TypeError, ValueError):
return {}
if not isinstance(doc, dict):
return {}
files = doc.get("files")
return dict(files) if isinstance(files, dict) else {}
def build_manifest_bytes(files: dict) -> bytes:
doc = {
"version": MANIFEST_VERSION,
"algorithm": HASH_ALGO,
"files": files,
}
return json.dumps(doc, separators=(",", ":")).encode("utf-8")
+57 -12
View File
@@ -10,6 +10,14 @@ import os
import time
import serial
from deploy_manifest import (
MANIFEST_FILENAME,
build_manifest_bytes,
normalize_remote_path,
parse_manifest,
sha256_hex_file,
)
# Add lib directory to path - handle both normal execution and PyInstaller bundle
if getattr(sys, 'frozen', False):
# Running as a PyInstaller bundle
@@ -109,26 +117,47 @@ class DeviceConnection:
finally:
self.disconnect()
def upload_directory(self, local_dir, remote_dir=None):
def _manifest_remote_path(self) -> str:
return "/" + MANIFEST_FILENAME
def read_hash_manifest(self) -> dict:
"""Load path -> sha256 hex map from file_hashes.json on the device."""
remote = self._manifest_remote_path()
if not self.transport.fs_exists(remote):
return {}
try:
data = self.transport.fs_readfile(remote)
return parse_manifest(data)
except Exception:
return {}
def write_hash_manifest(self, files: dict) -> None:
"""Write merged file_hashes.json to the device root."""
self._fs_writefile_with_wdt(
self._manifest_remote_path(),
build_manifest_bytes(files),
)
def upload_directory(self, local_dir, remote_dir=None, *, force: bool = False):
"""
Upload a directory recursively to the device.
Skips files whose sha256 matches file_hashes.json on the device unless
force is True. Updates the manifest after upload.
Args:
local_dir: Local directory path to upload
remote_dir: Remote directory path (default: root, uses basename of local_dir)
force: Upload every file even when the manifest hash matches
Returns:
(files_copied, dirs_created, files_skipped)
"""
import os
if not os.path.isdir(local_dir):
raise ValueError(f"{local_dir} is not a directory")
# Host bytecode must never reach the device: remove it before uploading.
import shutil
for root, dirs, _files in os.walk(local_dir):
for d in [d for d in dirs if d == "__pycache__"]:
shutil.rmtree(os.path.join(root, d), ignore_errors=True)
dirs.remove(d)
self.connect()
try:
# Determine remote directory name
@@ -136,15 +165,19 @@ class DeviceConnection:
remote_dir = os.path.basename(os.path.abspath(local_dir))
# Ensure remote directory exists
if not self.transport.fs_exists(remote_dir):
if remote_dir and not self.transport.fs_exists(remote_dir):
self.transport.fs_mkdir(remote_dir)
manifest = {} if force else self.read_hash_manifest()
# Walk through local directory and copy files
files_copied = 0
files_skipped = 0
dirs_created = 0
for root, dirs, files in os.walk(local_dir):
# Calculate relative path from local_dir
# Never upload Python bytecode trees (MicroPython does not use them).
dirs[:] = [d for d in dirs if d != "__pycache__"]
rel_path = os.path.relpath(root, local_dir)
# Build remote path
@@ -163,10 +196,12 @@ class DeviceConnection:
self.transport.fs_mkdir(remote_base)
dirs_created += 1
# Copy files
# Copy files (skip bytecode; __pycache__ dirs are pruned above)
for file in files:
if file.endswith((".pyc", ".pyo")):
continue
if file == MANIFEST_FILENAME:
continue
local_file = os.path.join(root, file)
# Handle root directory case properly
if remote_base == '/':
@@ -174,13 +209,23 @@ class DeviceConnection:
else:
remote_file = '/'.join([remote_base, file])
manifest_key = normalize_remote_path(remote_file)
local_hash = sha256_hex_file(local_file)
if not force and manifest.get(manifest_key) == local_hash:
print(f"Skipping (unchanged): {remote_file}", file=sys.stderr)
files_skipped += 1
continue
print(f"Uploading: {remote_file}", file=sys.stderr)
with open(local_file, 'rb') as f:
data = f.read()
self._fs_writefile_with_wdt(remote_file, data)
manifest[manifest_key] = local_hash
files_copied += 1
return files_copied, dirs_created
self.write_hash_manifest(manifest)
return files_copied, dirs_created, files_skipped
finally:
self.disconnect()
-148
View File
@@ -1,148 +0,0 @@
"""
Find every LED driver on a Wi-Fi network or address range, and update them in parallel.
A driver answers GET /ota with its partition and build info, so discovery is a parallel probe
of each address in the targets. Each driver found then gets the same image, `jobs` at a time.
Uses ota.py for the per-device upload.
Targets (one or more, comma-separated or as separate arguments):
auto this machine's /24
192.168.4 a /24 (same as 192.168.4.0/24)
192.168.4.0/24 a CIDR network
192.168.4.10-192.168.4.40 an inclusive range
192.168.4.10-40 the same, short form
192.168.4.25 one address
"""
import concurrent.futures as cf
import ipaddress
import os
import socket
import sys
from typing import List, Optional, Tuple
from ota import _info, ota_update
# Largest number of addresses one run will probe, so a typo like 10.0.0.0/8 is refused
MAX_TARGETS = 4096
def local_subnet() -> str:
"""First three octets of the address this machine uses to reach the network."""
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
s.connect(("192.0.2.1", 9)) # UDP connect sends no packet
ip = s.getsockname()[0]
finally:
s.close()
return ".".join(ip.split(".")[:3])
def _ip(text: str) -> ipaddress.IPv4Address:
try:
return ipaddress.IPv4Address(text.strip())
except ValueError:
raise ValueError(f"not an IPv4 address: {text}") from None
def _expand(part: str) -> List[ipaddress.IPv4Address]:
"""One target (see the module docstring) -> the addresses it covers."""
if part == "auto":
part = local_subnet()
if "/" in part:
try:
net = ipaddress.IPv4Network(part, strict=False)
except ValueError:
raise ValueError(f"not a network: {part}") from None
if net.num_addresses > MAX_TARGETS:
raise ValueError(f"network too large (max {MAX_TARGETS} addresses): {part}")
return list(net.hosts()) if net.num_addresses > 2 else list(net)
if "-" in part:
first, last = part.split("-", 1)
start = _ip(first)
end = _ip(last) if last.count(".") == 3 else _ip(".".join(first.split(".")[:3] + [last]))
if int(end) < int(start):
raise ValueError(f"range ends before it starts: {part}")
if int(end) - int(start) >= MAX_TARGETS:
raise ValueError(f"range too large (max {MAX_TARGETS} addresses): {part}")
return [ipaddress.IPv4Address(i) for i in range(int(start), int(end) + 1)]
if part.count(".") == 2:
# Three octets: the whole /24, as before
return list(ipaddress.IPv4Network(part + ".0/24").hosts())
return [_ip(part)]
def parse_targets(specs: List[str]) -> List[str]:
"""All addresses named by the targets, in order, without duplicates."""
seen = set()
out: List[str] = []
for spec in specs:
for part in spec.split(","):
part = part.strip()
if not part:
continue
for addr in _expand(part):
if addr not in seen:
seen.add(addr)
out.append(str(addr))
if len(out) > MAX_TARGETS:
raise ValueError(f"too many addresses ({len(out)}; max {MAX_TARGETS}). Narrow the targets.")
return out
def discover(hosts: List[str], port: int = 80, workers: int = 64) -> List[Tuple[str, dict]]:
"""Probe each host for a driver. Returns (host, info) sorted by address."""
found = []
with cf.ThreadPoolExecutor(max_workers=workers) as pool:
futures = {pool.submit(_info, h, port): h for h in hosts}
for fut in cf.as_completed(futures):
info = fut.result()
if info:
found.append((futures[fut], info))
return sorted(found, key=lambda t: int(ipaddress.IPv4Address(t[0])))
def ota_drivers(specs: List[str], image: Optional[str], jobs: int, list_only: bool,
port: int = 80) -> int:
"""Discover drivers in the targets and update them. Returns a process exit code."""
if not list_only:
if not image or not os.path.isfile(image):
print(f"Error: image not found: {image}", file=sys.stderr)
return 1
try:
hosts = parse_targets(specs or ["auto"])
except ValueError as e:
print(f"Error: {e}", file=sys.stderr)
return 1
if not hosts:
print("Error: no addresses to scan", file=sys.stderr)
return 1
print(f"Scanning {len(hosts)} address(es) on port {port}: {hosts[0]} .. {hosts[-1]}", file=sys.stderr)
drivers = discover(hosts, port)
if not drivers:
print("No drivers found.", file=sys.stderr)
return 1
print(f"Found {len(drivers)} driver(s):", file=sys.stderr)
for host, info in drivers:
print(f" {host:<16} {info.get('partition', '?'):<8} built {info.get('built', '?')}", file=sys.stderr)
if list_only:
return 0
print(f"\nUpdating {len(drivers)} driver(s) with {image}, {jobs} at a time...", file=sys.stderr)
failed = []
with cf.ThreadPoolExecutor(max_workers=jobs) as pool:
futures = {pool.submit(ota_update, h, image, port): h for h, _ in drivers}
for fut in cf.as_completed(futures):
host = futures[fut]
try:
fut.result()
print(f"OK {host}", file=sys.stderr)
except Exception as e:
failed.append(host)
print(f"FAILED {host}: {e}", file=sys.stderr)
ok = len(drivers) - len(failed)
print(f"\n{ok} updated, {len(failed)} failed" + (f": {' '.join(failed)}" if failed else ""), file=sys.stderr)
return 1 if failed else 0
+25
View File
@@ -0,0 +1,25 @@
"""Host serial port list filtering for led-tool /ports API."""
import re
# Exclude /dev/ttyS2 and higher (keep ttyS0, ttyS1; keep ttyACM*, ttyUSB*, etc.)
_TTYS_HIGH = re.compile(r"^/dev/ttyS([2-9]|[1-9]\d+)$")
def include_host_serial_device(device: str) -> bool:
return not _TTYS_HIGH.match(device or "")
def _is_na(value: str) -> bool:
return (value or "").strip().lower() in ("n/a", "na")
def include_host_serial_port(port: dict) -> bool:
if not include_host_serial_device(port.get("device", "")):
return False
if _is_na(port.get("description")) or _is_na(port.get("hwid")):
return False
return True
def filter_port_dicts(ports: list) -> list:
return [p for p in ports if include_host_serial_port(p)]
-82
View File
@@ -1,82 +0,0 @@
"""
Wi-Fi connection to the ESP-IDF led-driver.
The driver serves the same JSON API over HTTP on its address (led-driver main/web.cpp) that it
serves over USB (main/usb_cfg.cpp). HttpDevice has the same get/post/call interface as
idf_device.IdfDevice, so the settings code in cli.py works for both transports.
Not available over Wi-Fi: reboot (no HTTP route) and following the serial log.
"""
import http.client
import json
import socket
from typing import Any, Optional, Tuple
from idf_device import IdfError
class HttpDevice:
def __init__(self, host: str, port: int = 80, timeout: float = 5.0):
self.host = host
self.port = port
self.timeout = timeout
def open(self) -> "HttpDevice":
return self
def close(self) -> None:
pass
def __enter__(self) -> "HttpDevice":
return self
def __exit__(self, *exc) -> None:
pass
def call_raw(self, method: str, path: str, body: Any = None, host: Optional[str] = None,
timeout: Optional[float] = None) -> Tuple[int, Any]:
"""Send one request; return (status, parsed body). Does not raise on an error status."""
if host is not None:
raise IdfError(0, "relay through the driver is USB-only; use --port for that")
conn = http.client.HTTPConnection(self.host, self.port, timeout=timeout or self.timeout)
headers = {}
data = None
if body is not None:
data = json.dumps(body, separators=(",", ":")).encode()
headers["Content-Type"] = "application/json"
try:
conn.request(method, path, body=data, headers=headers)
r = conn.getresponse()
text = r.read().decode("utf-8", "replace")
except socket.timeout as e:
raise TimeoutError(f"no reply from {self.host} to {method} {path}") from e
except OSError as e:
raise TimeoutError(f"cannot reach {self.host}: {e}") from e
finally:
conn.close()
try:
parsed = json.loads(text) if text else {}
except ValueError:
parsed = text
return r.status, parsed
def call(self, method: str, path: str, body: Any = None, **kw) -> Any:
"""Send one request; return the parsed body. Raises IdfError on status >= 400."""
status, parsed = self.call_raw(method, path, body, **kw)
if status >= 400:
msg = parsed.get("error") if isinstance(parsed, dict) else None
raise IdfError(status, msg or str(parsed))
return parsed
def get(self, path: str, **kw) -> Any:
return self.call("GET", path, **kw)
def post(self, path: str, body: Any, **kw) -> Any:
return self.call("POST", path, body, **kw)
def reboot(self) -> None:
raise IdfError(0, "reboot is not available over Wi-Fi; use -r with --port (USB)")
def follow(self, seconds: Optional[float] = None) -> None:
raise IdfError(0, "following the log is not available over Wi-Fi; use -f with --port (USB)")
-172
View File
@@ -1,172 +0,0 @@
"""
USB connection to the ESP-IDF led-driver (ESP32-C3).
The driver serves its JSON API on the USB serial port (led-driver main/usb_cfg.cpp):
@api {"id": n, "method": "GET" or "POST", "path": "/api/...", "body": {...}}
-> @api {"id": n, "status": 200, "body": "<JSON text>"}
@reboot -> @ok, then the device restarts
Every other line on the port is log output.
"""
import json
import sys
import time
from typing import Any, Dict, Optional, Tuple
import serial
API = "@api "
class IdfError(RuntimeError):
"""The device answered with an error status."""
def __init__(self, status: int, message: str):
super().__init__(f"{status}: {message}")
self.status = status
self.message = message
class IdfDevice:
def __init__(self, port: str, verbose: bool = False):
self.port = port
self.verbose = verbose
self._id = 0
self._ser: Optional[serial.Serial] = None
def open(self) -> "IdfDevice":
if self._ser is None:
ser = serial.Serial()
ser.port = self.port
ser.baudrate = 115200
ser.timeout = 0.1
# On the C3's USB-Serial-JTAG, RTS high with DTR low resets the chip. Linux raises both
# on open and pyserial then sets DTR before RTS, so DTR must stay high (DTR low first
# would pass through RTS high, DTR low and reset it). RTS low keeps it running.
ser.dtr = True
ser.rts = False
ser.open()
self._ser = ser
return self
def close(self) -> None:
if self._ser is not None:
self._ser.close()
self._ser = None
def __enter__(self) -> "IdfDevice":
return self.open()
def __exit__(self, *exc) -> None:
self.close()
def _log(self, line: str) -> None:
if self.verbose and line:
print(f"[device] {line}", file=sys.stderr)
def _readline(self, deadline: float) -> Optional[str]:
"""One line from the device, or None at the deadline."""
buf = b""
while time.monotonic() < deadline:
chunk = self._ser.readline()
if not chunk:
continue
buf += chunk
if buf.endswith(b"\n"):
return buf.decode("utf-8", "replace").rstrip("\r\n")
return None
def call_raw(self, method: str, path: str, body: Any = None, host: Optional[str] = None,
timeout: float = 3.0) -> Tuple[int, Any]:
"""Send one request; return (status, parsed body). Does not raise on an error status."""
self.open()
self._id += 1
msg: Dict[str, Any] = {"id": self._id, "method": method, "path": path}
if body is not None:
msg["body"] = body
if host:
msg["host"] = host
self._ser.reset_input_buffer()
self._ser.write(("\n" + API + json.dumps(msg, separators=(",", ":")) + "\n").encode())
self._ser.flush()
deadline = time.monotonic() + timeout
while True:
line = self._readline(deadline)
if line is None:
raise TimeoutError(f"no reply from {self.port} to {method} {path}")
at = line.find(API + "{")
if at < 0:
self._log(line)
continue
if at > 0:
self._log(line[:at])
try:
env = json.loads(line[at + len(API):])
except ValueError:
continue
if env.get("id") != self._id:
continue
text = env.get("body", "")
try:
parsed = json.loads(text) if text else {}
except ValueError:
parsed = text
return int(env.get("status", 0)), parsed
def call(self, method: str, path: str, body: Any = None, **kw) -> Any:
"""Send one request; return the parsed body. Raises IdfError on status >= 400."""
status, parsed = self.call_raw(method, path, body, **kw)
if status >= 400:
msg = parsed.get("error") if isinstance(parsed, dict) else None
raise IdfError(status, msg or str(parsed))
return parsed
def get(self, path: str, **kw) -> Any:
return self.call("GET", path, **kw)
def post(self, path: str, body: Any, **kw) -> Any:
return self.call("POST", path, body, **kw)
def reboot(self) -> None:
"""Restart the device: the @reboot command, or an RTS reset pulse if it doesn't answer."""
self.open()
self._ser.reset_input_buffer()
self._ser.write(b"\n@reboot\n")
self._ser.flush()
deadline = time.monotonic() + 1.5
while True:
line = self._readline(deadline)
if line is None:
break
if line.strip() == "@ok":
return
self._log(line)
# Hardware reset: RTS high with DTR low holds the chip in reset (DTR low alone would
# mean "boot mode" at release, so RTS goes low first)
self._ser.rts = True
self._ser.dtr = False
time.sleep(0.1)
self._ser.rts = False
self._ser.dtr = True
def follow(self, seconds: Optional[float] = None) -> None:
"""Print the device's output until Ctrl+C, or for SECONDS."""
self.open()
end = time.monotonic() + seconds if seconds is not None else None
while end is None or time.monotonic() < end:
chunk = self._ser.read(256)
if chunk:
sys.stdout.write(chunk.decode("utf-8", "replace"))
sys.stdout.flush()
def probe(port: str, timeout: float = 1.0) -> bool:
"""True if an ESP-IDF led-driver answers the USB API on PORT."""
try:
with IdfDevice(port) as dev:
dev.call_raw("GET", "/api/status", timeout=timeout)
return True
except (TimeoutError, serial.SerialException, OSError):
return False
-77
View File
@@ -1,77 +0,0 @@
"""
Over-the-air firmware update for the v2 ESP32-S3 controller (Ethernet, plain HTTP).
The controller takes the raw app image on POST /ota, writes it to the idle slot and reboots.
"""
import http.client
import json
import os
import time
from typing import Optional
IMAGE_NAME = "led_controller_v2.bin"
# Searched in order when no image is given (relative to where the tool is run, since the
# PyInstaller binary has no useful location of its own)
DEFAULT_IMAGES = [
os.path.join("v2", "build", IMAGE_NAME),
os.path.join("build", IMAGE_NAME),
os.path.join("..", "v2", "build", IMAGE_NAME),
]
def _default_image() -> Optional[str]:
return next((p for p in DEFAULT_IMAGES if os.path.isfile(p)), None)
def _info(host: str, port: int) -> Optional[dict]:
try:
conn = http.client.HTTPConnection(host, port, timeout=5)
conn.request("GET", "/ota")
r = conn.getresponse()
return json.loads(r.read().decode()) if r.status == 200 else None
except (OSError, ValueError):
return None
def ota_update(host: str, image: Optional[str] = None, port: int = 80) -> None:
"""Upload image to host and wait for it to come back. Raises RuntimeError on failure."""
image = image or _default_image()
if not image:
raise RuntimeError(f"no image given and {IMAGE_NAME} not found under ./v2/build, ./build or ../v2/build")
if not os.path.isfile(image):
raise RuntimeError(f"image not found: {image}")
size = os.path.getsize(image)
before = _info(host, port)
if before is None:
raise RuntimeError(f"no OTA endpoint at http://{host}:{port}/ota (is this an LED device?)")
print(f"Running {before['partition']} (built {before['built']})")
print(f"Uploading {image} ({size} bytes)...")
conn = http.client.HTTPConnection(host, port, timeout=60)
with open(image, "rb") as f:
conn.request("POST", "/ota", body=f, headers={
"Content-Length": str(size),
"Content-Type": "application/octet-stream",
})
r = conn.getresponse()
body = r.read().decode()
if r.status != 200:
try:
body = json.loads(body).get("error", body)
except ValueError:
pass
raise RuntimeError(f"update rejected ({r.status}): {body}")
print("Written, waiting for reboot...")
time.sleep(3)
for _ in range(30):
after = _info(host, port)
if after:
print(f"Back up on {after['partition']} (built {after['built']})")
if after["partition"] == before["partition"]:
raise RuntimeError("controller came back on the same slot: new image was rejected or rolled back")
return
time.sleep(1)
raise RuntimeError("controller did not come back within 30 s")
+218
View File
@@ -0,0 +1,218 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>LED device settings</title>
<meta name="viewport" content="width=device-width, initial-scale=1" />
<style>
:root {
color-scheme: dark;
--text: #e5e7eb;
--muted: #9ca3af;
--border: #374151;
--accent: #3b82f6;
--danger: #f87171;
}
* { box-sizing: border-box; }
body {
margin: 0;
font-family: system-ui, sans-serif;
background: #0b1020;
color: var(--text);
padding: 1rem;
}
h1 { font-size: 1.15rem; margin: 0 0 0.35rem; }
.muted { color: var(--muted); font-size: 0.9rem; margin-bottom: 1rem; }
.card {
border: 1px solid var(--border);
border-radius: 8px;
padding: 1rem;
margin-bottom: 1rem;
background: #111827;
}
label { display: block; font-size: 0.85rem; margin-bottom: 0.25rem; color: var(--muted); }
input, select, textarea {
width: 100%;
padding: 0.5rem;
border-radius: 4px;
border: 1px solid var(--border);
background: #1f2937;
color: var(--text);
margin-bottom: 0.65rem;
}
.row { display: flex; gap: 0.5rem; flex-wrap: wrap; align-items: flex-end; }
.row > * { flex: 1; min-width: 10rem; }
.btn {
padding: 0.45rem 0.85rem;
border: none;
border-radius: 4px;
cursor: pointer;
background: #4b5563;
color: #fff;
font-size: 0.9rem;
}
.btn-primary { background: var(--accent); }
.btn:disabled { opacity: 0.5; cursor: not-allowed; }
.grid {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(11rem, 1fr));
gap: 0 0.5rem;
}
#status { font-size: 0.85rem; margin-top: 0.5rem; }
#status.error { color: var(--danger); }
.flash {
display: none;
padding: 0.5rem 0.75rem;
border-radius: 4px;
margin-bottom: 0.75rem;
background: #14532d;
color: #86efac;
}
.flash.error { background: #5e1b1b; color: #fca5a5; }
.flash.show { display: block; }
[hidden] { display: none !important; }
</style>
</head>
<body data-api-base="/led-tool">
<h1>Device settings (USB)</h1>
<p class="muted">Edit <code>settings.json</code> via <strong>Web Serial</strong> (USB on this computer) or <strong>host serial</strong> (Pi running <code>led-cli</code>). Use <strong>Connect</strong> for your transport, then <strong>Download</strong> or <strong>Upload</strong>.</p>
<div id="flash" class="flash"></div>
<div class="card" id="webserial-wrap" hidden>
<h2 style="font-size:1rem;margin:0 0 0.5rem;">Web Serial</h2>
<div class="row">
<button type="button" class="btn btn-primary" id="webserial-connect">Connect USB</button>
<button type="button" class="btn" id="webserial-disconnect" hidden>Disconnect</button>
</div>
</div>
<div class="card" id="host-serial-wrap">
<h2 style="font-size:1rem;margin:0 0 0.5rem;">Host serial</h2>
<label for="host-port">Port</label>
<select id="host-port"><option value="">Select port</option></select>
<div class="row">
<button type="button" class="btn btn-primary" id="host-connect">Connect</button>
<button type="button" class="btn" id="host-disconnect" hidden>Disconnect</button>
<button type="button" class="btn" id="btn-refresh-ports">Refresh ports</button>
</div>
</div>
<div class="card">
<div class="row" style="margin-bottom:0.75rem;">
<button type="button" class="btn btn-primary" id="btn-download">Download</button>
<button type="button" class="btn btn-primary" id="btn-upload">Upload &amp; reset</button>
<button type="button" class="btn" id="btn-from-json">JSON → form</button>
<button type="button" class="btn" id="btn-to-json">Form → JSON</button>
</div>
<p id="status">Ready</p>
<div class="grid">
<div>
<label for="name">Name</label>
<input id="name" data-setting="name" type="text" />
</div>
<div>
<label for="num_leds">Num LEDs</label>
<input id="num_leds" data-setting="num_leds" type="number" min="1" />
</div>
<div>
<label for="led_pin">LED pin</label>
<input id="led_pin" data-setting="led_pin" type="number" min="0" />
</div>
<div>
<label for="brightness">Brightness</label>
<input id="brightness" data-setting="brightness" type="number" min="0" max="255" />
</div>
<div>
<label for="color_order">Colour order</label>
<select id="color_order" data-setting="color_order">
<option value=""></option>
<option value="rgb">rgb</option>
<option value="rbg">rbg</option>
<option value="grb">grb</option>
<option value="gbr">gbr</option>
<option value="brg">brg</option>
<option value="bgr">bgr</option>
</select>
</div>
<div>
<label for="transport_type">Transport</label>
<select id="transport_type" data-setting="transport_type">
<option value=""></option>
<option value="espnow">espnow</option>
<option value="wifi">wifi</option>
</select>
</div>
<div>
<label for="ssid">WiFi SSID</label>
<input id="ssid" data-setting="ssid" type="text" />
</div>
<div>
<label for="password">WiFi password</label>
<input id="password" data-setting="password" type="password" />
</div>
<div>
<label for="wifi_channel">WiFi channel</label>
<input id="wifi_channel" data-setting="wifi_channel" type="number" min="1" max="11" />
</div>
<div>
<label for="ap_ip">Bridge AP IP</label>
<input id="ap_ip" data-setting="ap_ip" type="text" placeholder="192.168.4.1" />
</div>
<div>
<label for="ap_password">Bridge AP password</label>
<input id="ap_password" data-setting="ap_password" type="password" placeholder="min 8 chars, or empty for open" />
</div>
<div>
<label for="default">Default preset</label>
<input id="default" data-setting="default" type="text" />
</div>
<div>
<label for="id">Device id (ESP-NOW)</label>
<input id="id" data-setting="id" type="number" min="0" max="255" />
</div>
<div>
<label for="debug">Debug</label>
<select id="debug" data-setting="debug">
<option value=""></option>
<option value="False">False</option>
<option value="True">True</option>
</select>
</div>
</div>
</div>
<div class="card">
<label for="raw_json">Raw settings.json</label>
<textarea id="raw_json" rows="14" spellcheck="false">{}</textarea>
</div>
<script>
(function () {
const api =
document.body.getAttribute('data-api-base') ??
(location.pathname.includes('/led-tool') ? '/led-tool' : '');
const prefix = api + '/static';
const v = '20260520';
function loadScript(url) {
return new Promise((resolve, reject) => {
const s = document.createElement('script');
s.src = url + (url.includes('?') ? '&' : '?') + 'v=' + v;
s.onload = () => resolve();
s.onerror = () => reject(new Error('Failed to load ' + url));
document.body.appendChild(s);
});
}
loadScript(prefix + '/web_serial.js')
.then(() => loadScript(prefix + '/settings_editor.js'))
.catch((e) => {
const el = document.getElementById('flash');
if (el) {
el.textContent = e.message;
el.className = 'flash error show';
}
});
})();
</script>
</body>
</html>
+421
View File
@@ -0,0 +1,421 @@
(function () {
const LOG = '[led-tool/editor]';
const log = (...args) => console.log(LOG, ...args);
const apiBase =
(document.body && document.body.dataset.apiBase) ||
(window.location.pathname.includes('/led-tool') ? '/led-tool' : '');
const statusEl = document.getElementById('status');
const messageEl = document.getElementById('flash');
const portSelect = document.getElementById('host-port');
const rawJson = document.getElementById('raw_json');
const hostWrap = document.getElementById('host-serial-wrap');
const webWrap = document.getElementById('webserial-wrap');
const connectBtn = document.getElementById('webserial-connect');
const disconnectBtn = document.getElementById('webserial-disconnect');
const hostConnectBtn = document.getElementById('host-connect');
const hostDisconnectBtn = document.getElementById('host-disconnect');
const refreshPortsBtn = document.getElementById('btn-refresh-ports');
const DEFAULT_HOST_PORT = '/dev/ttyACM0';
let webClient = null;
let webPort = null;
let hostConnected = false;
let hostConnectedPort = '';
let transferBusy = false;
let webConnectBusy = false;
const webSerialOk = window.LedToolWebSerial && window.LedToolWebSerial.supported();
let webSerialGrantedCount = 0;
function setStatus(text, isError) {
if (!statusEl) return;
statusEl.textContent = text;
statusEl.classList.toggle('error', Boolean(isError));
}
function flash(text, isError) {
if (!messageEl) return;
messageEl.textContent = text;
messageEl.className = isError ? 'flash error show' : 'flash show';
setTimeout(() => messageEl.classList.remove('show'), 5000);
}
function errorMessage(e) {
if (!e) return 'Unknown error';
if (typeof e === 'string') return e;
return e.message || String(e);
}
function onWebSerialTransferError(e) {
if (webClient) webClient.inRawRepl = false;
return errorMessage(e);
}
function formToObject() {
const out = {};
document.querySelectorAll('[data-setting]').forEach((el) => {
const key = el.getAttribute('data-setting');
if (!key) return;
const raw = (el.value || '').trim();
if (raw === '') return;
if (el.type === 'number') {
const n = parseInt(raw, 10);
if (!Number.isNaN(n)) out[key] = n;
} else if (el.tagName === 'SELECT' && el.id === 'debug') {
out[key] = raw === 'True';
} else {
out[key] = raw;
}
});
return out;
}
function objectToForm(settings) {
if (!settings || typeof settings !== 'object') return;
document.querySelectorAll('[data-setting]').forEach((el) => {
const key = el.getAttribute('data-setting');
if (!key || !Object.prototype.hasOwnProperty.call(settings, key)) return;
const v = settings[key];
if (el.id === 'debug') {
el.value = v === true || v === 'True' ? 'True' : 'False';
} else {
el.value = v === undefined || v === null ? '' : String(v);
}
});
if (rawJson) rawJson.value = JSON.stringify(settings, null, 2);
}
function usingWebSerial() {
return webClient && webClient.connected;
}
function usingHostSerial() {
return hostConnected && Boolean(hostConnectedPort);
}
function updateUi() {
const webOpen = usingWebSerial();
const hostOpen = usingHostSerial();
if (webWrap) webWrap.hidden = !webSerialOk || hostOpen;
if (connectBtn) connectBtn.hidden = webOpen || hostOpen || !webSerialOk;
if (disconnectBtn) disconnectBtn.hidden = !webOpen;
if (hostWrap) hostWrap.hidden = webOpen;
const hostFieldsLocked = webOpen || hostOpen;
if (portSelect) portSelect.disabled = hostFieldsLocked;
if (refreshPortsBtn) refreshPortsBtn.disabled = hostFieldsLocked;
if (hostConnectBtn) hostConnectBtn.hidden = hostOpen || webOpen;
if (hostDisconnectBtn) hostDisconnectBtn.hidden = !hostOpen || webOpen;
if (webOpen) {
setStatus('USB open (device not reset until Download/Upload).');
} else if (hostOpen) {
setStatus(`Host serial: ${hostConnectedPort} (use Download or Upload).`);
} else if (webSerialOk) {
if (webSerialGrantedCount === 1) {
setStatus('Connect USB (one remembered port) or host serial, then Download or Upload.');
} else {
setStatus('Connect host serial or Web Serial USB, then Download or Upload.');
}
} else {
setStatus(`Connect host serial (default ${DEFAULT_HOST_PORT}).`);
}
}
async function loadHostPorts() {
if (!portSelect) return;
try {
const res = await fetch(`${apiBase}/ports`);
const data = await res.json();
const prev = portSelect.value;
portSelect.innerHTML = '<option value="">Select port</option>';
for (const p of data.ports || []) {
const opt = document.createElement('option');
opt.value = p.device;
opt.textContent = `${p.device} - ${p.description || 'device'}`;
portSelect.appendChild(opt);
}
const acm0 = DEFAULT_HOST_PORT;
const hasAcm0 = [...portSelect.options].some((o) => o.value === acm0);
if (hasAcm0) {
portSelect.value = acm0;
} else if (prev && [...portSelect.options].some((o) => o.value === prev)) {
portSelect.value = prev;
}
} catch (e) {
flash(`Could not list host ports: ${e.message}`, true);
}
}
function selectedHostPort() {
return portSelect && portSelect.value ? portSelect.value.trim() : '';
}
function hostPort() {
if (hostConnected && hostConnectedPort) return hostConnectedPort;
return selectedHostPort();
}
function connectHostSerial() {
if (usingWebSerial()) {
disconnectWebSerial();
}
const port = selectedHostPort();
if (!port) {
flash('Select a host serial port.', true);
return;
}
hostConnectedPort = port;
hostConnected = true;
log('connectHostSerial', port);
updateUi();
flash(`Host serial ready: ${port}`, false);
}
function disconnectHostSerial() {
hostConnected = false;
hostConnectedPort = '';
updateUi();
}
async function downloadHost() {
const port = hostConnectedPort || hostPort();
if (!port) {
flash('Connect host serial first.', true);
return;
}
log('downloadHost', port);
setStatus('Downloading from device (host serial)...');
const res = await fetch(`${apiBase}/settings?port=${encodeURIComponent(port)}`);
const data = await res.json();
log('downloadHost response', { ok: res.ok, status: res.status, data });
if (!res.ok) {
throw new Error(data.error || 'Download failed');
}
if (!data.settings) {
throw new Error('No settings in response (check CLI output)');
}
objectToForm(data.settings);
flash('Settings downloaded.', false);
setStatus(`Downloaded from ${port}`);
}
async function uploadHost() {
const port = hostConnectedPort || hostPort();
if (!port) {
flash('Connect host serial first.', true);
return;
}
const payload = { port, ...formToObject() };
log('uploadHost', payload);
setStatus('Uploading via host serial (led-cli)...');
const res = await fetch(`${apiBase}/settings`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload),
});
const data = await res.json();
if (!res.ok) throw new Error(data.error || 'Upload failed');
if (!data.ok) throw new Error(data.stderr || 'led-cli failed');
flash('Settings uploaded; device resetting.', false);
setStatus('Upload complete.');
}
async function connectWebSerial() {
if (webConnectBusy) return;
if (!window.LedToolWebSerial || !window.LedToolWebSerial.supported()) {
flash('Web Serial not supported (use Chrome or Edge over HTTPS or localhost).', true);
return;
}
if (usingWebSerial()) {
flash('USB already connected.', false);
return;
}
if (usingHostSerial()) {
disconnectHostSerial();
}
webConnectBusy = true;
try {
log('connectWebSerial: requestPort');
setStatus('Opening USB port…');
webPort = await window.LedToolWebSerial.requestPort();
log('connectWebSerial: port selected', webPort);
webClient = new window.LedToolWebSerial.MicroPythonRawRepl();
await webClient.connect(webPort);
updateUi();
flash('USB port open. Wait for boot, then Download.', false);
} finally {
webConnectBusy = false;
}
}
async function disconnectWebSerial() {
if (webClient) {
try {
await webClient.disconnect();
} catch (_) {
/* ignore */
}
}
webClient = null;
webPort = null;
updateUi();
}
async function downloadWebSerial() {
log('downloadWebSerial');
setStatus('Reading settings from device (Web Serial)…');
const settings = await webClient.readSettingsJson();
log('downloadWebSerial result', settings);
objectToForm(settings);
if (rawJson) rawJson.value = JSON.stringify(settings, null, 2);
flash('Settings read over Web Serial.', false);
setStatus('Downloaded via Web Serial.');
}
async function uploadWebSerial() {
log('uploadWebSerial');
let settings = {};
if (rawJson && rawJson.value.trim()) {
try {
settings = JSON.parse(rawJson.value);
} catch (e) {
flash('Invalid JSON in raw panel.', true);
return;
}
} else {
settings = await webClient.readSettingsJson();
Object.assign(settings, formToObject());
}
await webClient.writeSettingsJson(settings);
flash('Uploaded via Web Serial; device resetting.', false);
setStatus('Upload complete.');
await disconnectWebSerial();
}
document.getElementById('btn-download')?.addEventListener('click', async () => {
if (transferBusy) return;
transferBusy = true;
try {
if (usingWebSerial()) {
await downloadWebSerial();
} else if (usingHostSerial()) {
await downloadHost();
} else {
flash(
webSerialOk
? 'Connect host serial or Web Serial USB first.'
: 'Click Connect on host serial first.',
true,
);
}
} catch (e) {
console.error(LOG, 'download failed', e);
const msg = usingWebSerial() ? onWebSerialTransferError(e) : errorMessage(e);
if (rawJson) rawJson.value = msg;
flash(msg, true);
setStatus(msg, true);
} finally {
transferBusy = false;
}
});
document.getElementById('btn-upload')?.addEventListener('click', async () => {
if (transferBusy) return;
transferBusy = true;
try {
if (usingWebSerial()) {
await uploadWebSerial();
} else if (usingHostSerial()) {
await uploadHost();
} else {
flash(
webSerialOk
? 'Connect host serial or Web Serial USB first.'
: 'Click Connect on host serial first.',
true,
);
}
} catch (e) {
console.error(LOG, 'upload failed', e);
const msg = usingWebSerial() ? onWebSerialTransferError(e) : errorMessage(e);
flash(msg, true);
setStatus(msg, true);
} finally {
transferBusy = false;
}
});
document.getElementById('btn-from-json')?.addEventListener('click', () => {
try {
const parsed = JSON.parse(rawJson.value || '{}');
objectToForm(parsed);
flash('Form updated from JSON.', false);
} catch (e) {
flash('Invalid JSON.', true);
}
});
document.getElementById('btn-to-json')?.addEventListener('click', () => {
const merged = formToObject();
if (rawJson && rawJson.value.trim()) {
try {
Object.assign(merged, JSON.parse(rawJson.value));
} catch (_) {
/* use form only */
}
}
rawJson.value = JSON.stringify(merged, null, 2);
flash('JSON updated from form.', false);
});
connectBtn?.addEventListener('click', () => {
connectWebSerial().catch((e) => {
disconnectWebSerial();
const msg =
e.name === 'NotFoundError'
? 'No USB device selected.'
: e.name === 'SecurityError'
? 'Web Serial blocked (open LED Tool in a top-level tab, or use host serial on the Pi).'
: e.message || String(e);
flash(msg, true);
setStatus(msg, true);
});
});
disconnectBtn?.addEventListener('click', () => {
disconnectWebSerial();
flash('Web Serial disconnected.', false);
});
refreshPortsBtn?.addEventListener('click', () => loadHostPorts());
hostConnectBtn?.addEventListener('click', () => connectHostSerial());
hostDisconnectBtn?.addEventListener('click', () => {
disconnectHostSerial();
flash('Host serial disconnected.', false);
});
window.addEventListener('beforeunload', () => {
if (webClient) {
webClient.disconnect();
}
});
async function refreshWebSerialGrantHint() {
if (!webSerialOk || !window.LedToolWebSerial.getGrantedPorts) return;
try {
const ports = await window.LedToolWebSerial.getGrantedPorts();
webSerialGrantedCount = ports.length;
updateUi();
} catch (_) {
/* ignore */
}
}
log('settings editor ready', { apiBase, webSerialOk });
updateUi();
loadHostPorts();
refreshWebSerialGrantHint();
})();
+653
View File
@@ -0,0 +1,653 @@
/**
* MicroPython raw REPL over Web Serial (mpremote-compatible).
*/
(function (global) {
const RAW_REPL_BANNER = 'raw REPL; CTRL-B to exit\r\n';
const SOFT_REBOOT_MARKERS = ['soft reboot\r\n', 'MPY: soft reboot\r\n'];
const LOG = '[led-tool/serial]';
function log(...args) {
console.log(LOG, ...args);
}
function logDebug(...args) {
console.debug(LOG, ...args);
}
function describeBytes(data) {
if (!data || !data.length) return '(empty)';
const u8 = data instanceof Uint8Array ? data : new Uint8Array(data);
if (u8.length <= 64) {
return Array.from(u8)
.map((b) => (b >= 0x20 && b < 0x7f ? String.fromCharCode(b) : `\\x${b.toString(16).padStart(2, '0')}`))
.join('');
}
return `${u8.length} bytes: ${decodeText(u8.slice(0, 80))}…`;
}
function sleep(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
/** Common ESP32 USB-UART bridges (usbVendorId only per Web Serial API). */
const ESP32_USB_FILTERS = [
{ usbVendorId: 0x303a }, /* Espressif */
{ usbVendorId: 0x10c4 }, /* Silicon Labs CP210x */
{ usbVendorId: 0x1a86 }, /* WCH CH340 */
{ usbVendorId: 0x0403 }, /* FTDI */
];
async function deassertDtrRts(port) {
if (!port || !port.setSignals) return;
try {
await port.setSignals({ dataTerminalReady: false, requestToSend: false });
} catch (_) {
/* ignore — some adapters/browsers reject setSignals */
}
}
function bytesIndexOf(buf, suffix) {
if (!suffix.length) return 0;
if (buf.length < suffix.length) return -1;
for (let i = 0; i <= buf.length - suffix.length; i += 1) {
let ok = true;
for (let j = 0; j < suffix.length; j += 1) {
if (buf[i + j] !== suffix[j]) {
ok = false;
break;
}
}
if (ok) return i;
}
return -1;
}
function bufferEndsWithFriendlyRepl(buf) {
if (bufferLooksLikeEspRomBoot(buf) && !bufferHasMicroPython(buf)) return false;
const tail = decodeText(Uint8Array.from(buf.slice(-80)));
return /(?:\r\n|\n)>>> ?$/.test(tail);
}
function bufferLooksLikeEspRomBoot(buf) {
if (bufferIndicatesRuntime(buf)) return false;
const text = decodeText(Uint8Array.from(buf.slice(-512)));
return /SPI_FAST_FLASH_BOOT|rst:0x/.test(text) && !/entry 0x403/.test(text);
}
/** MicroPython is up (banner, REPL, raw REPL, or post-ROM heap lines from boot). */
function bufferIndicatesRuntime(buf) {
const text = decodeText(Uint8Array.from(buf));
if (text.includes('MicroPython')) return true;
if (text.includes('raw REPL; CTRL-B to exit')) return true;
if (/(?:\r\n|\n)>>> ?/.test(text)) return true;
if (text.includes('entry 0x') && (/['"]?free['"]?\s*:/.test(text) || /,\s*'free'/.test(text))) {
return true;
}
return false;
}
function bufferHasMicroPython(buf) {
return bufferIndicatesRuntime(buf);
}
function decodeText(u8) {
return new TextDecoder('utf-8', { fatal: false }).decode(u8);
}
function extractJsonObject(text) {
const t = (text || '').trim();
const start = t.indexOf('{');
const end = t.lastIndexOf('}');
if (start === -1 || end === -1 || end < start) {
throw new Error(`No JSON object in device output: ${t.slice(0, 400)}`);
}
return JSON.parse(t.slice(start, end + 1));
}
class MicroPythonRawRepl {
constructor() {
this.port = null;
this.reader = null;
this.writer = null;
this.portOpen = false;
this.inRawRepl = false;
this._rxBuf = [];
this.useRawPaste = true;
this._replLock = null;
}
get connected() {
return Boolean(this.portOpen && this.writer);
}
_appendRx(chunk) {
if (!chunk || !chunk.length) return;
logDebug('rx chunk', chunk.length, describeBytes(chunk));
for (let i = 0; i < chunk.length; i += 1) this._rxBuf.push(chunk[i]);
}
async _readStreamChunk(timeoutMs) {
if (!this.reader) return null;
const result = await Promise.race([
this.reader.read(),
sleep(timeoutMs).then(() => ({ timedOut: true })),
]);
if (result.timedOut) return null;
if (result.done) return null;
return result.value || null;
}
/** Match suffix anywhere in the buffer; keep bytes after the match for the next read. */
async readUntil(suffixBytes, timeoutMs = 15000) {
const deadline = Date.now() + timeoutMs;
while (Date.now() < deadline) {
const idx = bytesIndexOf(this._rxBuf, suffixBytes);
if (idx >= 0) {
const end = idx + suffixBytes.length;
const matched = Uint8Array.from(this._rxBuf.slice(0, end));
this._rxBuf.splice(0, end);
logDebug('readUntil matched', JSON.stringify(decodeText(suffixBytes)), 'len', matched.length);
return matched;
}
const chunk = await this._readStreamChunk(Math.min(300, Math.max(1, deadline - Date.now())));
if (chunk && chunk.length) {
this._appendRx(chunk);
} else {
await sleep(5);
}
}
const tail = decodeText(Uint8Array.from(this._rxBuf.slice(-240)));
const err = `Timed out waiting for ${JSON.stringify(decodeText(suffixBytes))} (tail: ${JSON.stringify(tail)})`;
log('readUntil timeout', err);
throw new Error(err);
}
async readUntilAny(suffixList, timeoutMs = 15000) {
const deadline = Date.now() + timeoutMs;
while (Date.now() < deadline) {
for (const suffixBytes of suffixList) {
const idx = bytesIndexOf(this._rxBuf, suffixBytes);
if (idx >= 0) {
const end = idx + suffixBytes.length;
const matched = Uint8Array.from(this._rxBuf.slice(0, end));
this._rxBuf.splice(0, end);
logDebug('readUntilAny matched', JSON.stringify(decodeText(suffixBytes)));
return matched;
}
}
const chunk = await this._readStreamChunk(Math.min(300, Math.max(1, deadline - Date.now())));
if (chunk && chunk.length) this._appendRx(chunk);
else await sleep(5);
}
const tail = decodeText(Uint8Array.from(this._rxBuf.slice(-240)));
throw new Error(
`Timed out waiting for one of ${suffixList.map((s) => JSON.stringify(decodeText(s))).join(', ')} (tail: ${JSON.stringify(tail)})`,
);
}
async readExact(n, timeoutMs = 10000) {
const deadline = Date.now() + timeoutMs;
while (this._rxBuf.length < n && Date.now() < deadline) {
const chunk = await this._readStreamChunk(Math.min(300, Math.max(1, deadline - Date.now())));
if (chunk && chunk.length) this._appendRx(chunk);
else await sleep(5);
}
if (this._rxBuf.length < n) {
throw new Error(`Expected ${n} bytes, got ${this._rxBuf.length}`);
}
return Uint8Array.from(this._rxBuf.splice(0, n));
}
async connect(serialPort) {
log('connect: opening port');
await this.disconnect();
this.port = serialPort;
this._rxBuf = [];
await this.port.open({
baudRate: 115200,
dataBits: 8,
stopBits: 1,
parity: 'none',
flowControl: 'none',
bufferSize: 65536,
});
await deassertDtrRts(this.port);
await sleep(50);
await deassertDtrRts(this.port);
this.reader = this.port.readable.getReader();
this.writer = this.port.writable.getWriter();
this.portOpen = true;
await sleep(100);
await this.collectIncoming(8000);
if (bufferIndicatesRuntime(this._rxBuf)) {
log('connect: MicroPython output seen during open');
}
log('connect: port open (raw REPL not entered yet)');
}
/** Read serial into _rxBuf without discarding (for post-open boot). */
async collectIncoming(maxMs) {
const deadline = Date.now() + maxMs;
while (Date.now() < deadline) {
const chunk = await this._readStreamChunk(Math.min(80, Math.max(1, deadline - Date.now())));
if (chunk && chunk.length) this._appendRx(chunk);
else if (
bufferHasMicroPython(this._rxBuf) ||
bufferEndsWithFriendlyRepl(this._rxBuf) ||
bytesIndexOf(this._rxBuf, new TextEncoder().encode(RAW_REPL_BANNER)) >= 0
) {
break;
} else {
await sleep(15);
}
}
}
async ensureRawRepl() {
if (this.inRawRepl) return;
if (this._replLock) {
await this._replLock;
return;
}
log('ensureRawRepl: entering raw REPL');
// USB open already resets the ESP32; skip soft-reset (unlike host led-cli/mpremote).
this._replLock = this.enterRawRepl(false).finally(() => {
this._replLock = null;
});
await this._replLock;
}
async disconnect() {
log('disconnect');
this._replLock = null;
const wasRaw = this.inRawRepl;
this.inRawRepl = false;
this.portOpen = false;
this.useRawPaste = true;
if (this.writer && wasRaw) {
try {
await this.writer.write(new Uint8Array([0x0d, 0x02]));
} catch (_) {
/* ignore */
}
}
if (this.reader) {
try {
await this.reader.cancel();
this.reader.releaseLock();
} catch (_) {
/* ignore */
}
this.reader = null;
}
if (this.writer) {
try {
await this.writer.close();
this.writer.releaseLock();
} catch (_) {
/* ignore */
}
this.writer = null;
}
if (this.port) {
try {
await deassertDtrRts(this.port);
} catch (_) {
/* ignore */
}
try {
await this.port.close();
} catch (_) {
/* ignore */
}
this.port = null;
}
this._rxBuf = [];
}
async writeBytes(data) {
if (!this.writer) throw new Error('Serial not connected');
logDebug('tx', describeBytes(data));
await this.writer.write(data);
}
async drainInput(maxMs = 400, clearBuffer = true) {
const deadline = Date.now() + maxMs;
while (Date.now() < deadline) {
const chunk = await this._readStreamChunk(40);
if (!chunk || !chunk.length) break;
if (!clearBuffer && chunk.length) this._appendRx(chunk);
}
if (clearBuffer) this._rxBuf.length = 0;
}
async sendCtrlA() {
await this.writeBytes(new Uint8Array([0x0d, 0x01]));
}
/** USB open often resets the ESP32; wait through ROM boot until MicroPython is up. */
async waitForMicroPythonBoot(timeoutMs = 60000) {
log('enterRawRepl: wait for MicroPython after boot', 'buf', this._rxBuf.length);
if (bufferHasMicroPython(this._rxBuf) || bufferEndsWithFriendlyRepl(this._rxBuf)) {
log('enterRawRepl: MicroPython already in buffer');
return;
}
const deadline = Date.now() + timeoutMs;
let nudgeSent = false;
let lastLog = Date.now();
while (Date.now() < deadline) {
if (bufferHasMicroPython(this._rxBuf) || bufferEndsWithFriendlyRepl(this._rxBuf)) {
log('enterRawRepl: MicroPython running');
return;
}
const text = decodeText(Uint8Array.from(this._rxBuf));
if (!nudgeSent && text.includes('entry 0x')) {
nudgeSent = true;
log('enterRawRepl: past ROM loader, nudge REPL');
await this.writeBytes(new Uint8Array([0x0d]));
await sleep(200);
}
if (Date.now() - lastLog > 5000) {
lastLog = Date.now();
log('enterRawRepl: still waiting…', 'buf', this._rxBuf.length);
}
const rem = Math.max(1, deadline - Date.now());
const chunk = await this._readStreamChunk(Math.min(300, rem));
if (chunk && chunk.length) this._appendRx(chunk);
else await sleep(bufferLooksLikeEspRomBoot(this._rxBuf) ? 20 : 10);
}
const tail = decodeText(Uint8Array.from(this._rxBuf.slice(-240)));
throw new Error(`Timed out waiting for MicroPython boot (tail: ${JSON.stringify(tail)})`);
}
/** Wait until raw REPL banner and `>` prompt (not banner alone — device may still be booting). */
async waitRawReplAfterSoftReboot(bannerBytes, bannerPromptBytes, timeoutMs = 15000) {
const deadline = Date.now() + timeoutMs;
while (Date.now() < deadline) {
const rem = Math.max(1, deadline - Date.now());
const promptAt = bytesIndexOf(this._rxBuf, bannerPromptBytes);
if (promptAt >= 0) {
this._rxBuf.splice(0, promptAt + bannerPromptBytes.length);
log('enterRawRepl: raw REPL prompt ready');
return;
}
if (bufferEndsWithFriendlyRepl(this._rxBuf)) {
log('enterRawRepl: friendly REPL, ctrl-A');
await this.sendCtrlA();
await sleep(30);
continue;
}
if (bufferLooksLikeEspRomBoot(this._rxBuf) && !bufferHasMicroPython(this._rxBuf)) {
logDebug('enterRawRepl: ROM boot in progress…');
}
const chunk = await this._readStreamChunk(Math.min(300, rem));
if (chunk && chunk.length) this._appendRx(chunk);
else await sleep(10);
}
const tail = decodeText(Uint8Array.from(this._rxBuf.slice(-240)));
throw new Error(
`Timed out waiting for raw REPL after soft reboot (tail: ${JSON.stringify(tail)})`,
);
}
/** Match mpremote SerialTransport.enter_raw_repl(soft_reset). */
async enterRawRepl(softReset = true) {
log('enterRawRepl', { softReset });
const bannerBytes = new TextEncoder().encode(RAW_REPL_BANNER);
const bannerPromptBytes = new TextEncoder().encode(RAW_REPL_BANNER + '>');
const softRebootBytes = SOFT_REBOOT_MARKERS.map((m) => new TextEncoder().encode(m));
if (
!bufferHasMicroPython(this._rxBuf) &&
!bufferEndsWithFriendlyRepl(this._rxBuf) &&
bytesIndexOf(this._rxBuf, bannerBytes) < 0
) {
await this.waitForMicroPythonBoot(60000);
} else {
log('enterRawRepl: already have REPL output in buffer');
}
if (bufferEndsWithFriendlyRepl(this._rxBuf)) {
await this.writeBytes(new Uint8Array([0x0d, 0x03]));
await sleep(50);
}
let ctrlARetries = 0;
const maxCtrlARetries = 3;
while (ctrlARetries <= maxCtrlARetries) {
try {
await this.sendCtrlA();
await this.waitRawReplAfterSoftReboot(bannerBytes, bannerPromptBytes, 20000);
break;
} catch (e) {
if (ctrlARetries >= maxCtrlARetries) throw e;
ctrlARetries += 1;
log('enterRawRepl: retry ctrl-A', ctrlARetries, e.message);
this._rxBuf.length = 0;
}
}
if (softReset) {
log('enterRawRepl: soft reset');
await this.writeBytes(new Uint8Array([0x04]));
try {
await this.readUntilAny(softRebootBytes, 20000);
log('enterRawRepl: saw soft reboot');
this._rxBuf.length = 0;
} catch (e) {
log('enterRawRepl: no soft reboot banner', e.message);
}
ctrlARetries = 0;
while (ctrlARetries <= maxCtrlARetries) {
try {
await this.waitRawReplAfterSoftReboot(bannerBytes, bannerPromptBytes, 60000);
break;
} catch (e) {
if (ctrlARetries >= maxCtrlARetries) throw e;
ctrlARetries += 1;
log('enterRawRepl: post-reboot retry ctrl-A', ctrlARetries, e.message);
this._rxBuf.length = 0;
await this.sendCtrlA();
}
}
}
this.inRawRepl = true;
log('enterRawRepl: ready');
}
async rawPasteWrite(commandBytes) {
await this.writeBytes(new Uint8Array([0x05, 0x41, 0x01]));
const hdr = await this.readExact(2, 8000);
const windowSize = hdr[0] | (hdr[1] << 8);
let windowRemain = windowSize;
let i = 0;
while (i < commandBytes.length) {
while (windowRemain === 0) {
const b = await this.readExact(1, 15000);
if (b[0] === 0x01) {
windowRemain += windowSize;
} else if (b[0] === 0x04) {
await this.writeBytes(new Uint8Array([0x04]));
return;
} else {
throw new Error(`Unexpected byte during raw paste: 0x${b[0].toString(16)}`);
}
}
const n = Math.min(windowRemain, commandBytes.length - i);
await this.writeBytes(commandBytes.subarray(i, i + n));
windowRemain -= n;
i += n;
}
await this.writeBytes(new Uint8Array([0x04]));
await this.readUntil(new Uint8Array([0x04]), 30000);
}
async awaitRawReplExecPrompt(timeoutMs = 60000) {
const bannerPromptBytes = new TextEncoder().encode(RAW_REPL_BANNER + '>');
const deadline = Date.now() + timeoutMs;
while (Date.now() < deadline) {
const promptAt = bytesIndexOf(this._rxBuf, bannerPromptBytes);
if (promptAt >= 0) {
this._rxBuf.splice(0, promptAt + bannerPromptBytes.length);
return;
}
if (bufferEndsWithFriendlyRepl(this._rxBuf)) {
log('exec: friendly REPL before prompt, ctrl-A');
this._rxBuf.length = 0;
await this.sendCtrlA();
} else if (bufferLooksLikeEspRomBoot(this._rxBuf)) {
logDebug('exec: still in ROM boot, waiting…');
}
const rem = Math.max(1, deadline - Date.now());
const chunk = await this._readStreamChunk(Math.min(300, rem));
if (chunk && chunk.length) this._appendRx(chunk);
else await sleep(10);
}
const tail = decodeText(Uint8Array.from(this._rxBuf.slice(-240)));
throw new Error(`Timed out waiting for raw REPL prompt (tail: ${JSON.stringify(tail)})`);
}
async execRawNoFollow(commandBytes) {
log('execRawNoFollow', commandBytes.length, 'bytes');
await this.awaitRawReplExecPrompt(60000);
if (this.useRawPaste) {
await this.writeBytes(new Uint8Array([0x05, 0x41, 0x01]));
let data;
try {
data = await this.readExact(2, 3000);
} catch (_) {
this.useRawPaste = false;
data = null;
}
if (data) {
if (data[0] === 0x52 && data[1] === 0x01) {
log('exec: using raw paste mode');
await this.rawPasteWrite(commandBytes);
const ok = await this.readExact(2, 15000);
if (ok[0] !== 0x4f || ok[1] !== 0x4b) {
throw new Error(`Device did not return OK after paste (got ${decodeText(ok)})`);
}
log('exec: paste OK');
return;
}
if (data[0] === 0x52 && data[1] === 0x00) {
log('exec: raw paste not supported (R\\x00)');
this.useRawPaste = false;
} else {
log('exec: raw paste probe unexpected', describeBytes(data));
this.useRawPaste = false;
try {
await this.readUntil(new TextEncoder().encode(RAW_REPL_BANNER + '>'), 5000);
} catch (_) {
/* ignore */
}
}
}
}
for (let i = 0; i < commandBytes.length; i += 256) {
await this.writeBytes(commandBytes.subarray(i, Math.min(i + 256, commandBytes.length)));
await sleep(10);
}
log('exec: standard raw REPL write');
await this.writeBytes(new Uint8Array([0x04]));
const ok = await this.readExact(2, 15000);
if (ok[0] !== 0x4f || ok[1] !== 0x4b) {
throw new Error(`Device did not return OK (got ${decodeText(ok)})`);
}
log('exec: got OK');
}
async follow(timeoutMs = 30000) {
const out1 = await this.readUntil(new Uint8Array([0x04]), timeoutMs);
const stdout = decodeText(out1.slice(0, -1));
const out2 = await this.readUntil(new Uint8Array([0x04]), timeoutMs);
const stderr = decodeText(out2.slice(0, -1));
log('follow stdout', stdout.slice(0, 500));
if (stderr) log('follow stderr', stderr.slice(0, 500));
return { stdout, stderr };
}
async exec(command, timeoutMs = 30000) {
const preview =
typeof command === 'string' ? command.split('\n').slice(0, 3).join('\n') : '<bytes>';
log('exec', preview);
await this.ensureRawRepl();
const commandBytes =
typeof command === 'string' ? new TextEncoder().encode(command) : command;
await this.execRawNoFollow(commandBytes);
return this.follow(timeoutMs);
}
async readSettingsJson() {
log('readSettingsJson');
const code = [
'import json',
'try:',
" f=open('settings.json','r')",
' d=json.load(f)',
' f.close()',
'except Exception:',
' d={}',
'print(json.dumps(d))',
].join('\n');
const { stdout, stderr } = await this.exec(code);
const text = (stdout || '').trim() || (stderr || '').trim();
if (!text) {
log('readSettingsJson: empty response');
return {};
}
const parsed = extractJsonObject(text);
log('readSettingsJson: ok', Object.keys(parsed));
return parsed;
}
async writeSettingsJson(settings) {
log('writeSettingsJson', settings);
const jsonText = JSON.stringify(settings);
const escaped = JSON.stringify(jsonText);
const code = [
'import json',
`s=json.loads(${escaped})`,
"f=open('settings.json','w')",
'f.write(s)',
'f.close()',
'import machine',
'machine.reset()',
].join('\n');
await this.exec(code, 60000);
}
}
function serialSupported() {
return typeof navigator !== 'undefined' && 'serial' in navigator;
}
async function getGrantedPorts() {
if (!serialSupported()) return [];
return navigator.serial.getPorts();
}
async function requestPort() {
if (!serialSupported()) {
throw new Error('Web Serial not supported');
}
const granted = await navigator.serial.getPorts();
if (granted.length === 1) {
log('requestPort: reusing single granted port');
return granted[0];
}
log('requestPort: showing picker', { grantedCount: granted.length });
return navigator.serial.requestPort({ filters: ESP32_USB_FILTERS });
}
global.LedToolWebSerial = {
supported: serialSupported,
getGrantedPorts,
requestPort,
MicroPythonRawRepl,
_test: { bytesIndexOf, decodeText },
};
})(typeof window !== 'undefined' ? window : globalThis);
+69
View File
@@ -0,0 +1,69 @@
/**
* Node regression tests for Web Serial readUntil buffer handling.
* Run: node led-tool/static/web_serial_readuntil_test.mjs
*/
function bytesIndexOf(buf, suffix) {
if (!suffix.length) return 0;
if (buf.length < suffix.length) return -1;
for (let i = 0; i <= buf.length - suffix.length; i += 1) {
let ok = true;
for (let j = 0; j < suffix.length; j += 1) {
if (buf[i + j] !== suffix[j]) {
ok = false;
break;
}
}
if (ok) return i;
}
return -1;
}
function readUntilConsume(rxBuf, suffixBytes) {
const idx = bytesIndexOf(rxBuf, suffixBytes);
if (idx < 0) return null;
const end = idx + suffixBytes.length;
const matched = rxBuf.slice(0, end);
rxBuf.splice(0, end);
return matched;
}
function enc(s) {
return [...new TextEncoder().encode(s)];
}
function assert(cond, msg) {
if (!cond) throw new Error(msg);
}
const RAW = 'raw REPL; CTRL-B to exit\r\n';
const SOFT = 'soft reboot\r\n';
// Old bug: one chunk with soft reboot + banner; suffix-at-end + clear-all loses banner.
{
const rx = enc(`MPY: ${SOFT}${RAW}boot.py line\r\n`);
const soft = enc(SOFT);
const m1 = readUntilConsume(rx, soft);
assert(m1 !== null, 'soft reboot should match');
const banner = enc(RAW);
const m2 = readUntilConsume(rx, banner);
assert(m2 !== null, 'banner must remain in buffer after soft reboot match');
assert(rx.length > 0, 'boot.py tail should remain after banner');
}
// Banner anywhere in buffer, not only at end.
{
const rx = enc(`noise${RAW}>>> `);
const banner = enc(RAW);
const m = readUntilConsume(rx, banner);
assert(m !== null, 'banner should match mid-buffer');
}
// MPY: soft reboot marker
{
const rx = enc(`MPY: ${SOFT}`);
const soft = enc('MPY: soft reboot\r\n');
assert(readUntilConsume(rx, soft) !== null, 'MPY soft reboot marker');
}
console.log('web_serial_readuntil_test: ok');
+52
View File
@@ -0,0 +1,52 @@
"""Tests for deploy_manifest helpers (host Python)."""
import json
import os
import tempfile
import unittest
from deploy_manifest import (
MANIFEST_FILENAME,
build_manifest_bytes,
normalize_remote_path,
parse_manifest,
sha256_hex_file,
)
class DeployManifestTests(unittest.TestCase):
def test_normalize_remote_path(self):
self.assertEqual(normalize_remote_path("/patterns/chase.py"), "patterns/chase.py")
self.assertEqual(normalize_remote_path("main.py"), "main.py")
def test_round_trip_manifest(self):
files = {"main.py": "abc", "patterns/x.py": "def"}
blob = build_manifest_bytes(files)
parsed = parse_manifest(blob)
self.assertEqual(parsed, files)
doc = json.loads(blob.decode())
self.assertEqual(doc["version"], 1)
self.assertEqual(doc["algorithm"], "sha256")
def test_parse_manifest_invalid(self):
self.assertEqual(parse_manifest(b"not json"), {})
self.assertEqual(parse_manifest(b'{"files": "nope"}'), {})
def test_sha256_hex_file(self):
with tempfile.NamedTemporaryFile(delete=False) as f:
f.write(b"hello")
path = f.name
try:
self.assertEqual(
sha256_hex_file(path),
"2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824",
)
finally:
os.unlink(path)
def test_manifest_filename(self):
self.assertEqual(MANIFEST_FILENAME, "file_hashes.json")
if __name__ == "__main__":
unittest.main()
+112 -2
View File
@@ -19,6 +19,7 @@ from flask import (
redirect,
url_for,
flash,
send_from_directory,
)
@@ -696,10 +697,119 @@ def handle_action():
)
def _static_dir() -> str:
return os.path.join(os.path.dirname(os.path.abspath(__file__)), "static")
@app.route("/ports")
def api_list_ports():
from host_ports import filter_port_dicts
from serial.tools import list_ports
ports = filter_port_dicts(
[
{"device": i.device, "description": i.description, "hwid": i.hwid}
for i in list_ports.comports()
]
)
cli = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cli.py")
return json.dumps({"ports": ports, "led_cli_exists": os.path.exists(cli)})
@app.route("/settings", methods=["GET"])
def api_read_settings():
import subprocess
import sys
port = (request.args.get("port") or "").strip()
if not port:
return json.dumps({"error": "port is required"}), 400
cli = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cli.py")
result = subprocess.run(
[sys.executable, cli, "--port", port, "--show"],
capture_output=True,
text=True,
timeout=180,
cwd=os.path.dirname(cli),
)
settings = None
try:
settings = json.loads((result.stdout or "").strip())
except json.JSONDecodeError:
pass
return json.dumps(
{
"ok": result.returncode == 0,
"returncode": result.returncode,
"stdout": result.stdout,
"stderr": result.stderr,
"settings": settings,
}
)
@app.route("/settings", methods=["POST"])
def api_write_settings():
import subprocess
import sys
data = request.get_json(silent=True) or {}
port = str(data.get("port") or "").strip()
if not port:
return json.dumps({"error": "port is required"}), 400
cli = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cli.py")
cmd = [sys.executable, cli, "--port", port]
flag_map = (
("name", "--name"),
("led_pin", "--pin"),
("num_leds", "--leds"),
("brightness", "--brightness"),
("transport", "--transport"),
("ssid", "--ssid"),
("password", "--wifi-password"),
("wifi_channel", "--wifi-channel"),
("default", "--default"),
)
for key, flag in flag_map:
val = data.get(key)
if val is None:
continue
s = str(val).strip()
if s:
cmd.extend([flag, s])
cmd.append("--follow")
result = subprocess.run(
cmd,
capture_output=True,
text=True,
timeout=180,
cwd=os.path.dirname(cli),
)
return json.dumps(
{
"ok": result.returncode == 0,
"returncode": result.returncode,
"stdout": result.stdout,
"stderr": result.stderr,
}
)
@app.route("/editor")
def settings_editor():
"""Static settings editor (Web Serial + host serial). Prefer this over the legacy form."""
return send_from_directory(_static_dir(), "settings_editor.html")
@app.route("/static/<path:filename>")
def settings_static(filename):
return send_from_directory(_static_dir(), filename)
def main() -> None:
# Bind to all interfaces so you can reach it from your LAN:
# python web_app.py
# Then open: http://<pi-ip>:5000/
# python web.py
# Then open: http://<pi-ip>:5000/editor
app.run(host="0.0.0.0", port=5000, debug=False)