Add src/engine, modelled on technicalkiwi/portal's player and sequence runner: - Pixel generator: runs the unchanged led-driver patterns under CPython (utime shim + NeoPixel-like buffer) on a per-zone render thread and streams frames to pixel outputs, with keepalive for static frames. - Output drivers: DDP, Art-Net (ArtDMX/ArtSync), sACN/E1.31, USB-DMX (Enttec Pro / Open DMX), plus an ESP32 preset output that reuses the existing preset + select delivery path. Registry in db/output.json, CRUD and test pattern at /outputs. - Sequencer: timed preset chains per zone (portal step shape), deadline scheduling, loop/repeat, resume after restart; legacy sequence records are migrated. Zone play/stop, sequence and scene play/stop endpoints. - CLI (python -m engine.cli), Outputs and Sequences modals, preset tiles drive pixel outputs, API/README docs, engine test suite. ESP32 firmware is unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
120 lines
3.7 KiB
Python
120 lines
3.7 KiB
Python
"""The unchanged led-driver patterns run under the CPython shim."""
|
|
|
|
import threading
|
|
import time
|
|
|
|
import pytest
|
|
|
|
from engine import mpcompat
|
|
from engine.pattern_loader import PatternLibrary
|
|
from engine.renderer import Renderer, RenderThread
|
|
|
|
LIB = PatternLibrary()
|
|
NUM_LEDS = 24
|
|
|
|
|
|
def payload(pattern, **kw):
|
|
base = {"p": pattern, "c": ["#ff0000", "#00ff00", "#0000ff"], "d": 40, "b": 255, "a": True,
|
|
"n1": 5, "n2": 5, "n3": 5, "n4": 5, "n5": 0, "n6": 0}
|
|
base.update(kw)
|
|
return base
|
|
|
|
|
|
def test_library_loads_every_driver_pattern():
|
|
assert LIB.errors == {}
|
|
assert LIB.preset_class.__module__ == "led_driver_preset"
|
|
assert len(LIB.classes) >= 30
|
|
assert {"rainbow", "pulse", "chase", "on", "off"} <= set(LIB.ids())
|
|
|
|
|
|
@pytest.mark.parametrize("pattern", sorted(LIB.classes))
|
|
def test_pattern_renders(pattern):
|
|
r = Renderer(LIB, NUM_LEDS)
|
|
frames = r.render_virtual("1", payload(pattern), ticks=200, tick_ms=5)
|
|
assert r.error is None
|
|
assert frames, f"{pattern} wrote no frames"
|
|
assert all(len(f) == NUM_LEDS * 3 for f in frames)
|
|
|
|
|
|
@pytest.mark.parametrize("pattern", ["rainbow", "colour_cycle", "plasma", "aurora", "scanner", "transition"])
|
|
def test_animated_patterns_change(pattern):
|
|
frames = Renderer(LIB, NUM_LEDS).render_virtual("1", payload(pattern), ticks=400, tick_ms=5)
|
|
assert len(set(frames)) > 3
|
|
|
|
|
|
def test_on_and_off_builtins():
|
|
r = Renderer(LIB, 3)
|
|
frames = r.render_virtual("1", {"p": "on", "c": ["#ff8000"], "b": 255}, ticks=5)
|
|
assert frames == [bytes((255, 128, 0)) * 3] and r.generator is None
|
|
frames = r.render_virtual("2", {"p": "off"}, ticks=5)
|
|
assert frames == [bytes(9)]
|
|
|
|
|
|
def test_preset_brightness_applies_like_device():
|
|
frames = Renderer(LIB, 1).render_virtual("1", {"p": "on", "c": ["#ffffff"], "b": 128}, ticks=1)
|
|
assert frames[-1] == bytes((128, 128, 128))
|
|
|
|
|
|
def test_step_reset_rules_match_presets_select():
|
|
r = Renderer(LIB, 4)
|
|
r.render_virtual("1", payload("rainbow", n1=10), ticks=100, tick_ms=50)
|
|
assert r.driver.step != 0
|
|
kept = r.driver.step
|
|
r.set_preset("1", payload("rainbow", n1=10)) # same preset again = beat, keeps step
|
|
assert r.driver.step == kept
|
|
r.set_preset("2", payload("rainbow")) # different preset resets
|
|
assert r.driver.step == 0
|
|
|
|
|
|
def test_unknown_pattern_goes_dark():
|
|
r = Renderer(LIB, 2)
|
|
frames = r.render_virtual("1", {"p": "does_not_exist"}, ticks=3)
|
|
assert r.error and frames == [bytes(6)]
|
|
|
|
|
|
def test_virtual_clock_sleep_does_not_block():
|
|
started = time.monotonic()
|
|
frames = Renderer(LIB, 4).render_virtual("1", payload("heartbeat", d=500), ticks=50)
|
|
assert time.monotonic() - started < 2.0
|
|
assert len(frames) > 10
|
|
|
|
|
|
def test_render_thread_real_clock_and_hot_swap():
|
|
got = []
|
|
lock = threading.Lock()
|
|
|
|
def on_frame(f):
|
|
with lock:
|
|
got.append(f)
|
|
|
|
r = Renderer(LIB, 4, on_frame=on_frame)
|
|
t = RenderThread(r).start()
|
|
try:
|
|
t.apply("1", payload("rainbow", d=10, n1=8))
|
|
time.sleep(0.3)
|
|
with lock:
|
|
n_rainbow = len(got)
|
|
assert n_rainbow >= 5
|
|
t.apply("2", {"p": "on", "c": ["#0000ff"], "b": 255})
|
|
time.sleep(0.1)
|
|
with lock:
|
|
assert got[-1] == bytes((0, 0, 255)) * 4
|
|
assert r.pattern_id == "on"
|
|
finally:
|
|
t.stop()
|
|
assert not t._thread.is_alive()
|
|
|
|
|
|
def test_shim_installed_as_utime():
|
|
import sys
|
|
assert getattr(sys.modules["utime"], "__led_controller_shim__", False)
|
|
clock = mpcompat.VirtualClock(1000)
|
|
mpcompat.set_thread_clock(clock)
|
|
try:
|
|
import utime
|
|
assert utime.ticks_ms() == 1000
|
|
utime.sleep_ms(250)
|
|
assert utime.ticks_diff(utime.ticks_ms(), 1000) == 250
|
|
finally:
|
|
mpcompat.set_thread_clock(None)
|