"""Corner aims, SMC-PAD input, and Art-Net output for the pattern editor.""" from __future__ import annotations import json import math import re import signal import subprocess import sys import threading import time from dataclasses import dataclass from pathlib import Path ROOT = Path(__file__).resolve().parents[1] SCRIPTS = ROOT / "scripts" if str(SCRIPTS) not in sys.path: sys.path.insert(0, str(SCRIPTS)) from cabaret_movers import ( # noqa: E402 M1_ADDR, M2_ADDR, ArtNetSender, Mover, clamp, discover_artnet_node, ) DEFAULT_PATH = ROOT / "shows" / "pad_pattern.json" FOCUS_FULL = 255 # SMC-PAD preset 1. Pad 1 (bottom-left) is note 36, counting right then up. PAD_NOTES = { 48: "front_left", # pad 13 49: "front_right", # pad 14 44: "back_left", # pad 9 45: "back_right", # pad 10 } CC_PAN = 16 # knob 7 CC_TILT = 80 # knob 8 CC_ROTATE = 17 # knob 5 CORNERS = ("front_left", "front_right", "back_left", "back_right") MODES = ("hold", "box", "cross", "circle", "figure8") ROUTES = { "box": ("front_left", "front_right", "back_right", "back_left"), "cross": ("front_left", "back_right", "front_right", "back_left"), "circle": ("front_left", "front_right", "back_right", "back_left"), } NOTE_ON_RE = re.compile(r"Note on\s+\d+,\s+note (\d+),\s+velocity (\d+)") CC_RE = re.compile(r"Control change\s+\d+,\s+controller (\d+),\s+value (\d+)") CLIENT_RE = re.compile(r"^client (\d+): '([^']*)'") PORT_RE = re.compile(r"^\s+(\d+) '([^']*)'") @dataclass class Aim: pan: int = 133 tilt: int = 113 rotate: int = 0 def clamped(self) -> Aim: return Aim(clamp(self.pan), clamp(self.tilt), clamp(self.rotate)) def as_dict(self) -> dict[str, int]: return {"pan": self.pan, "tilt": self.tilt, "rotate": self.rotate} def encoder_delta(value: int) -> int: """Relative encoder step. 1..63 clockwise, 65..127 counter-clockwise.""" if value <= 0 or value == 64 or value > 127: return 0 if value < 64: return value return value - 128 def lerp_aim(a: Aim, b: Aim, frac: float) -> Aim: def mix(x: int, y: int) -> int: return clamp(x + (y - x) * frac) return Aim(mix(a.pan, b.pan), mix(a.tilt, b.tilt), mix(a.rotate, b.rotate)) def ease(frac: float) -> float: return 0.5 - 0.5 * math.cos(math.pi * frac) class Pattern: def __init__(self, corners: dict[str, Aim]): self.corners = corners self.selected = "front_left" self.mode = "hold" self.loop_s = 6.0 self.t0 = time.monotonic() self._lock = threading.Lock() def select(self, name: str) -> None: if name not in self.corners: raise ValueError("Unknown corner") with self._lock: self.selected = name self.mode = "hold" def nudge(self, channel: str, delta: int) -> None: if delta == 0: return with self._lock: aim = self.corners[self.selected] if channel == "pan": aim.pan = clamp(aim.pan + delta) elif channel == "tilt": aim.tilt = clamp(aim.tilt + delta) elif channel == "rotate": aim.rotate = clamp(aim.rotate + delta) def set_aim(self, pan: int, tilt: int, rotate: int) -> None: with self._lock: aim = self.corners[self.selected] aim.pan = clamp(pan) aim.tilt = clamp(tilt) aim.rotate = clamp(rotate) def play(self, mode: str) -> None: if mode not in MODES: raise ValueError("Unknown pattern") with self._lock: self.mode = mode self.t0 = time.monotonic() def set_loop(self, seconds: float) -> None: with self._lock: self.loop_s = max(0.4, float(seconds)) self.t0 = time.monotonic() def sample(self, now: float) -> tuple[Aim, str]: with self._lock: if self.mode == "hold": aim = self.corners[self.selected] return Aim(aim.pan, aim.tilt, aim.rotate), self.selected.replace("_", " ") if self.mode == "figure8": return self._figure8(now), "figure of 8" aim = self._route(now) return aim, self._route_label def _route(self, now: float) -> Aim: order = ROUTES[self.mode] u = ((now - self.t0) / self.loop_s) % 1.0 x = u * len(order) i = int(x) % len(order) frac = x - int(x) if self.mode == "circle": frac = ease(frac) here = order[i].replace("_", " ") nxt = order[(i + 1) % len(order)].replace("_", " ") self._route_label = f"{here} → {nxt}" a = self.corners[order[i]] b = self.corners[order[(i + 1) % len(order)]] return lerp_aim(a, b, frac) def _figure8(self, now: float) -> Aim: pans = [self.corners[name].pan for name in CORNERS] tilts = [self.corners[name].tilt for name in CORNERS] cx = (min(pans) + max(pans)) / 2.0 cy = (min(tilts) + max(tilts)) / 2.0 hw = (max(pans) - min(pans)) / 2.0 hh = (max(tilts) - min(tilts)) / 2.0 t = ((now - self.t0) / self.loop_s) % 1.0 * 2.0 * math.pi return Aim( clamp(cx + (-math.sin(2.0 * t)) * hw), clamp(cy + math.cos(t) * hh), self.corners[self.selected].rotate, ) def snapshot(self) -> dict: with self._lock: return { "corners": {name: self.corners[name].as_dict() for name in CORNERS}, "loop_s": self.loop_s, } def state(self, now: float) -> dict: live, label = self.sample(now) with self._lock: return { "selected": self.selected, "mode": self.mode, "loop_s": self.loop_s, "label": label, "live": live.as_dict(), "corners": {name: self.corners[name].as_dict() for name in CORNERS}, } def default_aim() -> Aim: path = ROOT / "shows" / "mover_positions.json" try: down = json.loads(path.read_text())["positions"]["Down"]["m1"] return Aim(int(down["pan"]), int(down["tilt"]), 0) except (OSError, KeyError, TypeError, ValueError): return Aim() def load_pattern(path: Path) -> Pattern: seed = default_aim() corners = {name: Aim(seed.pan, seed.tilt, seed.rotate) for name in CORNERS} loop_s = 6.0 if path.is_file(): data = json.loads(path.read_text()) loop_s = float(data.get("loop_s", loop_s)) for name in CORNERS: raw = data.get("corners", {}).get(name, {}) corners[name] = Aim( int(raw.get("pan", seed.pan)), int(raw.get("tilt", seed.tilt)), int(raw.get("rotate", 0)), ).clamped() pattern = Pattern(corners) pattern.loop_s = max(0.4, loop_s) return pattern def save_pattern(path: Path, pattern: Pattern) -> None: path.parent.mkdir(parents=True, exist_ok=True) path.write_text(json.dumps(pattern.snapshot(), indent=2) + "\n") def list_smc_ports() -> list[tuple[str, str]]: try: text = subprocess.check_output(["aconnect", "-l"], text=True, stderr=subprocess.DEVNULL) except (OSError, subprocess.CalledProcessError): return [] found: list[tuple[str, str]] = [] client_id = "" client_name = "" for line in text.splitlines(): client = CLIENT_RE.match(line) if client: client_id = client.group(1) client_name = client.group(2) continue port = PORT_RE.match(line) if not port or not client_id: continue label = f"{client_name} {port.group(2)}".strip() if "smc-pad" not in label.lower() and "sinco" not in label.lower(): continue if "private" in port.group(2).lower(): continue found.append((f"{client_id}:{port.group(1)}", label)) return found def parse_midi_line(line: str) -> tuple[str, int, int] | None: note = NOTE_ON_RE.search(line) if note and int(note.group(2)) > 0: return ("note", int(note.group(1)), int(note.group(2))) cc = CC_RE.search(line) if cc: return ("cc", int(cc.group(1)), int(cc.group(2))) return None class Studio: """Holds the pattern, sends Art-Net, and listens to the SMC-PAD.""" def __init__(self, pattern: Pattern, sender: ArtNetSender, movers: list[Mover], path: Path, midi_port: str | None, midi_label: str): self.pattern = pattern self.sender = sender self.movers = movers self.path = path self.artnet = sender.destination() self.midi_port = midi_port self.midi_label = midi_label self._running = True self._midi: subprocess.Popen[str] | None = None self._threads: list[threading.Thread] = [] self._seen_notes: set[int] = set() def state(self) -> dict: data = self.pattern.state(time.monotonic()) data["artnet"] = self.artnet data["midi"] = self.midi_label data["file"] = str(self.path) return data def apply(self, aim: Aim) -> None: rgb = (255, 255, 255) for mover in self.movers: mover.apply( pan=aim.pan, tilt=aim.tilt, rgb=rgb, dimmer=255, focus=FOCUS_FULL, speed=0, zoom=0, rotate=aim.rotate, ) def output_loop(self) -> None: while self._running: aim, _label = self.pattern.sample(time.monotonic()) self.apply(aim) time.sleep(0.025) def handle_midi(self, kind: str, number: int, value: int) -> None: if kind == "note": name = PAD_NOTES.get(number) if name is None: if number not in self._seen_notes: self._seen_notes.add(number) print(f"pad note {number} is not a corner", flush=True) return self.pattern.select(name) return channel = {CC_PAN: "pan", CC_TILT: "tilt", CC_ROTATE: "rotate"}.get(number) if channel is None: return self.pattern.nudge(channel, encoder_delta(value)) def midi_loop(self, port: str) -> None: self._midi = subprocess.Popen( ["aseqdump", "-p", port], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, bufsize=1, ) assert self._midi.stdout is not None for line in self._midi.stdout: if not self._running: break parsed = parse_midi_line(line) if parsed: self.handle_midi(*parsed) if self._running and self._midi.poll() not in (None, 0): self.midi_label = "SMC-PAD disconnected" print("MIDI input stopped. Is the SMC-PAD still connected?", flush=True) def start(self) -> None: out = threading.Thread(target=self.output_loop, daemon=True) self._threads.append(out) out.start() if self.midi_port: midi = threading.Thread(target=self.midi_loop, args=(self.midi_port,), daemon=True) self._threads.append(midi) midi.start() def save(self) -> None: save_pattern(self.path, self.pattern) def close(self) -> None: self._running = False midi = self._midi if midi is not None and midi.poll() is None: midi.send_signal(signal.SIGINT) try: midi.wait(timeout=1.0) except subprocess.TimeoutExpired: midi.kill() for thread in self._threads: thread.join(timeout=1.0) self.save() self.sender.close() def open_studio(path: Path, ip: str | None, universe: int, address: int, address2: int, midi: str | None) -> Studio: ports = list_smc_ports() if midi: midi_port, midi_label = midi, midi elif ports: midi_port, midi_label = ports[0] else: midi_port, midi_label = None, "SMC-PAD not found" pattern = load_pattern(path) node = ip or discover_artnet_node() sender = ArtNetSender(node, universe=universe) movers = [Mover(sender, address, "M1"), Mover(sender, address2, "M2")] studio = Studio(pattern, sender, movers, path, midi_port, midi_label) print(f"Art-Net → {node} universe {universe} M1 @{address} M2 @{address2}") print(f"MIDI {midi_label}") print("Stop QLC+ Art-Net output first. Focus stays at 255 so rotate can spin.") return studio