Preview open-mic colour on the rig and save it back to the pad.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
jimmyandCursor committed 2026-10-21 15:53:22 +13:00
1 parent c9df537567
commit 10c39015b7
8 files changed
+805

No files matched your search

+338
View File
@@ -0,0 +1,338 @@
"""Pad picks, knob colours, open-mic preview, and saving the pad light."""
from __future__ import annotations
import signal
import subprocess
import sys
import threading
import time
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
ARTNET_PORT,
DEFAULT_NODE,
build_artdmx,
discover_artnet_node,
)
from pattern_pad.engine import list_smc_ports, parse_midi_line # noqa: E402
PAD_COUNT = 16
NOTE_PAD1 = 36
# Knobs 1–4, factory preset: CC 30 red, 31 green, 32 blue, 33 white.
KNOB_PART = {30: 0, 31: 1, 32: 2, 33: 3}
PRESS_GAP = 0.35
# QLC addresses are 0-based. Universe 0 holds the cans and movers.
# Universe 2 holds the two floor cans.
CANS = (87, 95, 103, 111, 119, 127, 135, 143, 151, 159, 167, 175, 183, 191, 199)
FLOOR = (207, 215)
# Front right, front left, back left, back right. Pan and tilt stay put.
MOVERS = {
0: (80, 180),
44: (12, 190),
257: (12, 190),
300: (80, 180),
}
def midi_level(value: int) -> int:
"""Absolute knob 0–127 onto a DMX channel."""
return max(0, min(127, value)) * 255 // 127
def pad_from_note(note: int) -> int | None:
if NOTE_PAD1 <= note < NOTE_PAD1 + PAD_COUNT:
return note - NOTE_PAD1 + 1
return None
def paint_openmic(frames: dict[int, bytearray], color: tuple[int, int, int, int]) -> None:
"""Write one RGBW colour onto every open-mic can and mover pixel."""
red, green, blue, white = color
room = frames[0]
floor = frames[2]
for addr in CANS:
_can(room, addr, red, green, blue, white)
for addr in FLOOR:
_can(floor, addr, red, green, blue, white)
for addr, (pan, tilt) in MOVERS.items():
room[addr] = pan
room[addr + 2] = tilt
room[addr + 7] = 0
room[addr + 8] = 255
room[addr + 9] = 0
for pixel in range(7):
base = addr + 10 + pixel * 4
room[base] = red
room[base + 1] = green
room[base + 2] = blue
room[base + 3] = white
def _can(frame: bytearray, addr: int, red: int, green: int, blue: int, white: int) -> None:
frame[addr] = 255
frame[addr + 1] = 0
frame[addr + 2] = red
frame[addr + 3] = green
frame[addr + 4] = blue
frame[addr + 5] = white
frame[addr + 6] = 0
class Preview:
"""Art-Net for universe 0 and universe 2. Sends only while a colour is being chosen."""
def __init__(self, dest: str):
import socket
self.dest = dest
self.frames = {0: bytearray(512), 2: bytearray(512)}
self.active = False
self._running = True
self._lock = threading.Lock()
self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self._sequence = 1
self._thread = threading.Thread(target=self._loop, daemon=True)
self._thread.start()
def show(self, color: tuple[int, int, int, int]) -> None:
with self._lock:
for frame in self.frames.values():
frame[:] = b"\x00" * 512
paint_openmic(self.frames, color)
self.active = True
def hold(self) -> None:
with self._lock:
self.active = False
def _loop(self) -> None:
while self._running:
with self._lock:
active = self.active
packets = [
(universe, build_artdmx(bytes(frame), universe, self._sequence))
for universe, frame in self.frames.items()
]
if active:
self._sequence = 1 if self._sequence >= 255 else self._sequence + 1
if active:
for _universe, packet in packets:
try:
self._sock.sendto(packet, (self.dest, ARTNET_PORT))
except OSError:
pass
time.sleep(0.04)
def close(self) -> None:
self.hold()
self._running = False
self._thread.join(timeout=1.0)
self._sock.close()
class Desk:
"""Which pad is being coloured, and the four knob values."""
def __init__(self) -> None:
self.colors = [(0xF0, 0x00, 0xF0, 0) for _ in range(PAD_COUNT)]
self.selected: int | None = None
self.editing = False
self.status = "Hit a pad, then turn knobs 1–4."
self._last = 0.0
self._lock = threading.Lock()
def press(self, pad: int, now: float | None = None) -> str:
if not 1 <= pad <= PAD_COUNT:
raise ValueError("pad must be 1 to 16")
moment = time.monotonic() if now is None else now
with self._lock:
if moment - self._last < PRESS_GAP:
return "ignore"
self._last = moment
if self.editing and self.selected == pad:
self.editing = False
self.status = f"Pad {pad} saved."
return "save"
self.selected = pad
self.editing = True
red, green, blue, white = self.colors[pad - 1]
self.status = f"Pad {pad} {red} {green} {blue} {white}. Hit it again to save."
return "edit"
def set_part(self, part: int, level: int) -> None:
if part not in (0, 1, 2, 3):
raise ValueError("part must be 0 to 3")
level = max(0, min(255, level))
with self._lock:
if not self.editing or self.selected is None:
return
color = list(self.colors[self.selected - 1])
color[part] = level
self.colors[self.selected - 1] = (color[0], color[1], color[2], color[3])
red, green, blue, white = self.colors[self.selected - 1]
self.status = (
f"Pad {self.selected} {red} {green} {blue} {white}. Hit it again to save."
)
def color(self) -> tuple[int, int, int, int] | None:
with self._lock:
if not self.editing or self.selected is None:
return None
return self.colors[self.selected - 1]
def snapshot(self) -> dict:
with self._lock:
return {
"selected": self.selected,
"editing": self.editing,
"status": self.status,
"pads": [
{
"pad": index + 1,
"r": color[0],
"g": color[1],
"b": color[2],
"w": color[3],
}
for index, color in enumerate(self.colors)
],
}
class Studio:
def __init__(self, desk: Desk, preview: Preview, midi_port: str | None, midi_label: str):
self.desk = desk
self.preview = preview
self.artnet = preview.dest
self.midi_label = midi_label
self._midi_port = midi_port
self._running = True
self._midi: subprocess.Popen[str] | None = None
self._threads: list[threading.Thread] = []
self._link = None
self._slot = 0
self._bank = 3
def state(self) -> dict:
data = self.desk.snapshot()
data["artnet"] = self.artnet
data["midi"] = self.midi_label
return data
def press(self, pad: int) -> None:
action = self.desk.press(pad)
if action == "edit":
color = self.desk.color()
if color is not None:
self.preview.show(color)
elif action == "save":
self._save_pad(pad)
self.preview.hold()
def set_part(self, part: int, level: int) -> None:
self.desk.set_part(part, level)
color = self.desk.color()
if color is not None:
self.preview.show(color)
def _save_pad(self, pad: int) -> None:
color = self.desk.colors[pad - 1]
if self._link is None:
self.desk.status = f"Pad {pad} colour is on the fixtures. The pad light was not reached."
return
from smc_pad import PAD_RECORD_SIZE, PAD_RGB_OFFSET, bank_address
address = bank_address(self._slot, self._bank) + (pad - 1) * PAD_RECORD_SIZE + PAD_RGB_OFFSET
try:
self._link.write(address, bytes(color[:3]))
except Exception as exc:
self.desk.status = f"Pad {pad} did not save: {exc}"
return
self.desk.status = f"Pad {pad} saved."
def load_device(self) -> None:
from smc_pad import PadError, PadLink, rgb_at, showing
try:
link = PadLink()
link.open()
slot, bank, image = showing(link, None, None)
except (PadError, OSError, Exception) as exc:
self.desk.status = f"Pad colours stayed on the page. {exc}"
return
self._link = link
self._slot = slot
self._bank = bank
for pad in range(1, PAD_COUNT + 1):
red, green, blue = rgb_at(image, pad)
white = self.desk.colors[pad - 1][3]
self.desk.colors[pad - 1] = (red, green, blue, white)
self.desk.status = f"Preset {slot + 1}, bank {bank}. Hit a pad, then turn knobs 1–4."
def handle_midi(self, kind: str, number: int, value: int) -> None:
if kind == "note":
pad = pad_from_note(number)
if pad is None:
return
self.press(pad)
return
part = KNOB_PART.get(number)
if part is None:
return
self.set_part(part, midi_level(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)
def start(self) -> None:
self.load_device()
if self._midi_port:
thread = threading.Thread(target=self.midi_loop, args=(self._midi_port,), daemon=True)
self._threads.append(thread)
thread.start()
def close(self) -> None:
self._running = False
self.preview.close()
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()
if self._link is not None:
self._link.close()
def open_studio(ip: str | None, 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"
node = ip or discover_artnet_node(DEFAULT_NODE)
return Studio(Desk(), Preview(node), midi_port, midi_label)