diff --git a/README.md b/README.md index 0d08576..0d93445 100644 --- a/README.md +++ b/README.md @@ -41,3 +41,21 @@ LED controller web app for managing profiles, **zones**, presets, and colour pal ## Driver pattern modules Pattern **`.py`** sources live under **`led-driver/src/patterns`**. The Pi app resolves that path via `util.driver_patterns.driver_patterns_dir()`. If you deploy without that tree next to the app, set **`LED_CONTROLLER_PATTERNS_DIR`** to the directory that contains those files. + +## Animation engine (Pi-side) + +`src/engine/` lets the Pi drive LEDs itself, in addition to the ESP32 drivers: + +- **Pixel generator**: runs the **unchanged** `led-driver/src/patterns/*.py` under CPython (a `utime` shim plus a NeoPixel-like buffer) with the same preset JSON the drivers get, and streams each frame to **pixel outputs**: DDP, Art-Net, sACN (E1.31), or USB-DMX (Enttec Pro / Open DMX). Configure outputs in **Outputs** (edit mode) and add an output's name to a zone's devices. +- **Preset sequencer**: **Sequences** play timed chains of presets on a zone, switching both the pixel outputs and the zone's ESP32 drivers. Sequences resume after a restart. +- ESP32 firmware is unchanged; drivers still get presets + `select`. + +CLI (run from `src/`): + +```bash +python -m engine.cli --output "ddp://192.168.1.60?pixels=300" --test +python -m engine.cli --output "artnet://192.168.1.61?universe=0&pixels=170" --preset 16 +python -m engine.cli --pattern rainbow --n1 2 --leds 60 # terminal preview +``` + +Tests: `pipenv run pytest tests/engine_tests`. diff --git a/db/output.json b/db/output.json new file mode 100644 index 0000000..0967ef4 --- /dev/null +++ b/db/output.json @@ -0,0 +1 @@ +{} diff --git a/db/sequence.json b/db/sequence.json index fee2521..74edefc 100644 --- a/db/sequence.json +++ b/db/sequence.json @@ -1 +1 @@ -{"1": {"group_name": "Main Group", "presets": ["1", "2"], "sequence_duration": 3000, "sequence_transition": 500, "sequence_loop": true, "sequence_repeat_count": 0, "sequence_active": false, "sequence_index": 0, "sequence_start_time": 0}, "2": {"group_name": "Accent Group", "presets": ["2", "3"], "sequence_duration": 2000, "sequence_transition": 300, "sequence_loop": true, "sequence_repeat_count": 0, "sequence_active": false, "sequence_index": 0, "sequence_start_time": 0}} \ No newline at end of file +{"1": {"name": "Main Group", "zone_id": null, "loop": true, "repeat_count": 0, "steps": [{"preset_id": "1", "duration_s": 3.0}, {"preset_id": "2", "duration_s": 3.0}], "active": false}, "2": {"name": "Accent Group", "zone_id": null, "loop": true, "repeat_count": 0, "steps": [{"preset_id": "2", "duration_s": 2.0}, {"preset_id": "3", "duration_s": 2.0}], "active": false}} \ No newline at end of file diff --git a/docs/API.md b/docs/API.md index c4a2442..19cf6b2 100644 --- a/docs/API.md +++ b/docs/API.md @@ -159,6 +159,9 @@ Stored preset records can include: | DELETE | `/zones/` | Delete zone; can delete `current` to remove the active zone; updates profile zone list. | | POST | `/zones//set-current` | Sets `current_zone` cookie. | | POST | `/zones//clone` | Clone zone into current profile. | +| POST | `/zones//play` | Body **`{"preset_id": "16", "drivers": true}`**. Runs the preset on every target in the zone through the Pi engine: pixel **outputs** are rendered on the Pi, ESP32 drivers get the preset + `select` (skipped when **`drivers`** is `false`; the UI sends to drivers itself and passes `false`). Stops any sequence on the zone. Returns the zone's player status. | +| POST | `/zones//stop` | Stops the zone's sequence and Pi rendering (pixel outputs go black). ESP32 drivers keep their current preset. | +| GET | `/zones/engine/status` | Engine state: `zones` (per-zone player: preset, pattern, error, per-output frame/packet/error counters) and `sequences`. | ### Palettes — `/palettes` @@ -190,15 +193,60 @@ Stored preset records can include: | PUT | `/scenes/` | Update. | | DELETE | `/scenes/` | Delete. | +### Scene playback + +| Method | Path | Description | +|--------|------|-------------| +| POST | `/scenes//play` | Starts every sequence listed in the scene's `sequences`. Returns `started` ids and per-sequence `errors`. | +| POST | `/scenes//stop` | Stops the scene's sequences. | + ### Sequences — `/sequences` +Timed preset chains for one zone, run by the Pi engine (hard cuts). Stored in **`db/sequence.json`**: + +```json +{"name": "Showcase", "zone_id": "2", "loop": true, "repeat_count": 0, + "steps": [{"preset_id": "16", "duration_s": 8}, {"preset_id": "17", "duration_s": 8}], + "active": false} +``` + +`duration_s` is clamped to 0.5–600 (default 5). `repeat_count` counts passes when `loop` is true (0 = forever). `active` is maintained by the engine; active sequences resume after a restart. Legacy records (`group_name`, `presets`, `sequence_duration` in ms) are migrated on load. + | Method | Path | Description | |--------|------|-------------| | GET | `/sequences` | All sequences. | +| GET | `/sequences/status` | Runtime state per sequence: `zone_id`, `step_index`, `preset_id`, `pass`, `next_at`, `running`, optional `error`. | | GET | `/sequences/` | One sequence. | -| POST | `/sequences` | Create; may use `group_name`, `presets` in body. | -| PUT | `/sequences/` | Update. | -| DELETE | `/sequences/` | Delete. | +| POST | `/sequences` | Create (body as above). 400 on invalid steps. | +| PUT | `/sequences/` | Update (merged, then re-validated). | +| DELETE | `/sequences/` | Stop if running, then delete. | +| POST | `/sequences//play` | Start on its zone; replaces a sequence already running there. 400 without `zone_id`/steps. | +| POST | `/sequences//stop` | Stop; the zone keeps its current preset. | + +Picking a preset manually on a zone (`/zones//play`) stops that zone's sequence. + +### Outputs — `/outputs` + +Pixel outputs the Pi renders frames for, stored in **`db/output.json`**. A zone drives an output when the output's **`name`** appears in the zone's `names` (the same list that holds ESP32 device names). + +| Field | Notes | +|-------|-------| +| `name` | Matched against zone `names`. | +| `protocol` | `ddp` (UDP 4048), `artnet` (ArtDMX, UDP 6454), `sacn` (E1.31, UDP 5568), `dmx_serial` (USB-DMX). | +| `host`, `port` | Network outputs. `ddp` needs a host; Art-Net without host broadcasts; sACN without host uses multicast `239.255..`. Blank port = protocol default. | +| `universe` | Art-Net/sACN start universe (sACN 1–63999). 170 RGB pixels per universe; consecutive universes are used for longer strips. | +| `serial_port`, `dmx_mode`, `channel` | USB-DMX: `enttec_pro` (Enttec DMX USB Pro) or `open_dmx` (FTDI); start channel 1–512; one universe max. | +| `pixel_count`, `pixel_offset` | Pixels this output takes from the zone frame, starting at `pixel_offset`. Outputs at offset 0 mirror the frame start. | +| `color_order`, `reverse`, `brightness`, `fps`, `enabled` | Per-output wiring order, direction, 0–255 brightness (× global brightness), frame-rate cap (default 40). | + +| Method | Path | Description | +|--------|------|-------------| +| GET | `/outputs` | All outputs. | +| GET | `/outputs/` | One output. | +| POST | `/outputs` | Create; 400 with `error` on validation failure. | +| PUT | `/outputs/` | Update. | +| DELETE | `/outputs/` | Delete. | +| POST | `/outputs//test` | Sends red, green, blue, white (optional body `step_s`, default 1 s each) then black. Returns per-output counters. | ### Patterns — `/patterns` diff --git a/pyproject.toml b/pyproject.toml index 8a9d1ae..6d1f643 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,3 +1,3 @@ [tool.pytest.ini_options] testpaths = ["tests"] -python_files = ["test_endpoints_pytest.py"] +python_files = ["test_endpoints_pytest.py", "engine_tests/test_*.py"] diff --git a/src/controllers/output.py b/src/controllers/output.py new file mode 100644 index 0000000..190f0ea --- /dev/null +++ b/src/controllers/output.py @@ -0,0 +1,85 @@ +from microdot import Microdot +from models.output import Output +from engine.outputs import open_output +import asyncio +import json + +controller = Microdot() +outputs = Output() + +_JSON = {'Content-Type': 'application/json'} + +TEST_COLORS = ((255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 255)) + + +async def run_output_test(out, step_s=1.0): + """Red, green, blue, white for ``step_s`` each, then black.""" + await out.open() + try: + for color in TEST_COLORS: + frame = bytes(color) * out.pixel_count + end = asyncio.get_running_loop().time() + step_s + while asyncio.get_running_loop().time() < end: + await out.send(frame) + await asyncio.sleep(1.0 / out.fps) + finally: + await out.close() + return out.status() + + +@controller.get('') +async def list_outputs(request): + """List all pixel outputs.""" + return json.dumps(outputs), 200, _JSON + + +@controller.get('/') +async def get_output(request, id): + doc = outputs.read(id) + if doc: + return json.dumps(doc), 200, _JSON + return json.dumps({"error": "Output not found"}), 404, _JSON + + +@controller.post('') +async def create_output(request): + try: + output_id = outputs.create(request.json or {}) + return json.dumps(outputs.read(output_id)), 201, _JSON + except ValueError as e: + return json.dumps({"error": str(e)}), 400, _JSON + + +@controller.put('/') +async def update_output(request, id): + try: + if outputs.update(id, request.json or {}): + return json.dumps(outputs.read(id)), 200, _JSON + return json.dumps({"error": "Output not found"}), 404, _JSON + except ValueError as e: + return json.dumps({"error": str(e)}), 400, _JSON + + +@controller.delete('/') +async def delete_output(request, id): + if outputs.delete(id): + return json.dumps({"message": "Output deleted successfully"}), 200, _JSON + return json.dumps({"error": "Output not found"}), 404, _JSON + + +@controller.post('//test') +async def test_output(request, id): + """Send a short red/green/blue/white test sequence, then black.""" + doc = outputs.read(id) + if not doc: + return json.dumps({"error": "Output not found"}), 404, _JSON + data = request.json or {} + try: + step_s = max(0.1, min(5.0, float(data.get("step_s", 1.0)))) + except (TypeError, ValueError): + step_s = 1.0 + try: + status = await run_output_test(open_output(doc), step_s=step_s) + except Exception as e: + return json.dumps({"error": f"Test failed: {e}"}), 503, _JSON + return json.dumps({"message": "Test sent", "status": status}), 200, _JSON diff --git a/src/controllers/scene.py b/src/controllers/scene.py index de35074..018f93e 100644 --- a/src/controllers/scene.py +++ b/src/controllers/scene.py @@ -47,3 +47,37 @@ async def delete_scene(request, id): if scenes.delete(id): return json.dumps({"message": "Scene deleted successfully"}), 200 return json.dumps({"error": "Scene not found"}), 404 + + +@controller.post('//play') +async def play_scene(request, id): + """Start every sequence in the scene (one per zone; later ones win a shared zone).""" + from engine import get_engine + from engine.core import EngineError + + scene = scenes.read(id) + if not scene: + return json.dumps({"error": "Scene not found"}), 404, {'Content-Type': 'application/json'} + started, errors = [], {} + for sid in scene.get("sequences") or []: + try: + await get_engine().sequences.play(sid) + started.append(str(sid)) + except EngineError as e: + errors[str(sid)] = str(e) + return json.dumps({"started": started, "errors": errors}), 200, {'Content-Type': 'application/json'} + + +@controller.post('//stop') +async def stop_scene(request, id): + """Stop every sequence in the scene.""" + from engine import get_engine + + scene = scenes.read(id) + if not scene: + return json.dumps({"error": "Scene not found"}), 404, {'Content-Type': 'application/json'} + stopped = [] + for sid in scene.get("sequences") or []: + if await get_engine().sequences.stop(sid): + stopped.append(str(sid)) + return json.dumps({"stopped": stopped}), 200, {'Content-Type': 'application/json'} diff --git a/src/controllers/sequence.py b/src/controllers/sequence.py index 43d509a..4d4b6a6 100644 --- a/src/controllers/sequence.py +++ b/src/controllers/sequence.py @@ -1,51 +1,78 @@ from microdot import Microdot from models.squence import Sequence +from engine import get_engine +from engine.core import EngineError import json controller = Microdot() sequences = Sequence() +_JSON = {'Content-Type': 'application/json'} + + @controller.get('') async def list_sequences(request): """List all sequences.""" - return json.dumps(sequences), 200, {'Content-Type': 'application/json'} + return json.dumps(sequences), 200, _JSON + + +@controller.get('/status') +async def sequences_status(request): + """Running state of every sequence started since boot.""" + return json.dumps(get_engine().sequences.status()), 200, _JSON + @controller.get('/') async def get_sequence(request, id): """Get a specific sequence by ID.""" sequence = sequences.read(id) if sequence: - return json.dumps(sequence), 200, {'Content-Type': 'application/json'} - return json.dumps({"error": "Sequence not found"}), 404 + return json.dumps(sequence), 200, _JSON + return json.dumps({"error": "Sequence not found"}), 404, _JSON + @controller.post('') async def create_sequence(request): - """Create a new sequence.""" + """Create a sequence: {name, zone_id, loop, repeat_count, steps: [{preset_id, duration_s}]}.""" try: - data = request.json or {} - group_name = data.get("group_name", "") - preset_names = data.get("presets", None) - sequence_id = sequences.create(group_name, preset_names) - if data: - sequences.update(sequence_id, data) - return json.dumps(sequences.read(sequence_id)), 201, {'Content-Type': 'application/json'} - except Exception as e: - return json.dumps({"error": str(e)}), 400 + sequence_id = sequences.create(request.json or {}) + return json.dumps(sequences.read(sequence_id)), 201, _JSON + except ValueError as e: + return json.dumps({"error": str(e)}), 400, _JSON + @controller.put('/') async def update_sequence(request, id): """Update an existing sequence.""" try: - data = request.json - if sequences.update(id, data): - return json.dumps(sequences.read(id)), 200, {'Content-Type': 'application/json'} - return json.dumps({"error": "Sequence not found"}), 404 - except Exception as e: - return json.dumps({"error": str(e)}), 400 + if sequences.update(id, request.json or {}): + return json.dumps(sequences.read(id)), 200, _JSON + return json.dumps({"error": "Sequence not found"}), 404, _JSON + except ValueError as e: + return json.dumps({"error": str(e)}), 400, _JSON + @controller.delete('/') async def delete_sequence(request, id): - """Delete a sequence.""" + """Delete a sequence (stops it first if running).""" + await get_engine().sequences.stop(id) if sequences.delete(id): - return json.dumps({"message": "Sequence deleted successfully"}), 200 - return json.dumps({"error": "Sequence not found"}), 404 + return json.dumps({"message": "Sequence deleted successfully"}), 200, _JSON + return json.dumps({"error": "Sequence not found"}), 404, _JSON + + +@controller.post('//play') +async def play_sequence(request, id): + """Start the sequence on its zone (replaces any sequence already running there).""" + try: + state = await get_engine().sequences.play(id) + return json.dumps(state), 200, _JSON + except EngineError as e: + return json.dumps({"error": str(e)}), e.status, _JSON + + +@controller.post('//stop') +async def stop_sequence(request, id): + """Stop the sequence; the zone keeps showing its current preset.""" + stopped = await get_engine().sequences.stop(id) + return json.dumps({"stopped": stopped}), 200, _JSON diff --git a/src/controllers/zone.py b/src/controllers/zone.py index a85b3d7..fdc71e2 100644 --- a/src/controllers/zone.py +++ b/src/controllers/zone.py @@ -211,6 +211,45 @@ async def set_current_zone(request, id): ) +@controller.get("/engine/status") +async def engine_status(request): + """Pi-side engine state: rendering zones and running sequences.""" + from engine import get_engine + + return json.dumps(get_engine().status()), 200, {"Content-Type": "application/json"} + + +@controller.post("//play") +async def play_zone(request, id): + """Run a preset on every target in the zone. + + Body: {"preset_id": "16", "drivers": true}. Pixel outputs (DDP/Art-Net/sACN/DMX) + are rendered on the Pi; ESP32 led-drivers get the preset + select as before + unless ``drivers`` is false. Stops any sequence running on the zone. + """ + from engine import get_engine + from engine.core import EngineError + + data = request.json or {} + preset_id = data.get("preset_id") + if preset_id in (None, ""): + return json.dumps({"error": "preset_id is required"}), 400, {"Content-Type": "application/json"} + try: + status = await get_engine().play(id, str(preset_id), drivers=data.get("drivers", True) is not False) + except EngineError as e: + return json.dumps({"error": str(e)}), e.status, {"Content-Type": "application/json"} + return json.dumps(status), 200, {"Content-Type": "application/json"} + + +@controller.post("//stop") +async def stop_zone(request, id): + """Stop the zone's sequence and Pi rendering (pixel outputs go black).""" + from engine import get_engine + + stopped = await get_engine().stop(id) + return json.dumps({"stopped": stopped}), 200, {"Content-Type": "application/json"} + + @controller.get("/") async def get_zone(request, id): z = zones.read(id) diff --git a/src/engine/__init__.py b/src/engine/__init__.py new file mode 100644 index 0000000..f8294b1 --- /dev/null +++ b/src/engine/__init__.py @@ -0,0 +1,25 @@ +"""Pi-side animation engine. + +* ``engine.outputs`` — protocol drivers (DDP, Art-Net, sACN, USB-DMX, ESP32 presets) +* ``engine.renderer`` — runs unchanged led-driver patterns under CPython +* ``engine.player`` — per-zone frame streaming +* ``engine.sequence_runner`` — timed preset chains + +``get_engine()`` returns the process-wide Engine (created on first use). +""" + +_engine = None + + +def get_engine(): + global _engine + if _engine is None: + from engine.core import Engine + _engine = Engine() + return _engine + + +def set_engine(engine): + global _engine + _engine = engine + return engine diff --git a/src/engine/cli.py b/src/engine/cli.py new file mode 100644 index 0000000..f7c4246 --- /dev/null +++ b/src/engine/cli.py @@ -0,0 +1,148 @@ +"""Engine CLI (run from ``src/``) — portal's ``run_cli`` equivalent. + + python -m engine.cli --output ddp://10.0.0.5?pixels=300 --test + python -m engine.cli --output artnet://10.0.0.6?universe=0&pixels=170 --color ff0000 + python -m engine.cli --output sacn://?universe=1&pixels=170 --preset 16 + python -m engine.cli --pattern rainbow --n1 2 --leds 60 # stdout preview + python -m engine.cli --output dmx_serial:///dev/ttyUSB0?pixels=10 --pattern pulse \\ + --colors ff0000,0000ff --n1 300 --n2 200 --n3 300 +""" + +import argparse +import asyncio +import sys + +from engine.outputs import parse_output_url +from engine.outputs.base import FrameOutput +from engine.player import ZonePlayer +from engine.zone_targets import ZoneTargets + + +class StdoutOutput(FrameOutput): + """Truecolour terminal strip, one line redrawn per frame.""" + + protocol = "stdout" + + async def _send_prepared(self, payload): + cells = [] + for i in range(0, len(payload), 3): + r, g, b = payload[i], payload[i + 1], payload[i + 2] + cells.append(f"\x1b[48;2;{r};{g};{b}m ") + sys.stdout.write("\r" + "".join(cells) + "\x1b[0m") + sys.stdout.flush() + self.stats.packets += 1 + + +def _output_factory(cfg): + if cfg.get("protocol") == "stdout": + return StdoutOutput(cfg) + from engine.outputs import open_output + return open_output(cfg) + + +def build_parser(): + p = argparse.ArgumentParser(prog="python -m engine.cli", description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter) + p.add_argument("--output", action="append", default=[], + help="ddp://, artnet://, sacn://, dmx_serial:// URL (repeatable); default stdout") + p.add_argument("--leds", type=int, default=None, help="pixel count (default: from output URL, else 60)") + p.add_argument("--fps", type=int, default=None, help="output fps cap") + p.add_argument("--global-brightness", type=int, default=255, help="0-255, applied at send") + p.add_argument("--duration", type=float, default=None, help="seconds to run (default: until Ctrl-C)") + what = p.add_mutually_exclusive_group() + what.add_argument("--test", action="store_true", help="red, green, blue, white, then black") + what.add_argument("--color", help="solid colour hex, e.g. ff0000") + what.add_argument("--preset", help="preset id from db/preset.json") + what.add_argument("--pattern", help="driver pattern name, e.g. rainbow") + p.add_argument("--colors", default="ffffff", help="comma-separated hex colours for --pattern") + p.add_argument("--delay", type=int, default=100) + p.add_argument("--brightness", type=int, default=255, help="preset brightness 0-255") + p.add_argument("--no-auto", action="store_true", help="manual (beat) mode: auto=false") + for i in range(1, 7): + p.add_argument(f"--n{i}", type=int, default=0) + return p + + +def _frame_cfgs(args): + urls = args.output or ["stdout://"] + cfgs = [] + for url in urls: + cfg = {"protocol": "stdout", "name": "stdout"} if url.startswith("stdout") else parse_output_url(url) + if args.leds is not None: + cfg["pixel_count"] = args.leds + cfg.setdefault("pixel_count", 60) + if args.fps is not None: + cfg["fps"] = args.fps + elif cfg["protocol"] == "stdout": + cfg.setdefault("fps", 20) + cfgs.append(cfg) + return cfgs + + +def _payload_from_args(args): + if args.preset: + from engine.presets import preset_payload + payload = preset_payload(args.preset) + if payload is None: + raise SystemExit(f"preset {args.preset!r} not found") + return args.preset, payload + if args.color: + return "cli", {"p": "on", "c": ["#" + args.color.lstrip("#")], "b": args.brightness} + payload = { + "p": args.pattern or "rainbow", + "c": ["#" + c.strip().lstrip("#") for c in args.colors.split(",") if c.strip()], + "d": args.delay, + "b": args.brightness, + "a": not args.no_auto, + } + for i in range(1, 7): + payload[f"n{i}"] = getattr(args, f"n{i}") + return "cli", payload + + +async def _run_test(player, step_s=1.0): + for color in ((255, 0, 0), (0, 255, 0), (0, 0, 255), (255, 255, 255)): + await player.apply("cli", {"p": "on", "c": [color], "b": 255}) + await asyncio.sleep(step_s) + + +async def run(args): + from engine.pattern_loader import get_library + + library = get_library() + if library.errors: + print(f"pattern load errors: {library.errors}", file=sys.stderr) + targets = ZoneTargets("cli", _frame_cfgs(args), []) + player = ZonePlayer(targets, library, lambda: args.global_brightness, output_factory=_output_factory) + await player.start() + try: + if args.test: + await _run_test(player) + return + preset_id, payload = _payload_from_args(args) + if payload.get("p") not in library.ids(): + raise SystemExit(f"unknown pattern {payload.get('p')!r}; available: {', '.join(library.ids())}") + await player.apply(preset_id, payload) + if args.duration: + await asyncio.sleep(args.duration) + else: + while True: + await asyncio.sleep(3600) + finally: + await player.stop() + print() + for st in player.status()["outputs"]: + print(f"{st['name']}: frames={st['frames']} packets={st['packets']} errors={st['errors']}" + + (f" last_error={st['last_error']}" if st["last_error"] else "")) + + +def main(argv=None): + args = build_parser().parse_args(argv) + try: + asyncio.run(run(args)) + except KeyboardInterrupt: + pass + + +if __name__ == "__main__": + main() diff --git a/src/engine/core.py b/src/engine/core.py new file mode 100644 index 0000000..8954f6a --- /dev/null +++ b/src/engine/core.py @@ -0,0 +1,89 @@ +"""Engine: one ZonePlayer per zone + the preset sequencer on top.""" + +import asyncio + +from engine.pattern_loader import get_library +from engine.player import ZonePlayer +from engine.presets import preset_payload +from engine.sequence_runner import SequenceRunner +from engine.zone_targets import resolve_zone + + +class EngineError(Exception): + def __init__(self, message, status=400): + super().__init__(message) + self.status = status + + +class Engine: + def __init__(self, library=None, brightness_getter=None, zone_resolver=None, + payload_resolver=None, player_factory=None, sequences_model=None): + self._library = library + self.brightness_getter = brightness_getter or (lambda: 255) + self._resolve_zone = zone_resolver or resolve_zone + self._payload = payload_resolver or preset_payload + self._player_factory = player_factory or ZonePlayer + self.players = {} + self._lock = None + self.sequences = SequenceRunner(self, sequences_model=sequences_model) + + @property + def library(self): + if self._library is None: + self._library = get_library() + return self._library + + def _get_lock(self): + if self._lock is None: + self._lock = asyncio.Lock() + return self._lock + + async def play(self, zone_id, preset_id, source="manual", drivers=True): + """Run ``preset_id`` on every target of ``zone_id`` (pixel outputs + ESP32s). + + ``source="manual"`` (UI pick) stops any sequence running on the zone. + ``drivers=False`` leaves the ESP32s alone (the UI already sent to them). + """ + zone_id = str(zone_id) + if source == "manual": + await self.sequences.stop_zone(zone_id) + targets = self._resolve_zone(zone_id) + if targets is None: + raise EngineError("Zone not found", 404) + payload = self._payload(str(preset_id)) + if payload is None: + raise EngineError("Preset not found", 404) + async with self._get_lock(): + player = self.players.get(zone_id) + if player is not None and player.targets.signature() != targets.signature(): + await player.stop() + player = None + if player is None: + player = self._player_factory(targets, self.library, self.brightness_getter) + await player.start() + self.players[zone_id] = player + await player.apply(str(preset_id), payload, drivers=drivers) + return player.status() + + async def stop(self, zone_id): + """Stop the zone's sequence and Pi rendering (pixel outputs go black).""" + zone_id = str(zone_id) + await self.sequences.stop_zone(zone_id) + async with self._get_lock(): + player = self.players.pop(zone_id, None) + if player is not None: + await player.stop() + return player is not None + + async def stop_all(self, persist=False): + await self.sequences.stop_all(persist=persist) + async with self._get_lock(): + players, self.players = list(self.players.values()), {} + for player in players: + await player.stop() + + def status(self): + return { + "zones": {zid: p.status() for zid, p in self.players.items()}, + "sequences": self.sequences.status(), + } diff --git a/src/engine/frame_driver.py b/src/engine/frame_driver.py new file mode 100644 index 0000000..635298b --- /dev/null +++ b/src/engine/frame_driver.py @@ -0,0 +1,68 @@ +"""Stand-in for the led-driver ``Presets`` object that patterns draw into. + +Same surface the patterns use on the ESP32 (``n[i]``, ``n.write()``, +``n.fill``, ``num_leds``, ``step``, ``fill``, ``off``, ``on``, +``apply_brightness``), but ``write()`` hands the frame to a callback instead +of a NeoPixel strip. +""" + + +class PixelBuffer: + """NeoPixel-compatible buffer of RGB tuples.""" + + def __init__(self, num_leds, on_write=None): + self.n = int(num_leds) + self._px = [(0, 0, 0)] * self.n + self.on_write = on_write + + def __len__(self): + return self.n + + def __setitem__(self, i, color): + self._px[i] = (int(color[0]) & 0xFF, int(color[1]) & 0xFF, int(color[2]) & 0xFF) + + def __getitem__(self, i): + return self._px[i] + + def fill(self, color): + c = (int(color[0]) & 0xFF, int(color[1]) & 0xFF, int(color[2]) & 0xFF) + self._px = [c] * self.n + + def to_bytes(self): + out = bytearray(self.n * 3) + for i, (r, g, b) in enumerate(self._px): + j = i * 3 + out[j] = r + out[j + 1] = g + out[j + 2] = b + return bytes(out) + + def write(self): + if self.on_write is not None: + self.on_write(self.to_bytes()) + + +class FrameDriver: + def __init__(self, num_leds, on_write=None): + self.num_leds = int(num_leds) + self.n = PixelBuffer(self.num_leds, on_write) + self.step = 0 + # Global brightness is applied per output at send time, not here. + self.b = 255 + + def apply_brightness(self, color, brightness_override=None): + local = brightness_override if brightness_override is not None else 255 + effective_brightness = int(local * self.b / 255) + return tuple(int(c * effective_brightness / 255) for c in color) + + def fill(self, color=None): + self.n.fill(color if color is not None else (0, 0, 0)) + self.n.write() + + def off(self, preset=None): + self.fill((0, 0, 0)) + + def on(self, preset): + colors = preset.c + color = colors[0] if colors else (255, 255, 255) + self.fill(self.apply_brightness(color, preset.b)) diff --git a/src/engine/mpcompat.py b/src/engine/mpcompat.py new file mode 100644 index 0000000..0131838 --- /dev/null +++ b/src/engine/mpcompat.py @@ -0,0 +1,86 @@ +"""MicroPython compatibility for running led-driver patterns under CPython. + +Installs a ``utime`` module whose clock is chosen per thread: + +* ``RealClock`` — monotonic wall clock, ``sleep_ms`` really sleeps (render threads). +* ``VirtualClock`` — manual time; ``sleep_ms`` just advances it (tests, offline render). + +Patterns only use ``ticks_ms``/``ticks_diff``/``ticks_add``/``sleep_ms``; tick +values never wrap here, so the diff/add helpers are plain arithmetic. +""" + +import sys +import threading +import time +import types + + +class RealClock: + def __init__(self): + self._t0 = time.monotonic() + + def ticks_ms(self): + return int((time.monotonic() - self._t0) * 1000) + + def ticks_us(self): + return int((time.monotonic() - self._t0) * 1000000) + + def sleep_ms(self, ms): + if ms > 0: + time.sleep(ms / 1000.0) + + +class VirtualClock: + def __init__(self, start_ms=0): + self.now_us = int(start_ms) * 1000 + + def ticks_ms(self): + return self.now_us // 1000 + + def ticks_us(self): + return self.now_us + + def advance_ms(self, ms): + self.now_us += int(ms * 1000) + + def sleep_ms(self, ms): + if ms > 0: + self.advance_ms(ms) + + +_local = threading.local() +_default_clock = RealClock() + + +def current_clock(): + return getattr(_local, "clock", None) or _default_clock + + +def set_thread_clock(clock): + """Use ``clock`` for ``utime`` calls made on the current thread (None = real).""" + _local.clock = clock + + +def _build_utime(): + mod = types.ModuleType("utime") + mod.ticks_ms = lambda: current_clock().ticks_ms() + mod.ticks_us = lambda: current_clock().ticks_us() + mod.ticks_cpu = mod.ticks_us + mod.ticks_diff = lambda a, b: a - b + mod.ticks_add = lambda a, b: a + b + mod.sleep_ms = lambda ms: current_clock().sleep_ms(ms) + mod.sleep_us = lambda us: current_clock().sleep_ms(us / 1000.0) + mod.sleep = lambda s: current_clock().sleep_ms(s * 1000.0) + mod.time = time.time + mod.__led_controller_shim__ = True + return mod + + +def install(): + """Register the shim as ``utime`` (idempotent; never replaces a real utime).""" + existing = sys.modules.get("utime") + if existing is not None: + return existing + mod = _build_utime() + sys.modules["utime"] = mod + return mod diff --git a/src/engine/outputs/__init__.py b/src/engine/outputs/__init__.py new file mode 100644 index 0000000..7df3f1a --- /dev/null +++ b/src/engine/outputs/__init__.py @@ -0,0 +1,72 @@ +"""Engine output drivers and the factory that builds them from config.""" + +from urllib.parse import parse_qs, urlparse + +from engine.outputs.artnet import ArtNetOutput +from engine.outputs.base import FrameOutput, PresetOutput +from engine.outputs.ddp import DdpOutput +from engine.outputs.dmx_serial import DmxSerialOutput +from engine.outputs.sacn import SacnOutput + +FRAME_PROTOCOLS = { + "ddp": DdpOutput, + "artnet": ArtNetOutput, + "sacn": SacnOutput, + "dmx_serial": DmxSerialOutput, +} + +_URL_ALIASES = {"e131": "sacn", "dmx": "dmx_serial", "art-net": "artnet"} +_QUERY_KEYS = { + "pixels": "pixel_count", + "order": "color_order", + "offset": "pixel_offset", + "mode": "dmx_mode", +} + + +def open_output(cfg): + """Build a FrameOutput from an output record (``protocol`` selects the driver).""" + protocol = str((cfg or {}).get("protocol") or "").lower() + protocol = _URL_ALIASES.get(protocol, protocol) + cls = FRAME_PROTOCOLS.get(protocol) + if cls is None: + raise ValueError(f"unknown output protocol: {protocol!r}") + return cls(cfg) + + +def parse_output_url(url): + """``ddp://10.0.0.5:4048?pixels=300&order=grb`` → output config dict. + + ``dmx_serial:///dev/ttyUSB0?mode=open_dmx&channel=1`` for serial DMX. + """ + # urlparse rejects "_" in schemes (dmx_serial://), so split the scheme off first. + scheme, sep, rest = str(url).partition("://") + if not sep: + raise ValueError(f"output URL needs a scheme, e.g. ddp://host: {url!r}") + scheme = scheme.strip().lower() + protocol = _URL_ALIASES.get(scheme, scheme) + parsed = urlparse("udp://" + rest) + cfg = {"protocol": protocol, "name": url} + if protocol == "dmx_serial": + cfg["serial_port"] = parsed.path or parsed.netloc + else: + if parsed.hostname: + cfg["host"] = parsed.hostname + if parsed.port: + cfg["port"] = parsed.port + for key, values in parse_qs(parsed.query).items(): + cfg[_QUERY_KEYS.get(key, key)] = values[-1] + return cfg + + +__all__ = [ + "FrameOutput", + "PresetOutput", + "DdpOutput", + "ArtNetOutput", + "SacnOutput", + "DmxSerialOutput", + "FRAME_PROTOCOLS", + "open_output", + "parse_output_url", +] diff --git a/src/engine/outputs/artnet.py b/src/engine/outputs/artnet.py new file mode 100644 index 0000000..2401ed6 --- /dev/null +++ b/src/engine/outputs/artnet.py @@ -0,0 +1,78 @@ +"""Art-Net (ArtDMX) output — UDP 6454. + +ArtDMX packet: + 0 "Art-Net\\0" + 8 OpCode 0x5000 (little-endian) + 10 ProtVer 14 (big-endian) + 12 Sequence 1..255 (0 disables re-ordering) + 13 Physical 0 + 14 Port-Address: SubUni (low byte), Net (high 7 bits) + 16 Length (big-endian, even, 2..512) + 18 DMX data + +170 RGB pixels per universe; consecutive universes from ``universe``. +Optional ArtSync (OpCode 0x5200) after each frame when ``sync`` is set. +""" + +import struct + +from engine.outputs.base import UdpFrameOutput, _bool, _int, split_universes + +ARTNET_PORT = 6454 +ARTNET_ID = b"Art-Net\x00" +OP_DMX = 0x5000 +OP_SYNC = 0x5200 +PROT_VER = 14 + + +def build_artdmx(universe, data, sequence=0, physical=0): + data = bytes(data[:512]) + if len(data) % 2: + data += b"\x00" + if len(data) < 2: + data = data + bytes(2 - len(data)) + universe &= 0x7FFF + return ( + ARTNET_ID + + struct.pack("H", PROT_VER) + + bytes((sequence & 0xFF, physical & 0xFF, universe & 0xFF, (universe >> 8) & 0x7F)) + + struct.pack(">H", len(data)) + + data + ) + + +def build_artsync(): + return ARTNET_ID + struct.pack("H", PROT_VER) + b"\x00\x00" + + +class ArtNetOutput(UdpFrameOutput): + protocol = "artnet" + default_port = ARTNET_PORT + + def __init__(self, cfg): + super().__init__(cfg) + if not self.host: + self.host = "255.255.255.255" + self.broadcast = True + self.universe = _int(self.cfg.get("universe"), 0, 0, 0x7FFF) + self.sync = _bool(self.cfg.get("sync"), False) + self._sequence = 0 + + def next_sequence(self): + self._sequence = (self._sequence % 255) + 1 + return self._sequence + + def packets_for(self, payload): + seq = self.next_sequence() + packets = [ + build_artdmx(self.universe + i, chunk, seq) + for i, chunk in enumerate(split_universes(payload)) + ] + if self.sync: + packets.append(build_artsync()) + return packets + + async def _send_prepared(self, payload): + for packet in self.packets_for(payload): + self.sendto(packet) diff --git a/src/engine/outputs/base.py b/src/engine/outputs/base.py new file mode 100644 index 0000000..9be87be --- /dev/null +++ b/src/engine/outputs/base.py @@ -0,0 +1,254 @@ +"""Common output-driver interface and helpers. + +Two kinds of output: + +* ``FrameOutput`` — the Pi renders pixels and streams raw RGB frames + (DDP, Art-Net, sACN, USB-DMX). +* ``PresetOutput`` — the device renders itself; the engine only tells it which + preset to run (our ESP32 led-drivers over Wi-Fi / ESP-NOW). +""" + +import asyncio +import functools +import socket + +COLOR_ORDERS = { + "rgb": (0, 1, 2), + "rbg": (0, 2, 1), + "grb": (1, 0, 2), + "gbr": (1, 2, 0), + "brg": (2, 0, 1), + "bgr": (2, 1, 0), +} + +DEFAULT_FPS = 40 + + +def _int(value, default, lo=None, hi=None): + try: + v = int(value) + except (TypeError, ValueError): + v = default + if lo is not None: + v = max(lo, v) + if hi is not None: + v = min(hi, v) + return v + + +def _bool(value, default=False): + if isinstance(value, bool): + return value + if isinstance(value, (int, float)): + return bool(value) + if isinstance(value, str): + s = value.strip().lower() + if s in ("1", "true", "yes", "on"): + return True + if s in ("0", "false", "no", "off"): + return False + return default + + +class OutputStats: + def __init__(self): + self.frames = 0 + self.packets = 0 + self.bytes = 0 + self.errors = 0 + self.last_error = None + + def error(self, exc): + self.errors += 1 + self.last_error = repr(exc) + + def to_dict(self): + return { + "frames": self.frames, + "packets": self.packets, + "bytes": self.bytes, + "errors": self.errors, + "last_error": self.last_error, + } + + +class FrameOutput: + """Base class for pixel-streaming outputs.""" + + kind = "frame" + protocol = "" + # Resend the last frame this often when the pattern is static, so receivers + # don't time out (sACN drops a source after 2.5 s; DMX expects a steady stream). + keepalive_s = 1.0 + + def __init__(self, cfg): + cfg = dict(cfg or {}) + self.cfg = cfg + self.name = str(cfg.get("name") or cfg.get("id") or self.protocol) + self.pixel_count = _int(cfg.get("pixel_count"), 60, 1, 100000) + self.pixel_offset = _int(cfg.get("pixel_offset"), 0, 0) + order = str(cfg.get("color_order") or "rgb").lower() + self.color_order = order if order in COLOR_ORDERS else "rgb" + self.reverse = _bool(cfg.get("reverse"), False) + self.brightness = _int(cfg.get("brightness"), 255, 0, 255) + self.fps = _int(cfg.get("fps"), DEFAULT_FPS, 1, 120) + self.stats = OutputStats() + self._index_map = self._build_index_map() + + # -- frame preparation ------------------------------------------------- + + def _build_index_map(self): + """Byte index map: out[i] = src[map[i]] (colour order + reverse).""" + order = COLOR_ORDERS[self.color_order] + n = self.pixel_count + idx = [] + for p in range(n): + src_px = (n - 1 - p) if self.reverse else p + base = src_px * 3 + idx.extend((base + order[0], base + order[1], base + order[2])) + return idx + + @staticmethod + @functools.lru_cache(maxsize=64) + def brightness_table(level): + level = max(0, min(255, int(level))) + return bytes((v * level + 127) // 255 for v in range(256)) + + def prepare(self, rgb, global_brightness=255): + """Pad/truncate, apply brightness, colour order and reverse.""" + need = self.pixel_count * 3 + data = bytes(rgb[:need]) + if len(data) < need: + data = data + bytes(need - len(data)) + level = (self.brightness * max(0, min(255, int(global_brightness))) + 127) // 255 + if level < 255: + data = data.translate(self.brightness_table(level)) + if self.color_order == "rgb" and not self.reverse: + return data + m = self._index_map + return bytes(data[i] for i in m) + + # -- lifecycle ----------------------------------------------------------- + + async def open(self): + pass + + async def send(self, rgb, global_brightness=255): + """Send one frame of logical RGB (pixel_count*3 bytes).""" + try: + payload = self.prepare(rgb, global_brightness) + await self._send_prepared(payload) + self.stats.frames += 1 + except Exception as e: + self.stats.error(e) + + async def _send_prepared(self, payload): + raise NotImplementedError + + async def blackout(self): + await self.send(bytes(self.pixel_count * 3)) + + async def close(self): + try: + await self.blackout() + except Exception: + pass + + def status(self): + return { + "name": self.name, + "protocol": self.protocol, + "kind": self.kind, + "pixel_count": self.pixel_count, + **self.stats.to_dict(), + } + + +class _DatagramSink(asyncio.DatagramProtocol): + def __init__(self, owner): + self.owner = owner + + def error_received(self, exc): + self.owner.stats.error(exc) + + +class UdpFrameOutput(FrameOutput): + """FrameOutput that sends UDP datagrams to one host:port.""" + + default_port = 0 + + def __init__(self, cfg): + super().__init__(cfg) + self.host = str(self.cfg.get("host") or "").strip() + self.port = _int(self.cfg.get("port"), self.default_port, 1, 65535) + self.broadcast = _bool(self.cfg.get("broadcast"), False) + self._transport = None + + def destination(self): + return (self.host, self.port) + + def _make_socket(self): + sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + sock.setblocking(False) + if self.broadcast or self.host.endswith(".255"): + sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) + return sock + + async def open(self): + if self._transport is not None: + return + loop = asyncio.get_running_loop() + self._transport, _ = await loop.create_datagram_endpoint( + lambda: _DatagramSink(self), sock=self._make_socket() + ) + + def sendto(self, packet, addr=None): + if self._transport is None: + raise RuntimeError("output not open") + self._transport.sendto(packet, addr or self.destination()) + self.stats.packets += 1 + self.stats.bytes += len(packet) + + async def send(self, rgb, global_brightness=255): + if self._transport is None: + try: + await self.open() + except Exception as e: + self.stats.error(e) + return + await super().send(rgb, global_brightness) + + async def close(self): + await super().close() + if self._transport is not None: + self._transport.close() + self._transport = None + + +class PresetOutput: + """Base class for outputs that render presets on the device itself.""" + + kind = "preset" + protocol = "" + + def __init__(self, cfg=None): + self.cfg = dict(cfg or {}) + self.name = str(self.cfg.get("name") or self.protocol) + self.stats = OutputStats() + + async def open(self): + pass + + async def apply(self, preset_id, preset_payload): + raise NotImplementedError + + async def close(self): + pass + + def status(self): + return {"name": self.name, "protocol": self.protocol, "kind": self.kind, **self.stats.to_dict()} + + +def split_universes(data, channels_per_universe=510): + """Split RGB bytes into DMX-universe sized chunks (170 RGB px = 510 ch).""" + return [data[i:i + channels_per_universe] for i in range(0, len(data), channels_per_universe)] or [b""] diff --git a/src/engine/outputs/ddp.py b/src/engine/outputs/ddp.py new file mode 100644 index 0000000..c60ddff --- /dev/null +++ b/src/engine/outputs/ddp.py @@ -0,0 +1,61 @@ +"""DDP (Distributed Display Protocol) output — UDP 4048. + +Header (10 bytes, big-endian): + 0 flags 0x40 = version 1, | 0x01 = PUSH (last packet of a frame) + 1 sequence 1..15 (0 = sequence numbers unused) + 2 data type 0x0B = RGB, 8 bits per channel + 3 dest id 0x01 = default output device + 4 offset uint32 byte offset into the frame + 8 length uint16 payload length +""" + +import struct + +from engine.outputs.base import UdpFrameOutput, _int + +DDP_PORT = 4048 +DDP_FLAG_VER1 = 0x40 +DDP_FLAG_PUSH = 0x01 +DDP_TYPE_RGB8 = 0x0B +DDP_ID_DISPLAY = 0x01 +DDP_MAX_DATA = 1440 # 480 RGB pixels; fits a 1500-byte MTU + + +def build_ddp_packets(data, sequence, max_data=DDP_MAX_DATA, dest_id=DDP_ID_DISPLAY): + """Split one frame into DDP packets; PUSH set on the last.""" + packets = [] + total = len(data) + offset = 0 + while True: + chunk = data[offset:offset + max_data] + last = offset + len(chunk) >= total + flags = DDP_FLAG_VER1 | (DDP_FLAG_PUSH if last else 0) + header = struct.pack( + ">BBBBIH", flags, sequence & 0x0F, DDP_TYPE_RGB8, dest_id, offset, len(chunk) + ) + packets.append(header + bytes(chunk)) + offset += len(chunk) + if last: + break + return packets + + +class DdpOutput(UdpFrameOutput): + protocol = "ddp" + default_port = DDP_PORT + + def __init__(self, cfg): + super().__init__(cfg) + self.dest_id = _int(self.cfg.get("dest_id"), DDP_ID_DISPLAY, 0, 255) + self._sequence = 0 + + def next_sequence(self): + self._sequence = (self._sequence % 15) + 1 + return self._sequence + + def packets_for(self, payload): + return build_ddp_packets(payload, self.next_sequence(), dest_id=self.dest_id) + + async def _send_prepared(self, payload): + for packet in self.packets_for(payload): + self.sendto(packet) diff --git a/src/engine/outputs/dmx_serial.py b/src/engine/outputs/dmx_serial.py new file mode 100644 index 0000000..88431f1 --- /dev/null +++ b/src/engine/outputs/dmx_serial.py @@ -0,0 +1,97 @@ +"""USB-DMX output via pyserial (one universe, 512 channels). + +Modes: + enttec_pro Enttec DMX USB Pro: 0x7E, label 6, len LE, start code + data, 0xE7 + open_dmx FTDI "Open DMX": 250000 baud 8N2, break, MAB, start code + 512 slots + +Pixels start at DMX channel ``channel`` (1-based). Max 170 RGB pixels. +""" + +import asyncio +import struct +import time + +from engine.outputs.base import FrameOutput, _int + +ENTTEC_SOM = 0x7E +ENTTEC_EOM = 0xE7 +ENTTEC_LABEL_SEND_DMX = 6 +DMX_CHANNELS = 512 + + +def dmx_universe(payload, channel=1): + """512-slot universe with ``payload`` starting at 1-based ``channel``.""" + start = max(1, int(channel)) - 1 + universe = bytearray(DMX_CHANNELS) + data = bytes(payload[: max(0, DMX_CHANNELS - start)]) + universe[start:start + len(data)] = data + return bytes(universe) + + +def build_enttec_pro(universe): + body = b"\x00" + bytes(universe) # start code 0 + return bytes((ENTTEC_SOM, ENTTEC_LABEL_SEND_DMX)) + struct.pack("= 88 us break + ser.break_condition = False + time.sleep(0.000012) # >= 8 us mark-after-break + ser.write(data) + self.stats.packets += 1 + self.stats.bytes += len(data) + + async def _send_prepared(self, payload): + async with self._lock: + if self._ser is None: + await self.open() + await asyncio.to_thread(self._write, self.frame_bytes(payload)) + + async def close(self): + await super().close() + if self._ser is not None: + try: + self._ser.close() + except Exception: + pass + self._ser = None diff --git a/src/engine/outputs/driver.py b/src/engine/outputs/driver.py new file mode 100644 index 0000000..6995c63 --- /dev/null +++ b/src/engine/outputs/driver.py @@ -0,0 +1,75 @@ +"""Preset output for our own ESP32 led-drivers (Wi-Fi and ESP-NOW). + +The firmware renders patterns itself, so the engine only sends the preset +definition followed by a ``select`` for the zone's device names — the same +two-message sequence the UI posts to ``/presets/push`` today. +""" + +import json + +from engine.outputs.base import PresetOutput +from models.device import Device +from models.transport import get_current_sender +from util.driver_delivery import deliver_json_messages + + +def resolve_device_macs(names, devices=None): + """Zone device names → MACs, one distinct device per repeated name (as zones.js).""" + devices = devices if devices is not None else Device() + used = set() + rows = [] + for raw in names or []: + name = str(raw or "").strip() + if not name: + continue + for mac, doc in devices.items(): + if mac in used or not isinstance(doc, dict): + continue + if str(doc.get("name") or "").strip() == name: + used.add(mac) + rows.append((name, mac)) + break + return rows + + +class DriverOutput(PresetOutput): + protocol = "driver" + + def __init__(self, names, cfg=None, sender_getter=None, devices=None, save=False, delay_s=0.05): + super().__init__(cfg) + self.names = [str(n).strip() for n in (names or []) if str(n or "").strip()] + self.name = self.cfg.get("name") or ",".join(self.names) or "driver" + self._sender_getter = sender_getter or get_current_sender + self._devices = devices + self.save = bool(save) + self.delay_s = delay_s + + def messages_for(self, preset_id, preset_payload): + pid = str(preset_id) + preset_msg = {"v": "1", "presets": {pid: preset_payload}} + if self.save: + preset_msg["save"] = True + messages = [json.dumps(preset_msg)] + names = list(dict.fromkeys(self.names)) + if names: + messages.append(json.dumps({"v": "1", "select": {n: [pid] for n in names}})) + return messages + + async def apply(self, preset_id, preset_payload): + sender = self._sender_getter() + if sender is None: + self.stats.error(RuntimeError("transport not configured")) + return 0 + devices = self._devices if self._devices is not None else Device() + macs = [mac for _name, mac in resolve_device_macs(self.names, devices)] + try: + delivered, _ = await deliver_json_messages( + sender, self.messages_for(preset_id, preset_payload), macs or None, devices, + delay_s=self.delay_s, + ) + self.stats.frames += 1 + self.stats.packets += delivered + return delivered + except Exception as e: + self.stats.error(e) + return 0 diff --git a/src/engine/outputs/sacn.py b/src/engine/outputs/sacn.py new file mode 100644 index 0000000..37eb983 --- /dev/null +++ b/src/engine/outputs/sacn.py @@ -0,0 +1,92 @@ +"""sACN / E1.31 output — UDP 5568, multicast 239.255.. by default. + +One data packet per universe (170 RGB pixels each), 126-byte header + +start code + up to 512 slots. Layer lengths are 12-bit, OR'd with 0x7000 +(flags). +""" + +import socket +import struct +import uuid + +from engine.outputs.base import UdpFrameOutput, _bool, _int, split_universes + +SACN_PORT = 5568 +ACN_PACKET_ID = b"ASC-E1.17\x00\x00\x00" +VECTOR_ROOT_E131_DATA = 0x00000004 +VECTOR_E131_DATA_PACKET = 0x00000002 +VECTOR_DMP_SET_PROPERTY = 0x02 +DEFAULT_PRIORITY = 100 + + +def multicast_address(universe): + return f"239.255.{(universe >> 8) & 0xFF}.{universe & 0xFF}" + + +def stable_cid(seed): + """Deterministic 16-byte CID from a name, so receivers see one source.""" + return uuid.uuid5(uuid.NAMESPACE_URL, f"led-controller/sacn/{seed}").bytes + + +def build_e131(universe, data, sequence, cid, source_name="led-controller", priority=DEFAULT_PRIORITY): + slots = b"\x00" + bytes(data[:512]) # start code 0 + DMX + prop_count = len(slots) + dmp_len = 10 + prop_count + framing_len = 77 + dmp_len + root_len = 22 + framing_len + name = source_name.encode("utf-8")[:63].ljust(64, b"\x00") + + root = ( + struct.pack(">HH", 0x0010, 0x0000) + + ACN_PACKET_ID + + struct.pack(">HI", 0x7000 | root_len, VECTOR_ROOT_E131_DATA) + + bytes(cid) + ) + framing = ( + struct.pack(">HI", 0x7000 | framing_len, VECTOR_E131_DATA_PACKET) + + name + + struct.pack(">BHBBH", priority & 0xFF, 0, sequence & 0xFF, 0, universe & 0xFFFF) + ) + dmp = ( + struct.pack(">HBBHHH", 0x7000 | dmp_len, VECTOR_DMP_SET_PROPERTY, 0xA1, 0x0000, 0x0001, prop_count) + + slots + ) + return root + framing + dmp + + +class SacnOutput(UdpFrameOutput): + protocol = "sacn" + default_port = SACN_PORT + + def __init__(self, cfg): + super().__init__(cfg) + self.universe = _int(self.cfg.get("universe"), 1, 1, 63999) + self.priority = _int(self.cfg.get("priority"), DEFAULT_PRIORITY, 0, 200) + self.multicast = not self.host or _bool(self.cfg.get("multicast"), False) + self.source_name = str(self.cfg.get("source_name") or f"led-controller {self.name}") + self.cid = stable_cid(self.cfg.get("cid") or self.cfg.get("id") or self.name) + self._sequences = {} + + def _make_socket(self): + sock = super()._make_socket() + if self.multicast: + sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 8) + return sock + + def _next_sequence(self, universe): + seq = (self._sequences.get(universe, -1) + 1) & 0xFF + self._sequences[universe] = seq + return seq + + def packets_for(self, payload): + out = [] + for i, chunk in enumerate(split_universes(payload)): + u = self.universe + i + pkt = build_e131(u, chunk, self._next_sequence(u), self.cid, self.source_name, self.priority) + addr = (multicast_address(u), self.port) if self.multicast else self.destination() + out.append((pkt, addr)) + return out + + async def _send_prepared(self, payload): + for packet, addr in self.packets_for(payload): + self.sendto(packet, addr) diff --git a/src/engine/pattern_loader.py b/src/engine/pattern_loader.py new file mode 100644 index 0000000..a601939 --- /dev/null +++ b/src/engine/pattern_loader.py @@ -0,0 +1,116 @@ +"""Load the led-driver pattern modules (and its Preset class) for Pi-side rendering. + +Mirrors ``Presets._load_dynamic_patterns`` in ``led-driver/src/presets.py``: +every ``*.py`` in the patterns dir except ``__init__.py``/``main.py``, using +the first class in the module that has ``run()``. +""" + +import importlib.util +import os +import threading + +from engine import mpcompat +from util.driver_patterns import driver_patterns_dir + +_MODULE_PREFIX = "led_driver_patterns." + + +def _load_module(name, path): + spec = importlib.util.spec_from_file_location(name, path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +class _FallbackPreset: + """Used only when led-driver/src/preset.py is not deployed next to the patterns.""" + + _aliases = {"pattern": "p", "colors": "c", "delay": "d", "brightness": "b", "auto": "a"} + + def __init__(self, data): + self.p, self.d, self.b, self.c, self.a = "off", 100, 127, [(255, 255, 255)], True + self.n1 = self.n2 = self.n3 = self.n4 = self.n5 = self.n6 = 0 + self.edit(data) + + def edit(self, data=None): + for key, value in (data or {}).items(): + key = self._aliases.get(key, key) + if key in ("d", "b", "n1", "n2", "n3", "n4", "n5", "n6"): + try: + value = max(0, int(value)) + except (TypeError, ValueError): + continue + if key == "b": + value = min(255, value) + elif key == "a": + value = bool(value) + elif key not in ("p", "c"): + continue + setattr(self, key, value) + return True + + +class PatternLibrary: + def __init__(self, patterns_dir=None): + self.patterns_dir = patterns_dir or driver_patterns_dir() + self._lock = threading.Lock() + self.classes = {} + self.errors = {} + self.preset_class = _FallbackPreset + self.load() + + def load(self): + mpcompat.install() + classes, errors = {}, {} + try: + files = sorted(os.listdir(self.patterns_dir)) + except OSError as e: + files = [] + errors["*"] = repr(e) + for filename in files: + if not filename.endswith(".py") or filename in ("__init__.py", "main.py"): + continue + base = filename[:-3] + try: + module = _load_module(_MODULE_PREFIX + base, os.path.join(self.patterns_dir, filename)) + except Exception as e: + errors[base] = repr(e) + continue + for attr_name in dir(module): + attr = getattr(module, attr_name) + if isinstance(attr, type) and hasattr(attr, "run"): + classes[base] = attr + break + preset_cls = _FallbackPreset + preset_path = os.path.join(os.path.dirname(self.patterns_dir), "preset.py") + if os.path.isfile(preset_path): + try: + preset_cls = _load_module("led_driver_preset", preset_path).Preset + except Exception as e: + errors["preset.py"] = repr(e) + with self._lock: + self.classes = classes + self.errors = errors + self.preset_class = preset_cls + return self + + reload = load + + def ids(self): + return sorted(set(self.classes) | {"on", "off"}) + + def get(self, pattern_id): + return self.classes.get(pattern_id) + + def make_preset(self, payload): + return self.preset_class(dict(payload or {})) + + +_library = None + + +def get_library(): + global _library + if _library is None: + _library = PatternLibrary() + return _library diff --git a/src/engine/player.py b/src/engine/player.py new file mode 100644 index 0000000..679c254 --- /dev/null +++ b/src/engine/player.py @@ -0,0 +1,148 @@ +"""Per-zone player: render on a thread, stream frames to pixel outputs. + +Modelled on portal's ``PatternPlayer``: the asyncio side only ships frames. +The render thread runs the driver pattern exactly like the ESP32 main loop, +and each ``n.write()`` wakes the sender, which pushes the newest frame to +every output (coalescing writes faster than the outputs' fps). +""" + +import asyncio +import time + +from engine.outputs import open_output +from engine.renderer import Renderer, RenderThread + +SEND_TIMEOUT_S = 0.05 + + +def _default_driver_output(names): + from engine.outputs.driver import DriverOutput # pulls in the Wi-Fi/serial stack + + return DriverOutput(names) + + +class ZonePlayer: + def __init__(self, targets, library, brightness_getter=None, output_factory=None, + driver_factory=None): + self.targets = targets + self.zone_id = targets.zone_id + self.library = library + self._brightness = brightness_getter or (lambda: 255) + make_output = output_factory or open_output + self.frame_outputs = [make_output(cfg) for cfg in targets.frame_cfgs] + make_driver = driver_factory or _default_driver_output + self.driver_output = make_driver(targets.driver_names) if targets.driver_names else None + self.preset_id = None + self.started_at = None + self._loop = None + self._latest = None + self._frame_event = None + self._sender_task = None + self._render = None + self.renderer = None + + @property + def fps(self): + return min((o.fps for o in self.frame_outputs), default=0) + + async def start(self): + self._loop = asyncio.get_running_loop() + if not self.frame_outputs: + return + for out in self.frame_outputs: + try: + await out.open() + except Exception as e: + out.stats.error(e) + self._frame_event = asyncio.Event() + self.renderer = Renderer(self.library, self.targets.frame_length, on_frame=self._on_frame_thread) + self._render = RenderThread(self.renderer, name=f"engine-zone-{self.zone_id}").start() + self._sender_task = asyncio.create_task(self._send_loop(), name=f"engine-send-{self.zone_id}") + + def _on_frame_thread(self, frame): + loop = self._loop + if loop is None or loop.is_closed(): + return + try: + loop.call_soon_threadsafe(self._frame_ready, frame) + except RuntimeError: + pass + + def _frame_ready(self, frame): + self._latest = frame + if self._frame_event is not None: + self._frame_event.set() + + async def send_frame(self, frame): + level = self._brightness() + tasks = [] + for out in self.frame_outputs: + start = out.pixel_offset * 3 + tasks.append(asyncio.ensure_future(out.send(frame[start:start + out.pixel_count * 3], level))) + if not tasks: + return + _done, pending = await asyncio.wait(tasks, timeout=SEND_TIMEOUT_S) + for t in pending: + t.cancel() + + @property + def keepalive_s(self): + return min((o.keepalive_s for o in self.frame_outputs), default=1.0) + + async def _send_loop(self): + interval = 1.0 / max(1, self.fps) + keepalive = self.keepalive_s + while True: + try: + await asyncio.wait_for(self._frame_event.wait(), timeout=keepalive) + except asyncio.TimeoutError: + pass # no new frame: resend the last one + self._frame_event.clear() + started = time.monotonic() + frame = self._latest + if frame is not None: + await self.send_frame(frame) + rest = interval - (time.monotonic() - started) + if rest > 0: + await asyncio.sleep(rest) + + async def apply(self, preset_id, payload, drivers=True): + self.preset_id = str(preset_id) + self.started_at = time.time() + if self._render is not None: + self._render.apply(preset_id, payload) + if drivers and self.driver_output is not None: + await self.driver_output.apply(preset_id, payload) + + async def stop(self): + if self._render is not None: + self._render.stop() + self._render = None + if self._sender_task is not None: + self._sender_task.cancel() + try: + await self._sender_task + except (asyncio.CancelledError, Exception): + pass + self._sender_task = None + for out in self.frame_outputs: + try: + await out.close() + except Exception: + pass + if self.driver_output is not None: + await self.driver_output.close() + + def status(self): + r = self.renderer + return { + "zone_id": self.zone_id, + "preset_id": self.preset_id, + "pattern": r.pattern_id if r else None, + "error": r.error if r else None, + "started_at": self.started_at, + "frame_length": self.targets.frame_length, + "fps": self.fps, + "outputs": [o.status() for o in self.frame_outputs] + + ([self.driver_output.status()] if self.driver_output else []), + } diff --git a/src/engine/presets.py b/src/engine/presets.py new file mode 100644 index 0000000..46c3042 --- /dev/null +++ b/src/engine/presets.py @@ -0,0 +1,61 @@ +"""Resolve stored presets into driver payloads (short keys, palette refs applied).""" + +from models.pallet import Palette +from models.preset import Preset as PresetModel +from models.profile import Profile +from util.espnow_message import build_preset_dict + + +def resolve_palette_colors(colors, palette_refs, palette): + """Same rule as presets.js ``resolveColorsWithPaletteRefs``.""" + base = list(colors) if isinstance(colors, list) else [] + refs = palette_refs if isinstance(palette_refs, list) else [] + pal = palette if isinstance(palette, list) else [] + out = [] + for idx, color in enumerate(base): + ref = refs[idx] if idx < len(refs) else None + try: + ref = int(ref) + except (TypeError, ValueError): + ref = None + if ref is not None and 0 <= ref < len(pal) and pal[ref]: + out.append(pal[ref]) + else: + out.append(color) + return out + + +def profile_palette(profile_id): + if profile_id is None: + return [] + profile = Profile().read(profile_id) or {} + palette_id = profile.get("palette_id") + if palette_id is None: + return [] + return Palette().read(palette_id) + + +def preset_payload(preset_id, preset_data=None): + """Driver payload (``p``, ``c``, ``d``, ``b``, ``a``, ``n1``..) for a stored preset.""" + data = preset_data if preset_data is not None else PresetModel().read(preset_id) + if not data: + return None + data = dict(data) + refs = data.get("palette_refs") + if refs: + data["colors"] = resolve_palette_colors( + data.get("colors") or [], refs, profile_palette(data.get("profile_id")) + ) + return build_preset_dict(data) + + +def hex_to_rgb(color): + if isinstance(color, (list, tuple)) and len(color) >= 3: + return tuple(max(0, min(255, int(c))) for c in color[:3]) + s = str(color or "").strip().lstrip("#") + if len(s) == 3: + s = "".join(ch * 2 for ch in s) + try: + return (int(s[0:2], 16), int(s[2:4], 16), int(s[4:6], 16)) + except (ValueError, IndexError): + return (255, 255, 255) diff --git a/src/engine/renderer.py b/src/engine/renderer.py new file mode 100644 index 0000000..1186e5b --- /dev/null +++ b/src/engine/renderer.py @@ -0,0 +1,157 @@ +"""Run one led-driver pattern generator and collect the frames it writes. + +``Renderer`` is synchronous and clock-agnostic (tests drive it with a +``VirtualClock``). ``RenderThread`` runs a Renderer on its own thread with the +real clock, the way the ESP32 main loop calls ``Presets.tick()``: patterns may +block in ``utime.sleep_ms`` between writes and every ``n.write()`` becomes a frame. +""" + +import threading +import time +import traceback +import types + +from engine import mpcompat +from engine.frame_driver import FrameDriver +from engine.presets import hex_to_rgb + +BUILTIN_PATTERNS = ("on", "off") + + +class Renderer: + def __init__(self, library, num_leds, on_frame=None): + self.library = library + self.on_frame = on_frame + self.driver = FrameDriver(num_leds, on_write=self._frame_written) + self.preset = None + self.preset_id = None + self.pattern_id = None + self.generator = None + self.last_frame = bytes(self.driver.num_leds * 3) + self.frame_count = 0 + self.error = None + + def _frame_written(self, frame): + self.last_frame = frame + self.frame_count += 1 + if self.on_frame is not None: + self.on_frame(frame) + + def set_preset(self, preset_id, payload): + """Select a preset, mirroring ``Presets.select`` (step reset rules included).""" + data = dict(payload or {}) + colors = data.get("c", data.get("colors")) + if isinstance(colors, list): + data["c"] = [hex_to_rgb(c) for c in colors] + data.pop("colors", None) + preset = self.library.make_preset(data) + pid = str(preset_id) + if preset.p == "off" or pid != self.preset_id: + self.driver.step = 0 + self.preset = preset + self.preset_id = pid + self.pattern_id = preset.p + self.error = None + self.generator = None + + if preset.p in BUILTIN_PATTERNS: + getattr(self.driver, preset.p)(preset) + return True + cls = self.library.get(preset.p) + if cls is None: + self.error = f"pattern not found: {preset.p}" + self.driver.off() + return False + try: + result = cls(self.driver).run(preset) + except Exception as e: + self.error = repr(e) + return False + if isinstance(result, types.GeneratorType): + self.generator = result + return True + + def tick(self): + """Advance the pattern by one generator step (one device tick).""" + gen = self.generator + if gen is None: + return False + try: + next(gen) + return True + except StopIteration: + self.generator = None + except Exception as e: + self.error = repr(e) + print(f"[engine] pattern {self.pattern_id!r} error: {e!r}") + self.generator = None + return False + + def render_virtual(self, preset_id, payload, ticks, tick_ms=1, clock=None): + """Offline render with a virtual clock; returns the list of frames written.""" + frames = [] + prev_cb = self.on_frame + self.on_frame = frames.append + clock = clock or mpcompat.VirtualClock() + mpcompat.set_thread_clock(clock) + try: + self.set_preset(preset_id, payload) + for _ in range(int(ticks)): + self.tick() + clock.advance_ms(tick_ms) + finally: + mpcompat.set_thread_clock(None) + self.on_frame = prev_cb + return frames + + +class RenderThread: + """Ticks a Renderer on a daemon thread; ``apply`` hot-swaps presets thread-safely.""" + + def __init__(self, renderer, tick_s=0.001, name="engine-render"): + self.renderer = renderer + self.tick_s = tick_s + self._pending = None + self._lock = threading.Lock() + self._wake = threading.Event() + self._stop = threading.Event() + self._thread = threading.Thread(target=self._run, name=name, daemon=True) + + def start(self): + self._thread.start() + return self + + def apply(self, preset_id, payload): + with self._lock: + self._pending = (preset_id, payload) + self._wake.set() + + def stop(self, timeout=1.0): + self._stop.set() + self._wake.set() + if self._thread.is_alive() and threading.current_thread() is not self._thread: + self._thread.join(timeout) + + def _take_pending(self): + with self._lock: + pending, self._pending = self._pending, None + return pending + + def _run(self): + mpcompat.set_thread_clock(mpcompat.RealClock()) + r = self.renderer + while not self._stop.is_set(): + pending = self._take_pending() + if pending is not None: + try: + r.set_preset(*pending) + except Exception: + traceback.print_exc() + if r.generator is None: + # Static frame (on/off/finished): sleep until the next preset. + self._wake.wait() + self._wake.clear() + continue + r.tick() + if self.tick_s: + time.sleep(self.tick_s) diff --git a/src/engine/sequence_runner.py b/src/engine/sequence_runner.py new file mode 100644 index 0000000..ae673c0 --- /dev/null +++ b/src/engine/sequence_runner.py @@ -0,0 +1,161 @@ +"""Preset sequencer — timed chains of presets per zone (portal's SequenceRunner). + +Each running sequence is an asyncio task: ``engine.play(zone, step)``, +``notify()``, ``sleep(duration_s)``, next step; loop / repeat_count decide +when it ends. Cuts are hard. At most one sequence runs per zone. +""" + +import asyncio +import time + + +class SequenceRunner: + def __init__(self, engine, sequences_model=None, notify=None): + self.engine = engine + self._model = sequences_model + self.notify = notify + self._tasks = {} # zone_id -> (sequence_id, task) + self._state = {} # sequence_id -> status dict + + @property + def model(self): + if self._model is None: + from models.squence import Sequence + self._model = Sequence() + return self._model + + def zone_for(self, sequence_id): + for zone_id, (sid, _task) in self._tasks.items(): + if sid == str(sequence_id): + return zone_id + return None + + async def play(self, sequence_id): + from engine.core import EngineError + + sid = str(sequence_id) + seq = self.model.read(sid) + if not seq: + raise EngineError("Sequence not found", 404) + zone_id = seq.get("zone_id") + if zone_id in (None, ""): + raise EngineError("Sequence has no zone_id", 400) + if not seq.get("steps"): + raise EngineError("Sequence has no steps", 400) + zone_id = str(zone_id) + await self.stop_zone(zone_id) + current = self.zone_for(sid) + if current is not None: + await self.stop_zone(current) + self.model.update(sid, {"active": True}) + self._state[sid] = { + "sequence_id": sid, + "zone_id": zone_id, + "step_index": 0, + "pass": 0, + "preset_id": None, + "started_at": time.time(), + "next_at": None, + "running": True, + } + task = asyncio.create_task(self._run(sid, zone_id), name=f"sequence-{sid}") + self._tasks[zone_id] = (sid, task) + return self._state[sid] + + async def _run(self, sid, zone_id): + state = self._state[sid] + passes = 0 + loop = asyncio.get_running_loop() + # Steps are scheduled on absolute deadlines so send latency doesn't drift the timing. + deadline = loop.time() + try: + while True: + seq = self.model.read(sid) or {} + steps = seq.get("steps") or [] + if not steps: + break + for index, step in enumerate(steps): + duration = float(step.get("duration_s") or 5) + state.update(step_index=index, preset_id=str(step.get("preset_id")), + next_at=time.time() + duration) + try: + await self.engine.play(zone_id, step.get("preset_id"), source="sequence") + except Exception as e: + state["error"] = str(e) + print(f"[sequence {sid}] step {index} failed: {e}") + self._notify(state) + deadline += duration + await asyncio.sleep(max(0.0, deadline - loop.time())) + passes += 1 + state["pass"] = passes + if not seq.get("loop", True): + break + repeat = int(seq.get("repeat_count") or 0) + if repeat and passes >= repeat: + break + except asyncio.CancelledError: + raise + finally: + state.update(running=False, next_at=None) + entry = self._tasks.get(zone_id) + if entry is not None and entry[0] == sid and entry[1] is asyncio.current_task(): + self._tasks.pop(zone_id, None) + # Finished on its own (not cancelled): no longer active. + self.model.update(sid, {"active": False}) + self._notify(state) + + def _notify(self, state): + if self.notify is not None: + try: + self.notify(dict(state)) + except Exception: + pass + + async def _cancel(self, zone_id, persist): + entry = self._tasks.pop(str(zone_id), None) + if entry is None: + return None + sid, task = entry + task.cancel() + try: + await task + except (asyncio.CancelledError, Exception): + pass + if persist: + self.model.update(sid, {"active": False}) + state = self._state.get(sid) + if state is not None: + state.update(running=False, next_at=None) + return sid + + async def stop(self, sequence_id): + zone_id = self.zone_for(sequence_id) + if zone_id is None: + self.model.update(str(sequence_id), {"active": False}) + return False + await self._cancel(zone_id, persist=True) + return True + + async def stop_zone(self, zone_id): + return await self._cancel(zone_id, persist=True) + + async def stop_all(self, persist=False): + """Cancel every sequence; ``persist=False`` keeps ``active`` so they resume on restart.""" + for zone_id in list(self._tasks): + await self._cancel(zone_id, persist=persist) + + async def resume_active(self): + started = [] + for sid in list(self.model.list()): + seq = self.model.read(sid) or {} + if seq.get("active"): + try: + await self.play(sid) + started.append(sid) + except Exception as e: + print(f"[sequence {sid}] resume failed: {e}") + self.model.update(sid, {"active": False}) + return started + + def status(self): + return {sid: dict(s) for sid, s in self._state.items()} diff --git a/src/engine/zone_targets.py b/src/engine/zone_targets.py new file mode 100644 index 0000000..89af2d6 --- /dev/null +++ b/src/engine/zone_targets.py @@ -0,0 +1,56 @@ +"""Resolve a zone's ``names`` into pixel outputs and ESP32 driver names. + +A name that matches an enabled record in ``db/output.json`` becomes a frame +output (the Pi renders for it); every other name is treated as an led-driver +device name and gets presets + ``select`` as today. +""" + +import json + +from models.output import Output +from models.zone import Zone + + +class ZoneTargets: + def __init__(self, zone_id, frame_cfgs, driver_names): + self.zone_id = str(zone_id) + self.frame_cfgs = frame_cfgs + self.driver_names = driver_names + + @property + def frame_length(self): + """Pixels the renderer must produce: outputs at offset 0 mirror the frame start.""" + return max( + (int(c.get("pixel_offset") or 0) + int(c.get("pixel_count") or 0) for c in self.frame_cfgs), + default=0, + ) + + def signature(self): + return json.dumps( + {"frames": self.frame_cfgs, "drivers": self.driver_names}, sort_keys=True + ) + + +def zone_names(zone): + names = zone.get("names") if isinstance(zone, dict) else None + return [str(n).strip() for n in (names or []) if str(n or "").strip()] + + +def resolve_zone(zone_id, zones=None, outputs=None): + zones = zones if zones is not None else Zone() + outputs = outputs if outputs is not None else Output() + zone = zones.read(zone_id) + if not zone: + return None + frame_cfgs, driver_names, seen = [], [], set() + for name in zone_names(zone): + matches = [o for o in outputs.by_name(name) if o.get("enabled", True)] + if matches: + for cfg in matches: + oid = str(cfg.get("id")) + if oid not in seen: + seen.add(oid) + frame_cfgs.append(dict(cfg)) + else: + driver_names.append(name) + return ZoneTargets(zone_id, frame_cfgs, driver_names) diff --git a/src/main.py b/src/main.py index 7817179..ed29abc 100644 --- a/src/main.py +++ b/src/main.py @@ -22,6 +22,9 @@ import controllers.pattern as pattern import controllers.settings as settings_controller import controllers.device as device_controller import controllers.led_tool as led_tool_controller +import controllers.output as output_controller +from engine import set_engine +from engine.core import Engine from models.transport import get_sender, set_sender, get_current_sender from models.device import Device, normalize_mac from models import wifi_ws_clients as tcp_client_registry @@ -261,6 +264,7 @@ async def main(port=80): ('/zones', zone, 'zone'), ('/palettes', palette, 'palette'), ('/scenes', scene, 'scene'), + ('/outputs', output_controller, 'output'), ] # Mount model controllers as subroutes @@ -275,6 +279,12 @@ async def main(port=80): app.mount(settings_controller.controller, '/settings') app.mount(device_controller.controller, '/devices') app.mount(led_tool_controller.controller, '/led-tool') + app.mount(output_controller.controller, '/outputs') + + # Pi-side animation engine: renders pixel outputs and runs sequences. + engine = set_engine(Engine( + brightness_getter=lambda: settings_controller.settings.get('global_brightness', 255), + )) tcp_client_registry.set_settings(settings) tcp_client_registry.set_tcp_status_broadcaster(broadcast_device_tcp_status) @@ -342,6 +352,15 @@ async def main(port=80): await _send_bridge_wifi_channel(settings, sender) _prime_wifi_outbound_driver_connections() + async def _resume_sequences(): + # Give Wi-Fi drivers a moment to connect before the first step. + await asyncio.sleep(2.0) + resumed = await engine.sequences.resume_active() + if resumed: + print(f"[engine] resumed sequences: {resumed}") + + asyncio.create_task(_resume_sequences()) + udp_holder = {"closing": False} loop = asyncio.get_running_loop() @@ -383,6 +402,11 @@ async def main(port=80): ) raise finally: + try: + # Keep sequence ``active`` flags so they resume after restart. + await engine.stop_all(persist=False) + except Exception as e: + print(f"[engine] stop failed: {e!r}") srv = getattr(app, "server", None) if srv is not None: try: diff --git a/src/models/output.py b/src/models/output.py new file mode 100644 index 0000000..7914bad --- /dev/null +++ b/src/models/output.py @@ -0,0 +1,138 @@ +""" +Pixel-output registry persisted in ``db/output.json``. + +Network / DMX fixtures that the Pi renders frames for (DDP, Art-Net, sACN, +USB-DMX). Our own ESP32 led-drivers stay in ``db/device.json``. **name** is +matched against zone ``names`` the same way device names are. +""" + +from models.model import Model + +OUTPUT_PROTOCOLS = ("ddp", "artnet", "sacn", "dmx_serial") +COLOR_ORDERS = ("rgb", "rbg", "grb", "gbr", "brg", "bgr") +DMX_MODES = ("enttec_pro", "open_dmx") + +_DEFAULTS = { + "name": "", + "protocol": "ddp", + "host": "", + "port": None, + "universe": None, + "channel": 1, + "serial_port": "", + "dmx_mode": "enttec_pro", + "pixel_count": 60, + "pixel_offset": 0, + "color_order": "rgb", + "reverse": False, + "brightness": 255, + "fps": 40, + "enabled": True, +} + + +def _int_field(doc, key, lo, hi, allow_none=False): + value = doc.get(key) + if value is None or value == "": + if allow_none: + doc[key] = None + return + raise ValueError(f"{key} is required") + try: + value = int(value) + except (TypeError, ValueError): + raise ValueError(f"{key} must be an integer") + if value < lo or value > hi: + raise ValueError(f"{key} must be between {lo} and {hi}") + doc[key] = value + + +def validate_output(data): + """Return a normalised output record or raise ValueError.""" + doc = dict(_DEFAULTS) + doc.update({k: v for k, v in (data or {}).items() if k != "id"}) + doc["name"] = str(doc.get("name") or "").strip() + if not doc["name"]: + raise ValueError("name is required") + protocol = str(doc.get("protocol") or "").strip().lower() + if protocol not in OUTPUT_PROTOCOLS: + raise ValueError(f"protocol must be one of: {', '.join(OUTPUT_PROTOCOLS)}") + doc["protocol"] = protocol + doc["host"] = str(doc.get("host") or "").strip() + doc["serial_port"] = str(doc.get("serial_port") or "").strip() + + if protocol == "ddp" and not doc["host"]: + raise ValueError("host is required for ddp") + if protocol == "dmx_serial": + if not doc["serial_port"]: + raise ValueError("serial_port is required for dmx_serial") + mode = str(doc.get("dmx_mode") or "enttec_pro").lower() + if mode not in DMX_MODES: + raise ValueError(f"dmx_mode must be one of: {', '.join(DMX_MODES)}") + doc["dmx_mode"] = mode + + _int_field(doc, "port", 1, 65535, allow_none=True) + if protocol == "sacn": + _int_field(doc, "universe", 1, 63999, allow_none=True) + else: + _int_field(doc, "universe", 0, 0x7FFF, allow_none=True) + _int_field(doc, "channel", 1, 512) + _int_field(doc, "pixel_count", 1, 100000) + _int_field(doc, "pixel_offset", 0, 100000) + _int_field(doc, "brightness", 0, 255) + _int_field(doc, "fps", 1, 120) + if protocol == "dmx_serial": + max_px = (512 - doc["channel"] + 1) // 3 + if doc["pixel_count"] > max_px: + raise ValueError(f"pixel_count must be at most {max_px} for one DMX universe from channel {doc['channel']}") + + order = str(doc.get("color_order") or "rgb").lower() + if order not in COLOR_ORDERS: + raise ValueError(f"color_order must be one of: {', '.join(COLOR_ORDERS)}") + doc["color_order"] = order + doc["reverse"] = bool(doc.get("reverse")) + doc["enabled"] = bool(doc.get("enabled", True)) + return doc + + +class Output(Model): + def __init__(self): + super().__init__() + + def create(self, data): + doc = validate_output(data) + next_id = self.get_next_id() + doc["id"] = next_id + self[next_id] = doc + self.save() + return next_id + + def read(self, id): + return self.get(str(id), None) + + def update(self, id, data): + id_str = str(id) + if id_str not in self: + return False + merged = dict(self[id_str]) + merged.update(data or {}) + doc = validate_output(merged) + doc["id"] = id_str + self[id_str] = doc + self.save() + return True + + def delete(self, id): + id_str = str(id) + if id_str not in self: + return False + self.pop(id_str) + self.save() + return True + + def list(self): + return list(self.keys()) + + def by_name(self, name): + n = str(name or "").strip() + return [doc for doc in self.values() if isinstance(doc, dict) and doc.get("name") == n] diff --git a/src/models/squence.py b/src/models/squence.py index 6d39ffb..c6c57ef 100644 --- a/src/models/squence.py +++ b/src/models/squence.py @@ -1,37 +1,105 @@ from models.model import Model +DURATION_MIN_S = 0.5 +DURATION_MAX_S = 600.0 +DURATION_DEFAULT_S = 5.0 + +_LEGACY_KEYS = ( + "group_name", "presets", "sequence_duration", "sequence_transition", "sequence_loop", + "sequence_repeat_count", "sequence_active", "sequence_index", "sequence_start_time", +) + + +def _normalize_step(step): + """``{"preset_id", "duration_s"}`` with duration clamped to 0.5–600 s (default 5).""" + if not isinstance(step, dict): + step = {"preset_id": step} + preset_id = step.get("preset_id") + if preset_id in (None, ""): + raise ValueError("each step needs a preset_id") + try: + duration = float(step.get("duration_s", DURATION_DEFAULT_S)) + except (TypeError, ValueError): + duration = DURATION_DEFAULT_S + duration = max(DURATION_MIN_S, min(DURATION_MAX_S, duration)) + return {"preset_id": str(preset_id), "duration_s": duration} + + +def _normalize(data): + doc = dict(data or {}) + doc["name"] = str(doc.get("name") or "").strip() + zone_id = doc.get("zone_id") + doc["zone_id"] = None if zone_id in (None, "") else str(zone_id) + doc["loop"] = bool(doc.get("loop", True)) + try: + doc["repeat_count"] = max(0, int(doc.get("repeat_count") or 0)) + except (TypeError, ValueError): + raise ValueError("repeat_count must be an integer") + steps = doc.get("steps") or [] + if not isinstance(steps, list): + raise ValueError("steps must be a list") + doc["steps"] = [_normalize_step(s) for s in steps] + doc["active"] = bool(doc.get("active", False)) + for key in _LEGACY_KEYS: + doc.pop(key, None) + return doc + + +def migrate_legacy(doc): + """Old ``presets`` + ``sequence_duration`` (ms) records → ``steps`` shape.""" + if not isinstance(doc, dict) or "steps" in doc: + return doc, False + try: + duration_s = float(doc.get("sequence_duration", 3000)) / 1000.0 + except (TypeError, ValueError): + duration_s = DURATION_DEFAULT_S + migrated = { + "name": doc.get("name") or doc.get("group_name") or "", + "zone_id": doc.get("zone_id"), + "loop": bool(doc.get("sequence_loop", True)), + "repeat_count": doc.get("sequence_repeat_count") or 0, + "steps": [{"preset_id": p, "duration_s": duration_s} for p in (doc.get("presets") or [])], + "active": False, + } + return _normalize(migrated), True + + class Sequence(Model): def __init__(self): super().__init__() - def create(self, group_name="", preset_names=None): + def load(self): + super().load() + changed = False + for key in list(self.keys()): + doc, migrated = migrate_legacy(self[key]) + if migrated: + self[key] = doc + changed = True + if changed: + self.save() + + def create(self, data=None): + doc = _normalize(data) next_id = self.get_next_id() - self[next_id] = { - "group_name": group_name, - "presets": preset_names if preset_names else [], - "sequence_duration": 3000, # Duration per preset in ms - "sequence_transition": 500, # Transition time in ms - "sequence_loop": False, - "sequence_repeat_count": 0, # 0 = infinite - "sequence_active": False, - "sequence_index": 0, - "sequence_start_time": 0 - } + self[next_id] = doc self.save() return next_id def read(self, id): id_str = str(id) return self.get(id_str, None) - + def update(self, id, data): id_str = str(id) if id_str not in self: return False - self[id_str].update(data) + merged = dict(self[id_str]) + merged.update(data or {}) + self[id_str] = _normalize(merged) self.save() return True - + def delete(self, id): id_str = str(id) if id_str not in self: @@ -39,6 +107,6 @@ class Sequence(Model): self.pop(id_str) self.save() return True - + def list(self): return list(self.keys()) diff --git a/src/static/outputs.js b/src/static/outputs.js new file mode 100644 index 0000000..4c9382a --- /dev/null +++ b/src/static/outputs.js @@ -0,0 +1,219 @@ +// Pixel outputs (db/output.json): DDP, Art-Net, sACN, USB-DMX fixtures the Pi renders for. + +const OUTPUT_PROTOCOL_LABELS = { + ddp: 'DDP', + artnet: 'Art-Net', + sacn: 'sACN', + dmx_serial: 'USB-DMX', +}; + +async function fetchOutputs() { + const res = await fetch('/outputs', { headers: { Accept: 'application/json' } }); + if (!res.ok) throw new Error('Failed to load outputs'); + return res.json(); +} + +function outputSummary(out) { + const proto = OUTPUT_PROTOCOL_LABELS[out.protocol] || out.protocol; + let where = ''; + if (out.protocol === 'dmx_serial') { + where = `${out.serial_port || '?'} ch ${out.channel || 1}`; + } else { + where = out.host || (out.protocol === 'sacn' ? 'multicast' : 'broadcast'); + if (out.port) where += `:${out.port}`; + if (out.protocol !== 'ddp' && out.universe != null) where += ` u${out.universe}`; + } + return `${proto} · ${where} · ${out.pixel_count} px${out.enabled === false ? ' · disabled' : ''}`; +} + +function renderOutputsList(outputs) { + const container = document.getElementById('outputs-list-modal'); + if (!container) return; + container.innerHTML = ''; + const ids = Object.keys(outputs || {}); + if (ids.length === 0) { + const p = document.createElement('p'); + p.className = 'muted-text'; + p.textContent = 'No outputs yet.'; + container.appendChild(p); + return; + } + ids.forEach((id) => { + const out = outputs[id]; + const row = document.createElement('div'); + row.className = 'profiles-row'; + row.style.display = 'flex'; + row.style.alignItems = 'center'; + row.style.gap = '0.5rem'; + row.style.flexWrap = 'wrap'; + + const label = document.createElement('span'); + label.style.flex = '1'; + label.innerHTML = ''; + const name = document.createElement('strong'); + name.textContent = out.name; + const meta = document.createElement('span'); + meta.className = 'muted-text'; + meta.textContent = ` ${outputSummary(out)}`; + label.appendChild(name); + label.appendChild(meta); + + const testBtn = document.createElement('button'); + testBtn.type = 'button'; + testBtn.className = 'btn btn-secondary btn-small'; + testBtn.textContent = 'Test'; + testBtn.title = 'Red, green, blue, white, then black'; + testBtn.addEventListener('click', async () => { + testBtn.disabled = true; + testBtn.textContent = 'Testing…'; + try { + const res = await fetch(`/outputs/${encodeURIComponent(id)}/test`, { method: 'POST' }); + const data = await res.json().catch(() => ({})); + if (!res.ok) throw new Error(data.error || res.statusText); + const st = data.status || {}; + testBtn.textContent = st.errors ? `Errors: ${st.errors}` : 'Sent'; + if (st.last_error) testBtn.title = st.last_error; + } catch (e) { + testBtn.textContent = 'Failed'; + testBtn.title = String(e.message || e); + } finally { + testBtn.disabled = false; + setTimeout(() => { testBtn.textContent = 'Test'; }, 2500); + } + }); + + const editBtn = document.createElement('button'); + editBtn.type = 'button'; + editBtn.className = 'btn btn-secondary btn-small'; + editBtn.textContent = 'Edit'; + editBtn.addEventListener('click', () => openOutputEditor(id, out)); + + const delBtn = document.createElement('button'); + delBtn.type = 'button'; + delBtn.className = 'btn btn-danger btn-small'; + delBtn.textContent = 'Delete'; + delBtn.addEventListener('click', async () => { + if (!confirm(`Delete output "${out.name}"?`)) return; + const res = await fetch(`/outputs/${encodeURIComponent(id)}`, { method: 'DELETE' }); + if (!res.ok) { + alert('Failed to delete output.'); + return; + } + loadOutputsModal(); + }); + + row.append(label, testBtn, editBtn, delBtn); + container.appendChild(row); + }); +} + +async function loadOutputsModal() { + const container = document.getElementById('outputs-list-modal'); + try { + renderOutputsList(await fetchOutputs()); + } catch (e) { + if (container) container.textContent = 'Failed to load outputs.'; + } +} + +function syncOutputProtocolFields() { + const proto = document.getElementById('edit-output-protocol').value; + document.querySelectorAll('#edit-output-form .engine-field').forEach((el) => { + const list = (el.dataset.protocols || '').split(/\s+/); + el.hidden = !list.includes(proto); + }); +} + +function setOutputField(id, value) { + const el = document.getElementById(id); + if (!el) return; + if (el.type === 'checkbox') el.checked = !!value; + else el.value = value == null ? '' : value; +} + +function openOutputEditor(id, out) { + const o = out || { + name: '', protocol: 'ddp', pixel_count: 60, pixel_offset: 0, color_order: 'rgb', + brightness: 255, fps: 40, channel: 1, dmx_mode: 'enttec_pro', enabled: true, reverse: false, + }; + document.getElementById('edit-output-title').textContent = id ? 'Edit output' : 'Add output'; + setOutputField('edit-output-id', id || ''); + setOutputField('edit-output-name', o.name); + setOutputField('edit-output-protocol', o.protocol); + setOutputField('edit-output-host', o.host); + setOutputField('edit-output-port', o.port); + setOutputField('edit-output-universe', o.universe); + setOutputField('edit-output-serial-port', o.serial_port); + setOutputField('edit-output-dmx-mode', o.dmx_mode || 'enttec_pro'); + setOutputField('edit-output-channel', o.channel || 1); + setOutputField('edit-output-pixel-count', o.pixel_count); + setOutputField('edit-output-pixel-offset', o.pixel_offset || 0); + setOutputField('edit-output-color-order', o.color_order || 'rgb'); + setOutputField('edit-output-brightness', o.brightness == null ? 255 : o.brightness); + setOutputField('edit-output-fps', o.fps || 40); + setOutputField('edit-output-reverse', o.reverse); + setOutputField('edit-output-enabled', o.enabled !== false); + const err = document.getElementById('edit-output-error'); + err.hidden = true; + syncOutputProtocolFields(); + document.getElementById('edit-output-modal').classList.add('active'); +} + +function readOutputForm() { + const val = (id) => document.getElementById(id).value.trim(); + const num = (id) => (val(id) === '' ? null : Number(val(id))); + return { + name: val('edit-output-name'), + protocol: val('edit-output-protocol'), + host: val('edit-output-host'), + port: num('edit-output-port'), + universe: num('edit-output-universe'), + serial_port: val('edit-output-serial-port'), + dmx_mode: val('edit-output-dmx-mode'), + channel: num('edit-output-channel') || 1, + pixel_count: num('edit-output-pixel-count'), + pixel_offset: num('edit-output-pixel-offset') || 0, + color_order: val('edit-output-color-order'), + brightness: num('edit-output-brightness'), + fps: num('edit-output-fps'), + reverse: document.getElementById('edit-output-reverse').checked, + enabled: document.getElementById('edit-output-enabled').checked, + }; +} + +document.addEventListener('DOMContentLoaded', () => { + const btn = document.getElementById('outputs-btn'); + const modal = document.getElementById('outputs-modal'); + const editModal = document.getElementById('edit-output-modal'); + const form = document.getElementById('edit-output-form'); + if (!btn || !modal || !form) return; + + btn.addEventListener('click', () => { + modal.classList.add('active'); + loadOutputsModal(); + }); + document.getElementById('outputs-close-btn').addEventListener('click', () => modal.classList.remove('active')); + document.getElementById('output-add-btn').addEventListener('click', () => openOutputEditor(null, null)); + document.getElementById('edit-output-close-btn').addEventListener('click', () => editModal.classList.remove('active')); + document.getElementById('edit-output-protocol').addEventListener('change', syncOutputProtocolFields); + + form.addEventListener('submit', async (e) => { + e.preventDefault(); + const id = document.getElementById('edit-output-id').value; + const err = document.getElementById('edit-output-error'); + err.hidden = true; + const res = await fetch(id ? `/outputs/${encodeURIComponent(id)}` : '/outputs', { + method: id ? 'PUT' : 'POST', + headers: { 'Content-Type': 'application/json', Accept: 'application/json' }, + body: JSON.stringify(readOutputForm()), + }); + const data = await res.json().catch(() => ({})); + if (!res.ok) { + err.textContent = data.error || 'Save failed'; + err.hidden = false; + return; + } + editModal.classList.remove('active'); + loadOutputsModal(); + }); +}); diff --git a/src/static/presets.js b/src/static/presets.js index f412b75..6076fd2 100644 --- a/src/static/presets.js +++ b/src/static/presets.js @@ -1859,6 +1859,10 @@ const createPresetButton = (presetId, preset, zoneId, isSelected = false) => { sendPresetViaEspNow(presetId, preset, deviceNames, false, false, '2').catch((err) => { console.error(err); }); + // Pi-side engine: pixel outputs in this zone + stop any running sequence. + if (typeof window.notifyEngineZonePlay === 'function') { + window.notifyEngineZonePlay(zoneId, presetId); + } }); if (canDrag) { diff --git a/src/static/sequences.js b/src/static/sequences.js new file mode 100644 index 0000000..e4230c7 --- /dev/null +++ b/src/static/sequences.js @@ -0,0 +1,296 @@ +// Sequences: timed preset chains per zone, run by the Pi-side engine. + +const SEQUENCES_POLL_MS = 1000; +let sequencesPollTimer = null; + +async function fetchJson(url) { + const res = await fetch(url, { headers: { Accept: 'application/json' }, credentials: 'same-origin' }); + if (!res.ok) throw new Error(`${url}: ${res.status}`); + return res.json(); +} + +async function loadSequenceContext() { + const [sequences, status, zonesData, presets] = await Promise.all([ + fetchJson('/sequences'), + fetchJson('/sequences/status'), + fetchJson('/zones'), + fetchJson('/presets'), + ]); + const order = Array.isArray(zonesData.zone_order) ? zonesData.zone_order : []; + const zones = {}; + order.forEach((zid) => { + if (zonesData.zones && zonesData.zones[zid]) zones[zid] = zonesData.zones[zid]; + }); + return { sequences, status, zones, presets }; +} + +function stepSummary(seq, presets, state) { + const steps = seq.steps || []; + const total = steps.reduce((s, st) => s + Number(st.duration_s || 0), 0); + let text = `${steps.length} step${steps.length === 1 ? '' : 's'} · ${total.toFixed(1)} s`; + text += seq.loop ? (seq.repeat_count ? ` · ×${seq.repeat_count}` : ' · loop') : ' · once'; + if (state && state.running) { + const p = presets[state.preset_id]; + text += ` · ▶ step ${state.step_index + 1}${p ? ` (${p.name})` : ''}`; + } + return text; +} + +function renderSequencesList(ctx) { + const container = document.getElementById('sequences-list-modal'); + if (!container) return; + const editMode = typeof isEditModeActive === 'function' && isEditModeActive(); + container.innerHTML = ''; + const ids = Object.keys(ctx.sequences || {}).filter((id) => { + const z = ctx.sequences[id].zone_id; + return z == null || ctx.zones[z]; // only this profile's zones (plus unassigned) + }); + if (ids.length === 0) { + const p = document.createElement('p'); + p.className = 'muted-text'; + p.textContent = 'No sequences yet.'; + container.appendChild(p); + return; + } + ids.forEach((id) => { + const seq = ctx.sequences[id]; + const state = ctx.status[id]; + const running = !!(state && state.running); + const zone = ctx.zones[seq.zone_id]; + + const row = document.createElement('div'); + row.className = 'profiles-row'; + row.style.display = 'flex'; + row.style.alignItems = 'center'; + row.style.gap = '0.5rem'; + row.style.flexWrap = 'wrap'; + + const label = document.createElement('span'); + label.style.flex = '1'; + const name = document.createElement('strong'); + name.textContent = seq.name || `Sequence ${id}`; + const meta = document.createElement('span'); + meta.className = 'muted-text'; + meta.textContent = ` ${zone ? zone.name : 'no zone'} · ${stepSummary(seq, ctx.presets, state)}`; + label.append(name, meta); + + const playBtn = document.createElement('button'); + playBtn.type = 'button'; + playBtn.className = running ? 'btn btn-danger btn-small' : 'btn btn-primary btn-small'; + playBtn.textContent = running ? 'Stop' : 'Play'; + playBtn.disabled = !zone || !(seq.steps || []).length; + playBtn.addEventListener('click', async () => { + playBtn.disabled = true; + const res = await fetch(`/sequences/${encodeURIComponent(id)}/${running ? 'stop' : 'play'}`, { + method: 'POST', credentials: 'same-origin', + }); + if (!res.ok) { + const data = await res.json().catch(() => ({})); + alert(data.error || 'Failed'); + } + refreshSequencesList(); + }); + row.append(label, playBtn); + + if (editMode) { + const editBtn = document.createElement('button'); + editBtn.type = 'button'; + editBtn.className = 'btn btn-secondary btn-small'; + editBtn.textContent = 'Edit'; + editBtn.addEventListener('click', () => openSequenceEditor(id, seq, ctx)); + const delBtn = document.createElement('button'); + delBtn.type = 'button'; + delBtn.className = 'btn btn-danger btn-small'; + delBtn.textContent = 'Delete'; + delBtn.addEventListener('click', async () => { + if (!confirm(`Delete sequence "${seq.name}"?`)) return; + await fetch(`/sequences/${encodeURIComponent(id)}`, { method: 'DELETE' }); + refreshSequencesList(); + }); + row.append(editBtn, delBtn); + } + container.appendChild(row); + }); +} + +let lastSequenceCtx = null; + +async function refreshSequencesList() { + try { + lastSequenceCtx = await loadSequenceContext(); + renderSequencesList(lastSequenceCtx); + } catch (e) { + const container = document.getElementById('sequences-list-modal'); + if (container && !lastSequenceCtx) container.textContent = 'Failed to load sequences.'; + } +} + +function stopSequencesPoll() { + if (sequencesPollTimer != null) { + clearInterval(sequencesPollTimer); + sequencesPollTimer = null; + } +} + +function addStepRow(presets, step) { + const container = document.getElementById('edit-sequence-steps'); + const row = document.createElement('div'); + row.className = 'engine-step-row'; + + const select = document.createElement('select'); + select.className = 'engine-step-preset'; + Object.entries(presets || {}).forEach(([pid, p]) => { + const opt = document.createElement('option'); + opt.value = pid; + opt.textContent = p.name || pid; + select.appendChild(opt); + }); + if (step && step.preset_id != null) select.value = String(step.preset_id); + + const dur = document.createElement('input'); + dur.type = 'number'; + dur.min = '0.5'; + dur.max = '600'; + dur.step = '0.5'; + dur.className = 'engine-step-duration'; + dur.value = step && step.duration_s != null ? step.duration_s : 5; + dur.title = 'Seconds'; + + const unit = document.createElement('span'); + unit.className = 'muted-text'; + unit.textContent = 's'; + + const mk = (text, title, fn) => { + const b = document.createElement('button'); + b.type = 'button'; + b.className = 'btn btn-secondary btn-small'; + b.textContent = text; + b.title = title; + b.addEventListener('click', fn); + return b; + }; + const up = mk('↑', 'Move up', () => { if (row.previousElementSibling) container.insertBefore(row, row.previousElementSibling); }); + const down = mk('↓', 'Move down', () => { if (row.nextElementSibling) container.insertBefore(row.nextElementSibling, row); }); + const del = mk('✕', 'Remove step', () => row.remove()); + + row.append(select, dur, unit, up, down, del); + container.appendChild(row); +} + +function openSequenceEditor(id, seq, ctx) { + const s = seq || { name: '', zone_id: null, loop: true, repeat_count: 0, steps: [] }; + document.getElementById('edit-sequence-title').textContent = id ? 'Edit sequence' : 'New sequence'; + document.getElementById('edit-sequence-id').value = id || ''; + document.getElementById('edit-sequence-name').value = s.name || ''; + const zoneSel = document.getElementById('edit-sequence-zone'); + zoneSel.innerHTML = ''; + Object.entries(ctx.zones).forEach(([zid, z]) => { + const opt = document.createElement('option'); + opt.value = zid; + opt.textContent = z.name || zid; + zoneSel.appendChild(opt); + }); + const currentZone = s.zone_id + || (window.zonesManager && window.zonesManager.getCurrentZoneId && window.zonesManager.getCurrentZoneId()); + if (currentZone && ctx.zones[currentZone]) zoneSel.value = String(currentZone); + document.getElementById('edit-sequence-loop').checked = s.loop !== false; + document.getElementById('edit-sequence-repeat').value = s.repeat_count || 0; + const steps = document.getElementById('edit-sequence-steps'); + steps.innerHTML = ''; + (s.steps || []).forEach((st) => addStepRow(ctx.presets, st)); + if (!(s.steps || []).length) addStepRow(ctx.presets, null); + document.getElementById('edit-sequence-error').hidden = true; + document.getElementById('edit-sequence-modal').classList.add('active'); +} + +function readSequenceForm() { + const steps = []; + document.querySelectorAll('#edit-sequence-steps .engine-step-row').forEach((row) => { + const pid = row.querySelector('.engine-step-preset').value; + const dur = Number(row.querySelector('.engine-step-duration').value); + if (pid) steps.push({ preset_id: pid, duration_s: Number.isFinite(dur) ? dur : 5 }); + }); + return { + name: document.getElementById('edit-sequence-name').value.trim(), + zone_id: document.getElementById('edit-sequence-zone').value || null, + loop: document.getElementById('edit-sequence-loop').checked, + repeat_count: Number(document.getElementById('edit-sequence-repeat').value) || 0, + steps, + }; +} + +// Tell the engine a preset was picked on a zone: renders it on the zone's pixel +// outputs and stops any sequence there. ESP32s were already sent the preset +// by presets.js, so the engine leaves them alone (drivers: false). +async function notifyEngineZonePlay(zoneId, presetId) { + if (!zoneId || !presetId) return; + try { + await fetch(`/zones/${encodeURIComponent(zoneId)}/play`, { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + credentials: 'same-origin', + body: JSON.stringify({ preset_id: String(presetId), drivers: false }), + }); + } catch (e) { + console.warn('Engine zone play failed:', e); + } +} +window.notifyEngineZonePlay = notifyEngineZonePlay; + +document.addEventListener('DOMContentLoaded', () => { + const btn = document.getElementById('sequences-btn'); + const modal = document.getElementById('sequences-modal'); + const editModal = document.getElementById('edit-sequence-modal'); + const form = document.getElementById('edit-sequence-form'); + if (!btn || !modal || !form) return; + + btn.addEventListener('click', () => { + modal.classList.add('active'); + refreshSequencesList(); + stopSequencesPoll(); + sequencesPollTimer = setInterval(refreshSequencesList, SEQUENCES_POLL_MS); + }); + document.getElementById('sequences-close-btn').addEventListener('click', () => { + modal.classList.remove('active'); + }); + new MutationObserver(() => { + if (!modal.classList.contains('active')) stopSequencesPoll(); + }).observe(modal, { attributes: true, attributeFilter: ['class'] }); + + document.getElementById('sequence-add-btn').addEventListener('click', async () => { + const ctx = lastSequenceCtx || await loadSequenceContext(); + openSequenceEditor(null, null, ctx); + }); + document.getElementById('edit-sequence-add-step-btn').addEventListener('click', () => { + addStepRow((lastSequenceCtx && lastSequenceCtx.presets) || {}, null); + }); + document.getElementById('edit-sequence-close-btn').addEventListener('click', () => { + editModal.classList.remove('active'); + }); + + form.addEventListener('submit', async (e) => { + e.preventDefault(); + const id = document.getElementById('edit-sequence-id').value; + const err = document.getElementById('edit-sequence-error'); + err.hidden = true; + const body = readSequenceForm(); + if (!body.steps.length) { + err.textContent = 'Add at least one step.'; + err.hidden = false; + return; + } + const res = await fetch(id ? `/sequences/${encodeURIComponent(id)}` : '/sequences', { + method: id ? 'PUT' : 'POST', + headers: { 'Content-Type': 'application/json', Accept: 'application/json' }, + body: JSON.stringify(body), + }); + const data = await res.json().catch(() => ({})); + if (!res.ok) { + err.textContent = data.error || 'Save failed'; + err.hidden = false; + return; + } + editModal.classList.remove('active'); + refreshSequencesList(); + }); +}); diff --git a/src/static/style.css b/src/static/style.css index d6335d4..70679be 100644 --- a/src/static/style.css +++ b/src/static/style.css @@ -1389,3 +1389,68 @@ body.preset-ui-run .edit-mode-only { }#settings-modal .settings-section.ap-settings-section { margin-top: 1.5rem; } + +/* Engine: outputs + sequences editors */ +#edit-output-modal .modal-content, +#edit-sequence-modal .modal-content { + max-height: 90vh; + overflow-y: auto; +} + +.engine-form select { + width: 100%; + padding: 0.5rem; + background-color: #3a3a3a; + color: white; + border: 1px solid #4a4a4a; + border-radius: 4px; + font-size: 1rem; +} + +.engine-form label.engine-check { + display: flex; + align-items: center; + gap: 0.5rem; + font-weight: normal; +} + +.engine-form label.engine-check input { + width: auto; +} + +.engine-field[hidden] { + display: none; +} + +.engine-subheading { + margin: 1.25rem 0 0.5rem; + font-size: 1rem; +} + +.engine-steps { + display: flex; + flex-direction: column; + gap: 0.4rem; + margin-bottom: 0.5rem; +} + +.engine-step-row { + display: flex; + align-items: center; + gap: 0.35rem; +} + +.engine-step-row select.engine-step-preset { + flex: 1; + min-width: 0; +} + +.engine-step-row input.engine-step-duration { + width: 5rem; + flex: none; +} + +.engine-error { + margin-top: 0.75rem; + color: #ff6b6b; +} diff --git a/src/templates/index.html b/src/templates/index.html index 9c82cda..9390ab1 100644 --- a/src/templates/index.html +++ b/src/templates/index.html @@ -21,6 +21,8 @@ + + @@ -40,6 +42,8 @@ + + @@ -162,6 +166,124 @@ + + + + + + + + + +