Adds the driver half of the v2 controller link as extra 0x4C message types: DATA with fragment reassembly, de-duplication and acks, a state-version digest with jittered resync requests, a bench echo, and a BEAT frame handled by BeatSync (accepts one of the two copies, free-runs on the last period when a beat is missed). Presets.beat() steps the selected pattern without a message. Optional settings: espnow_loss, bench, beat_pin, usb_log. The working tree also carries the files already running on the bench device, which were ahead of origin/p2p: board.py (per-chip LED pin and CPU speed), the reversed device_config flag in controller_messages.py, and the apply_cpu_freq call in main.py. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
323 lines
12 KiB
Python
323 lines
12 KiB
Python
from machine import Pin
|
||
from neopixel import NeoPixel
|
||
from preset import Preset
|
||
from utils import convert_and_reorder_colors
|
||
import json
|
||
import sys
|
||
import utime
|
||
try:
|
||
import uos as os
|
||
except ImportError:
|
||
import os
|
||
|
||
MAX_PRESETS = 32
|
||
|
||
# Tests set this so pattern import can feed the 10s watchdog.
|
||
load_wdt = None
|
||
|
||
|
||
class Presets:
|
||
def __init__(self, pin, num_leds):
|
||
self.n = NeoPixel(Pin(pin, Pin.OUT), num_leds)
|
||
self.num_leds = num_leds
|
||
self.step = 0
|
||
# Global brightness (0–255), controlled via ESPNow {"b": <value>}
|
||
self.b = 255
|
||
self.reversed = False
|
||
|
||
self.generator = None
|
||
self.presets = {}
|
||
self.selected = None
|
||
|
||
self.reload_patterns()
|
||
|
||
def reload_patterns(self):
|
||
# Register built-in methods first, then discovered pattern classes
|
||
self.patterns = {
|
||
"off": self.off,
|
||
"on": self.on,
|
||
"blink": self.blink,
|
||
}
|
||
self.patterns.update(self._load_dynamic_patterns())
|
||
|
||
def _load_dynamic_patterns(self):
|
||
loaded = {}
|
||
try:
|
||
files = os.listdir("patterns")
|
||
except OSError:
|
||
return loaded
|
||
|
||
for filename in files:
|
||
if load_wdt is not None:
|
||
load_wdt.feed()
|
||
if not filename.endswith(".py") or filename in ("__init__.py", "main.py"):
|
||
continue
|
||
module_basename = filename[:-3]
|
||
module_name = "patterns." + module_basename
|
||
try:
|
||
if module_name in sys.modules:
|
||
del sys.modules[module_name]
|
||
module = __import__(module_name, None, None, ["*"])
|
||
except Exception as e:
|
||
print("Pattern import failed:", module_name, e)
|
||
continue
|
||
|
||
pattern_class = None
|
||
for attr_name in dir(module):
|
||
attr = getattr(module, attr_name)
|
||
# Pick the first class in the module that exposes run()
|
||
if isinstance(attr, type) and hasattr(attr, "run"):
|
||
pattern_class = attr
|
||
break
|
||
|
||
if pattern_class is None:
|
||
continue
|
||
|
||
try:
|
||
loaded[module_basename] = pattern_class(self).run
|
||
except Exception as e:
|
||
print("Pattern init failed:", module_name, e)
|
||
|
||
self._apply_pattern_aliases(loaded)
|
||
return loaded
|
||
|
||
def _apply_pattern_aliases(self, loaded):
|
||
"""Legacy pattern ids -> merged implementations (same generator)."""
|
||
aliases = (
|
||
("rainbow", "colour_cycle"),
|
||
("gradient_scroll", "colour_cycle"),
|
||
("meteor_rain", "meteor"),
|
||
("comet_dual", "meteor"),
|
||
("scanner", "meteor"),
|
||
("snowfall", "particles"),
|
||
("starfall", "particles"),
|
||
("sparkle_trail", "sparkle"),
|
||
("ice_sparkle", "sparkle"),
|
||
("fireflies", "sparkle"),
|
||
("marquee", "chase"),
|
||
("northern_wave", "aurora"),
|
||
)
|
||
for old, new in aliases:
|
||
if new in loaded and old not in loaded:
|
||
loaded[old] = loaded[new]
|
||
|
||
def save(self):
|
||
"""Save the presets to a file."""
|
||
with open("presets.json", "w") as f:
|
||
json.dump({name: preset.to_dict() for name, preset in self.presets.items()}, f)
|
||
return True
|
||
|
||
def load(self, settings=None):
|
||
"""Load presets from a file.
|
||
|
||
`settings` is used to convert hex strings in `c` to RGB tuples and apply
|
||
the device's colour order (same as ESPNow receive). If omitted, RGB order
|
||
is assumed.
|
||
"""
|
||
try:
|
||
with open("presets.json", "r") as f:
|
||
data = json.load(f)
|
||
except OSError:
|
||
# Create an empty presets file if missing
|
||
self.presets = {}
|
||
self.save()
|
||
return True
|
||
|
||
order = settings if settings is not None else "rgb"
|
||
self.presets = {}
|
||
for name, preset_data in data.items():
|
||
if len(self.presets) >= MAX_PRESETS:
|
||
print("Preset limit reached on load:", MAX_PRESETS)
|
||
break
|
||
color_key = "c" if "c" in preset_data else ("colors" if "colors" in preset_data else None)
|
||
if color_key is not None:
|
||
preset_data[color_key] = convert_and_reorder_colors(
|
||
preset_data[color_key], order
|
||
)
|
||
self.presets[name] = Preset(preset_data)
|
||
return True
|
||
|
||
def edit(self, name, data):
|
||
"""Create or update a preset with the given name."""
|
||
if name in self.presets:
|
||
# Update existing preset
|
||
was_auto = self.presets[name].a
|
||
self.presets[name].edit(data)
|
||
# Editing the live preset: auto still re-selects (one tick) so the strip
|
||
# restarts without a separate select message (controller often sends both).
|
||
# Manual must NOT call select() here — presets-only pushes (e.g. zone sequence
|
||
# arming the first step) would otherwise run select's first tick and consume a
|
||
# beat/step. Manual advances only on explicit select from the controller.
|
||
if self.selected == name:
|
||
preset = self.presets[name]
|
||
if preset.a:
|
||
self.step = 0
|
||
self.generator = None
|
||
self.fill((0, 0, 0))
|
||
self.select(name)
|
||
elif was_auto:
|
||
self.step = 0
|
||
self.generator = None
|
||
self.fill((0, 0, 0))
|
||
else:
|
||
if len(self.presets) >= MAX_PRESETS and name not in ("on", "off"):
|
||
print("Preset limit reached:", MAX_PRESETS)
|
||
return False
|
||
# Create new preset
|
||
self.presets[name] = Preset(data)
|
||
return True
|
||
|
||
def delete(self, name):
|
||
if name in self.presets:
|
||
del self.presets[name]
|
||
return True
|
||
return False
|
||
|
||
def delete_all(self):
|
||
self.presets = {}
|
||
self.generator = None
|
||
self.selected = None
|
||
return True
|
||
|
||
def tick(self):
|
||
if self.generator is None:
|
||
return
|
||
try:
|
||
next(self.generator)
|
||
except StopIteration:
|
||
self.generator = None
|
||
except Exception as e:
|
||
print(f"Error in tick: {e}")
|
||
self.generator = None
|
||
|
||
def beat(self):
|
||
"""Step the selected pattern once; same effect as re-selecting it, without the message."""
|
||
name = self.selected
|
||
if name in self.presets:
|
||
preset = self.presets[name]
|
||
if preset.p in self.patterns:
|
||
self.generator = self.patterns[preset.p](preset)
|
||
|
||
def select(self, preset_name, step=None):
|
||
# Auto-create simple built-in presets for common names on first use
|
||
if preset_name not in self.presets and preset_name in ("on", "off"):
|
||
if preset_name == "on":
|
||
self.presets[preset_name] = Preset({"p": "on"})
|
||
else:
|
||
self.presets[preset_name] = Preset({"p": "off"})
|
||
|
||
if preset_name in self.presets:
|
||
preset = self.presets[preset_name]
|
||
if preset.p in self.patterns:
|
||
if preset.p == "off":
|
||
self.generator = None
|
||
self.step = 0
|
||
self.fill((0, 0, 0))
|
||
self.selected = preset_name
|
||
return True
|
||
# If re-selecting the same preset before the main loop has tick()'d the
|
||
# previous frame, run one pending tick so step stays in sync.
|
||
if (
|
||
preset_name == self.selected
|
||
and self.generator is not None
|
||
):
|
||
self.tick()
|
||
# Set step value if explicitly provided
|
||
if step is not None:
|
||
self.step = step
|
||
elif self.selected != preset_name:
|
||
self.step = 0
|
||
self.generator = self.patterns[preset.p](preset)
|
||
self.selected = preset_name # Store the preset name, not the object
|
||
self.tick()
|
||
return True
|
||
print("select failed: pattern not found for preset", preset_name, "pattern=", preset.p)
|
||
return False
|
||
print("select failed: preset not found", preset_name)
|
||
# If preset doesn't exist or pattern not found, indicate failure
|
||
return False
|
||
|
||
def update_num_leds(self, pin, num_leds):
|
||
self.n = NeoPixel(Pin(pin, Pin.OUT), num_leds)
|
||
self.num_leds = num_leds
|
||
|
||
def is_reversed(self, preset):
|
||
from patterns.pattern_direction import is_reversed as _is_reversed
|
||
|
||
return _is_reversed(preset, self)
|
||
|
||
def led_i(self, preset, logical_index):
|
||
from patterns.pattern_direction import led_i as _led_i
|
||
|
||
return _led_i(self, preset, logical_index)
|
||
|
||
def set(self, preset, logical_index, color):
|
||
from patterns.pattern_direction import set_led
|
||
|
||
set_led(self, preset, logical_index, color)
|
||
|
||
def signed(self, preset, value):
|
||
from patterns.pattern_direction import signed as _signed
|
||
|
||
return _signed(preset, value, self)
|
||
|
||
def apply_brightness(self, color, brightness_override=None):
|
||
# Combine per-preset brightness (override) with global brightness self.b
|
||
local = brightness_override if brightness_override is not None else 255
|
||
# Scale preset brightness by global brightness
|
||
effective_brightness = int(local * self.b / 255)
|
||
return tuple(int(c * effective_brightness / 255) for c in color)
|
||
|
||
def fill(self, color=None):
|
||
fill_color = color if color is not None else (0, 0, 0)
|
||
for i in range(self.num_leds):
|
||
self.n[i] = fill_color
|
||
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)
|
||
while True:
|
||
self.fill(self.apply_brightness(color, preset.b))
|
||
yield
|
||
|
||
def blink(self, preset):
|
||
"""Built-in blink (used by controller identify); no patterns/ deploy required."""
|
||
colors = preset.c if preset.c else [(255, 255, 255)]
|
||
bg_color = self.apply_brightness(preset.background_or(colors), preset.b)
|
||
color_index = 0
|
||
delay_ms = max(1, int(preset.d))
|
||
period = delay_ms * 2
|
||
now = utime.ticks_ms()
|
||
# Phase-lock to wall time so group identify (broadcast select) stays in sync even
|
||
# when devices process the packet on different main-loop iterations.
|
||
phase = now % period if period else 0
|
||
state = phase < delay_ms
|
||
last_update = utime.ticks_add(now, -phase)
|
||
if state:
|
||
base = colors[color_index % len(colors)]
|
||
self.fill(self.apply_brightness(base, preset.b))
|
||
color_index += 1
|
||
else:
|
||
self.fill(bg_color)
|
||
while True:
|
||
now = utime.ticks_ms()
|
||
if utime.ticks_diff(now, last_update) >= delay_ms:
|
||
if state:
|
||
base = colors[color_index % len(colors)]
|
||
self.fill(self.apply_brightness(base, preset.b))
|
||
color_index += 1
|
||
else:
|
||
self.fill(bg_color)
|
||
state = not state
|
||
last_update = utime.ticks_add(last_update, delay_ms)
|
||
yield
|
||
|
||
|
||
def run_tick(presets):
|
||
"""Advance one animation frame (standalone tests / mpremote demos)."""
|
||
presets.tick()
|