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": } 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()