"""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)