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

+1
View File
@@ -0,0 +1 @@
"""Set SMC-PAD colours and preview them on the open mic fixtures."""
+61
View File
@@ -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())
+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)
+125
View File
@@ -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()
+34
View File
@@ -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; }
+110
View File
@@ -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();
+31
View File
@@ -0,0 +1,31 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Pad colours</title>
<link rel="stylesheet" href="/app.css">
</head>
<body>
<main>
<h1>Pad colours</h1>
<p class="meta" id="meta">Connecting…</p>
<div class="pads" id="pads"></div>
<p class="hint">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.</p>
<label class="slider">Red <output id="r-out"></output>
<input id="r" data-part="0" type="range" min="0" max="255" value="0">
</label>
<label class="slider">Green <output id="g-out"></output>
<input id="g" data-part="1" type="range" min="0" max="255" value="0">
</label>
<label class="slider">Blue <output id="b-out"></output>
<input id="b" data-part="2" type="range" min="0" max="255" value="0">
</label>
<label class="slider">White <output id="w-out"></output>
<input id="w" data-part="3" type="range" min="0" max="255" value="0">
</label>
<p class="status" id="status"></p>
</main>
<script src="/app.js"></script>
</body>
</html>
+105
View File
@@ -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")