Edit mover patterns from the SMC-PAD and save the corner aims.
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
1b181640dd
commit
b1181e6f28
8 files changed
+859
No files matched your search
@@ -0,0 +1,386 @@
|
||||
"""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
|
||||
Reference in new issue
Block a user