339 lines
11 KiB
Python
339 lines
11 KiB
Python
"""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)
|