diff --git a/pad_color/__init__.py b/pad_color/__init__.py new file mode 100644 index 0000000..cef42a9 --- /dev/null +++ b/pad_color/__init__.py @@ -0,0 +1 @@ +"""Set SMC-PAD colours and preview them on the open mic fixtures.""" diff --git a/pad_color/__main__.py b/pad_color/__main__.py new file mode 100644 index 0000000..e723348 --- /dev/null +++ b/pad_color/__main__.py @@ -0,0 +1,61 @@ +"""Reload the pad colour page when its Python changes. + + python3 -m pad_color +""" + +from __future__ import annotations + +import os +import signal +import subprocess +import sys +import time +from pathlib import Path + +PKG = Path(__file__).resolve().parent +ROOT = PKG.parent + + +def stamp(root: Path) -> dict[str, int]: + found: dict[str, int] = {} + for path in root.rglob("*.py"): + if "__pycache__" in path.parts or not path.is_file(): + continue + found[str(path)] = path.stat().st_mtime_ns + return found + + +def stop_child(proc: subprocess.Popen) -> None: + if proc.poll() is not None: + return + proc.send_signal(signal.SIGINT) + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + proc.wait() + + +def main() -> int: + os.chdir(ROOT) + cmd = [sys.executable, "-m", "pad_color.server", *sys.argv[1:]] + while True: + py = stamp(PKG) + proc = subprocess.Popen(cmd) + try: + while proc.poll() is None: + time.sleep(0.25) + if stamp(PKG) != py: + print("reload backend", flush=True) + stop_child(proc) + break + else: + return proc.returncode or 0 + except KeyboardInterrupt: + print("\nstopped", flush=True) + stop_child(proc) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/pad_color/engine.py b/pad_color/engine.py new file mode 100644 index 0000000..8691e37 --- /dev/null +++ b/pad_color/engine.py @@ -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) diff --git a/pad_color/server.py b/pad_color/server.py new file mode 100644 index 0000000..28472d6 --- /dev/null +++ b/pad_color/server.py @@ -0,0 +1,125 @@ +"""HTTP server for the pad colour page. Run via `python -m pad_color`.""" + +from __future__ import annotations + +import argparse +import json +import signal +import threading +import time +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from pathlib import Path + +from pad_color.engine import open_studio + +STATIC = Path(__file__).resolve().parent / "static" +BOOT = str(time.time_ns()) +HOST = "127.0.0.1" +PORT = 8767 + +MIME = { + ".html": "text/html; charset=utf-8", + ".css": "text/css; charset=utf-8", + ".js": "text/javascript; charset=utf-8", +} + + +def static_stamp(directory: Path) -> str: + latest = 0 + if directory.is_dir(): + for path in directory.rglob("*"): + if path.is_file(): + latest = max(latest, path.stat().st_mtime_ns) + return str(latest) + + +def make_handler(studio): + class Handler(BaseHTTPRequestHandler): + protocol_version = "HTTP/1.1" + + def log_message(self, fmt: str, *args) -> None: + return + + def _send(self, code: int, body: bytes, content_type: str) -> None: + self.send_response(code) + self.send_header("Content-Type", content_type) + self.send_header("Content-Length", str(len(body))) + self.send_header("Cache-Control", "no-store") + self.end_headers() + self.wfile.write(body) + + def _json(self, code: int, payload: dict) -> None: + self._send(code, json.dumps(payload).encode(), "application/json") + + def _read_json(self) -> dict: + length = int(self.headers.get("Content-Length", "0") or 0) + if length <= 0: + return {} + data = json.loads(self.rfile.read(length).decode() or "{}") + if not isinstance(data, dict): + raise ValueError("Expected a JSON object") + return data + + def do_GET(self) -> None: # noqa: N802 + path = self.path.split("?", 1)[0] + if path == "/api/state": + self._json(200, studio.state()) + return + if path == "/api/dev": + self._json(200, {"boot": BOOT, "static": static_stamp(STATIC)}) + return + if path == "/": + path = "/index.html" + file_path = (STATIC / path.lstrip("/")).resolve() + if not str(file_path).startswith(str(STATIC)) or not file_path.is_file(): + self._send(404, b"not found", "text/plain; charset=utf-8") + return + self._send(200, file_path.read_bytes(), MIME.get(file_path.suffix, "application/octet-stream")) + + def do_POST(self) -> None: # noqa: N802 + path = self.path.split("?", 1)[0] + try: + body = self._read_json() + if path == "/api/pad": + studio.press(int(body["pad"])) + elif path == "/api/part": + studio.set_part(int(body["part"]), int(body["level"])) + else: + self._json(404, {"error": "Unknown request"}) + return + except (KeyError, TypeError, ValueError) as exc: + self._json(400, {"error": str(exc) or "Bad request"}) + return + self._json(200, studio.state()) + + return Handler + + +def main() -> None: + parser = argparse.ArgumentParser(description="Pad colour page") + parser.add_argument("--host", default=HOST) + parser.add_argument("--port", type=int, default=PORT) + parser.add_argument("--ip", default=None, help="Art-Net destination") + parser.add_argument("--midi", default=None, help="ALSA port, for example 128:0") + args = parser.parse_args() + + studio = open_studio(args.ip, args.midi) + studio.start() + ThreadingHTTPServer.allow_reuse_address = True + httpd = ThreadingHTTPServer((args.host, args.port), make_handler(studio)) + + def stop(_signum, _frame) -> None: + threading.Thread(target=httpd.shutdown, daemon=True).start() + + signal.signal(signal.SIGINT, stop) + signal.signal(signal.SIGTERM, stop) + print(f"http://{args.host}:{args.port}", flush=True) + try: + httpd.serve_forever() + finally: + httpd.server_close() + studio.close() + + +if __name__ == "__main__": + main() diff --git a/pad_color/static/app.css b/pad_color/static/app.css new file mode 100644 index 0000000..ad31066 --- /dev/null +++ b/pad_color/static/app.css @@ -0,0 +1,34 @@ +:root { color-scheme: dark; } +* { box-sizing: border-box; } +body { + margin: 0; + font: 16px/1.4 system-ui, sans-serif; + background: #12141a; + color: #eee; +} +main { max-width: 36rem; margin: 0 auto; padding: 1.25rem 1.25rem 3rem; } +h1 { font-size: 1.35rem; font-weight: 650; margin: 0 0 0.2rem; } +.meta, .hint, .status { color: #8e98a8; font-size: 0.85rem; } +.meta { margin: 0 0 1rem; word-break: break-all; } +.hint { margin: 0.75rem 0 1rem; } +.pads { + display: grid; + grid-template-columns: repeat(4, 1fr); + gap: 0.5rem; +} +.pads button { + aspect-ratio: 1; + border: 1px solid #3a4050; + border-radius: 12px; + font: inherit; + font-weight: 700; + cursor: pointer; +} +.pads button.selected { + outline: 3px solid #fff; + outline-offset: 2px; +} +.slider { display: block; margin: 0.75rem 0; } +.slider output { float: right; font-variant-numeric: tabular-nums; } +input[type="range"] { width: 100%; margin-top: 0.25rem; } +.status { min-height: 1.2em; } diff --git a/pad_color/static/app.js b/pad_color/static/app.js new file mode 100644 index 0000000..94f7a54 --- /dev/null +++ b/pad_color/static/app.js @@ -0,0 +1,110 @@ +const $ = (id) => document.getElementById(id); +const pads = $("pads"); +const sliders = [...document.querySelectorAll("input[type=range]")]; +const ROWS = [[13, 14, 15, 16], [9, 10, 11, 12], [5, 6, 7, 8], [1, 2, 3, 4]]; +let dragging = false; +let seenDev = null; +let devDown = false; + +for (const row of ROWS) { + for (const pad of row) { + const button = document.createElement("button"); + button.type = "button"; + button.dataset.pad = String(pad); + button.textContent = String(pad); + pads.appendChild(button); + } +} + +function hex(part) { + return part.toString(16).padStart(2, "0"); +} + +function ink(r, g, b) { + return r * 0.3 + g * 0.6 + b * 0.1 > 140 ? "#1a1206" : "#fff"; +} + +function paint(data) { + $("meta").textContent = `${data.artnet} · ${data.midi}`; + $("status").textContent = data.status; + const byPad = new Map(data.pads.map((item) => [item.pad, item])); + for (const button of pads.querySelectorAll("button")) { + const item = byPad.get(Number(button.dataset.pad)); + button.style.background = `#${hex(item.r)}${hex(item.g)}${hex(item.b)}`; + button.style.color = ink(item.r, item.g, item.b); + button.classList.toggle("selected", data.editing && item.pad === data.selected); + } + if (!dragging && data.selected) { + const item = byPad.get(data.selected); + sliders[0].value = item.r; + sliders[1].value = item.g; + sliders[2].value = item.b; + sliders[3].value = item.w; + } + for (const slider of sliders) { + slider.parentElement.querySelector("output").textContent = slider.value; + } +} + +async function post(url, body) { + const res = await fetch(url, { + method: "POST", + headers: {"Content-Type": "application/json"}, + body: JSON.stringify(body), + }); + const data = await res.json(); + if (!res.ok) throw new Error(data.error || "request failed"); + paint(data); + return data; +} + +pads.addEventListener("click", (ev) => { + const button = ev.target.closest("button"); + if (!button) return; + post("/api/pad", {pad: Number(button.dataset.pad)}).catch((err) => { + $("status").textContent = err.message; + }); +}); + +for (const slider of sliders) { + slider.addEventListener("pointerdown", () => { + dragging = true; + }); + slider.addEventListener("input", () => { + slider.parentElement.querySelector("output").textContent = slider.value; + post("/api/part", {part: Number(slider.dataset.part), level: Number(slider.value)}).catch((err) => { + $("status").textContent = err.message; + }); + }); +} +window.addEventListener("pointerup", () => { + dragging = false; +}); + +async function poll() { + try { + const data = await fetch("/api/state", {cache: "no-store"}).then((res) => res.json()); + paint(data); + } catch { + $("meta").textContent = "Reconnecting…"; + } + setTimeout(poll, 200); +} + +async function watchDev() { + try { + const dev = await fetch("/api/dev", {cache: "no-store"}).then((res) => res.json()); + if (devDown || (seenDev && (dev.boot !== seenDev.boot || dev.static !== seenDev.static))) { + location.reload(); + return; + } + seenDev = dev; + devDown = false; + } catch { + devDown = seenDev !== null; + } + setTimeout(watchDev, 400); +} + +poll(); +watchDev(); diff --git a/pad_color/static/index.html b/pad_color/static/index.html new file mode 100644 index 0000000..1cab4a7 --- /dev/null +++ b/pad_color/static/index.html @@ -0,0 +1,31 @@ + + + + + +Pad colours + + + +
+

Pad colours

+

Connecting…

+
+

Pad 1 is bottom-left. Hit a pad, turn knobs 1–4 for red, green, blue, and white. The open mic fixtures follow. Hit the same pad again to save. The pad light keeps red, green, and blue until the pad is switched off.

+ + + + +

+
+ + + diff --git a/tests/test_pad_color.py b/tests/test_pad_color.py new file mode 100644 index 0000000..4a0f3e4 --- /dev/null +++ b/tests/test_pad_color.py @@ -0,0 +1,105 @@ +"""Pad colour desk: select, knobs, save, and the open-mic DMX frame.""" + +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT)) + +from pad_color.engine import ( # noqa: E402 + CANS, + FLOOR, + MOVERS, + Desk, + Studio, + midi_level, + pad_from_note, + paint_openmic, +) + + +class Preview: + def __init__(self) -> None: + self.shown: list[tuple[int, int, int, int]] = [] + self.held = 0 + self.dest = "127.0.0.1" + + def show(self, color: tuple[int, int, int, int]) -> None: + self.shown.append(color) + + def hold(self) -> None: + self.held += 1 + + +def test_press_selects_then_saves() -> None: + desk = Desk() + assert desk.press(4, 1.0) == "edit" + assert desk.editing and desk.selected == 4 + assert desk.press(4, 1.2) == "ignore" + assert desk.editing + assert desk.press(4, 1.5) == "save" + assert not desk.editing + assert desk.press(1, 2.0) == "edit" + desk.set_part(0, 12) + desk.set_part(3, 40) + assert desk.colors[0] == (12, 0, 0xF0, 40) + assert desk.press(9, 3.0) == "edit" + assert desk.colors[0] == (12, 0, 0xF0, 40) + + +def test_knobs_only_while_choosing() -> None: + desk = Desk() + desk.set_part(1, 200) + assert desk.colors[0][1] == 0 + desk.press(2, 1.0) + desk.set_part(1, 200) + assert desk.colors[1][1] == 200 + + +def test_midi_maps_pads_and_knobs() -> None: + assert pad_from_note(36) == 1 + assert pad_from_note(51) == 16 + assert pad_from_note(52) is None + assert midi_level(0) == 0 + assert midi_level(127) == 255 + assert midi_level(64) == 128 + preview = Preview() + studio = Studio(Desk(), preview, None, "test") + studio.desk._last = 0 + studio.handle_midi("note", 38, 100) + assert studio.desk.selected == 3 + assert preview.shown + studio.handle_midi("cc", 30, 127) + assert studio.desk.colors[2][0] == 255 + assert preview.shown[-1][0] == 255 + studio.desk._last = 0 + studio.handle_midi("note", 38, 80) + assert not studio.desk.editing + assert preview.held == 1 + assert "saved" in studio.desk.status.lower() or "not reached" in studio.desk.status.lower() + + +def test_openmic_frame() -> None: + frames = {0: bytearray(512), 2: bytearray(512)} + paint_openmic(frames, (10, 20, 30, 40)) + for addr in CANS: + assert frames[0][addr] == 255 + assert frames[0][addr + 1] == 0 + assert frames[0][addr + 2 : addr + 6] == bytes((10, 20, 30, 40)) + assert frames[0][addr + 6] == 0 + for addr in FLOOR: + assert frames[2][addr + 2 : addr + 6] == bytes((10, 20, 30, 40)) + for addr, (pan, tilt) in MOVERS.items(): + assert frames[0][addr] == pan + assert frames[0][addr + 2] == tilt + assert frames[0][addr + 8] == 255 + assert frames[0][addr + 10 : addr + 14] == bytes((10, 20, 30, 40)) + assert frames[0][addr + 34 : addr + 38] == bytes((10, 20, 30, 40)) + + +if __name__ == "__main__": + test_press_selects_then_saves() + test_knobs_only_while_choosing() + test_midi_maps_pads_and_knobs() + test_openmic_frame() + print("ok")