Files
qlcplus/pad_color/engine.py
T

339 lines
11 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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)