Edit mover patterns from the SMC-PAD and save the corner aims.
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
1b181640dd
commit
b1181e6f28
8 files changed
+859
No files matched your search
@@ -0,0 +1 @@
|
||||
"""Web editor for mover patterns, driven by the SMC-PAD and the page."""
|
||||
@@ -0,0 +1,73 @@
|
||||
"""Dev runner: restart the server when Python changes.
|
||||
|
||||
The page reloads itself when static files change, and again after the
|
||||
server comes back from a Python restart.
|
||||
|
||||
pipenv run pattern
|
||||
"""
|
||||
|
||||
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, suffix: str) -> dict[str, int]:
|
||||
found: dict[str, int] = {}
|
||||
for path in root.rglob(f"*{suffix}"):
|
||||
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", "pattern_pad.server", *sys.argv[1:]]
|
||||
print("pattern editor — reload on Python and page changes", flush=True)
|
||||
while True:
|
||||
py = stamp(PKG, ".py")
|
||||
parent = Path(__file__).stat().st_mtime_ns
|
||||
proc = subprocess.Popen(cmd)
|
||||
try:
|
||||
while proc.poll() is None:
|
||||
time.sleep(0.25)
|
||||
if Path(__file__).stat().st_mtime_ns != parent:
|
||||
stop_child(proc)
|
||||
os.execv(sys.executable, [sys.executable, "-m", "pattern_pad", *sys.argv[1:]])
|
||||
if stamp(PKG, ".py") != py:
|
||||
print("reload backend", flush=True)
|
||||
stop_child(proc)
|
||||
break
|
||||
else:
|
||||
code = proc.returncode or 0
|
||||
if code not in (0, -signal.SIGINT, 128 + signal.SIGINT):
|
||||
print(f"server exited ({code})", flush=True)
|
||||
return code
|
||||
return 0
|
||||
except KeyboardInterrupt:
|
||||
print("\nstopped", flush=True)
|
||||
stop_child(proc)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,386 @@
|
||||
"""Corner aims, SMC-PAD input, and Art-Net output for the pattern editor."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import math
|
||||
import re
|
||||
import signal
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
from dataclasses import dataclass
|
||||
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
|
||||
M1_ADDR,
|
||||
M2_ADDR,
|
||||
ArtNetSender,
|
||||
Mover,
|
||||
clamp,
|
||||
discover_artnet_node,
|
||||
)
|
||||
|
||||
DEFAULT_PATH = ROOT / "shows" / "pad_pattern.json"
|
||||
FOCUS_FULL = 255
|
||||
|
||||
# SMC-PAD preset 1. Pad 1 (bottom-left) is note 36, counting right then up.
|
||||
PAD_NOTES = {
|
||||
48: "front_left", # pad 13
|
||||
49: "front_right", # pad 14
|
||||
44: "back_left", # pad 9
|
||||
45: "back_right", # pad 10
|
||||
}
|
||||
CC_PAN = 16 # knob 7
|
||||
CC_TILT = 80 # knob 8
|
||||
CC_ROTATE = 17 # knob 5
|
||||
|
||||
CORNERS = ("front_left", "front_right", "back_left", "back_right")
|
||||
MODES = ("hold", "box", "cross", "circle", "figure8")
|
||||
ROUTES = {
|
||||
"box": ("front_left", "front_right", "back_right", "back_left"),
|
||||
"cross": ("front_left", "back_right", "front_right", "back_left"),
|
||||
"circle": ("front_left", "front_right", "back_right", "back_left"),
|
||||
}
|
||||
|
||||
NOTE_ON_RE = re.compile(r"Note on\s+\d+,\s+note (\d+),\s+velocity (\d+)")
|
||||
CC_RE = re.compile(r"Control change\s+\d+,\s+controller (\d+),\s+value (\d+)")
|
||||
CLIENT_RE = re.compile(r"^client (\d+): '([^']*)'")
|
||||
PORT_RE = re.compile(r"^\s+(\d+) '([^']*)'")
|
||||
|
||||
|
||||
@dataclass
|
||||
class Aim:
|
||||
pan: int = 133
|
||||
tilt: int = 113
|
||||
rotate: int = 0
|
||||
|
||||
def clamped(self) -> Aim:
|
||||
return Aim(clamp(self.pan), clamp(self.tilt), clamp(self.rotate))
|
||||
|
||||
def as_dict(self) -> dict[str, int]:
|
||||
return {"pan": self.pan, "tilt": self.tilt, "rotate": self.rotate}
|
||||
|
||||
|
||||
def encoder_delta(value: int) -> int:
|
||||
"""Relative encoder step. 1..63 clockwise, 65..127 counter-clockwise."""
|
||||
if value <= 0 or value == 64 or value > 127:
|
||||
return 0
|
||||
if value < 64:
|
||||
return value
|
||||
return value - 128
|
||||
|
||||
|
||||
def lerp_aim(a: Aim, b: Aim, frac: float) -> Aim:
|
||||
def mix(x: int, y: int) -> int:
|
||||
return clamp(x + (y - x) * frac)
|
||||
|
||||
return Aim(mix(a.pan, b.pan), mix(a.tilt, b.tilt), mix(a.rotate, b.rotate))
|
||||
|
||||
|
||||
def ease(frac: float) -> float:
|
||||
return 0.5 - 0.5 * math.cos(math.pi * frac)
|
||||
|
||||
|
||||
class Pattern:
|
||||
def __init__(self, corners: dict[str, Aim]):
|
||||
self.corners = corners
|
||||
self.selected = "front_left"
|
||||
self.mode = "hold"
|
||||
self.loop_s = 6.0
|
||||
self.t0 = time.monotonic()
|
||||
self._lock = threading.Lock()
|
||||
|
||||
def select(self, name: str) -> None:
|
||||
if name not in self.corners:
|
||||
raise ValueError("Unknown corner")
|
||||
with self._lock:
|
||||
self.selected = name
|
||||
self.mode = "hold"
|
||||
|
||||
def nudge(self, channel: str, delta: int) -> None:
|
||||
if delta == 0:
|
||||
return
|
||||
with self._lock:
|
||||
aim = self.corners[self.selected]
|
||||
if channel == "pan":
|
||||
aim.pan = clamp(aim.pan + delta)
|
||||
elif channel == "tilt":
|
||||
aim.tilt = clamp(aim.tilt + delta)
|
||||
elif channel == "rotate":
|
||||
aim.rotate = clamp(aim.rotate + delta)
|
||||
|
||||
def set_aim(self, pan: int, tilt: int, rotate: int) -> None:
|
||||
with self._lock:
|
||||
aim = self.corners[self.selected]
|
||||
aim.pan = clamp(pan)
|
||||
aim.tilt = clamp(tilt)
|
||||
aim.rotate = clamp(rotate)
|
||||
|
||||
def play(self, mode: str) -> None:
|
||||
if mode not in MODES:
|
||||
raise ValueError("Unknown pattern")
|
||||
with self._lock:
|
||||
self.mode = mode
|
||||
self.t0 = time.monotonic()
|
||||
|
||||
def set_loop(self, seconds: float) -> None:
|
||||
with self._lock:
|
||||
self.loop_s = max(0.4, float(seconds))
|
||||
self.t0 = time.monotonic()
|
||||
|
||||
def sample(self, now: float) -> tuple[Aim, str]:
|
||||
with self._lock:
|
||||
if self.mode == "hold":
|
||||
aim = self.corners[self.selected]
|
||||
return Aim(aim.pan, aim.tilt, aim.rotate), self.selected.replace("_", " ")
|
||||
if self.mode == "figure8":
|
||||
return self._figure8(now), "figure of 8"
|
||||
aim = self._route(now)
|
||||
return aim, self._route_label
|
||||
|
||||
def _route(self, now: float) -> Aim:
|
||||
order = ROUTES[self.mode]
|
||||
u = ((now - self.t0) / self.loop_s) % 1.0
|
||||
x = u * len(order)
|
||||
i = int(x) % len(order)
|
||||
frac = x - int(x)
|
||||
if self.mode == "circle":
|
||||
frac = ease(frac)
|
||||
here = order[i].replace("_", " ")
|
||||
nxt = order[(i + 1) % len(order)].replace("_", " ")
|
||||
self._route_label = f"{here} → {nxt}"
|
||||
a = self.corners[order[i]]
|
||||
b = self.corners[order[(i + 1) % len(order)]]
|
||||
return lerp_aim(a, b, frac)
|
||||
|
||||
def _figure8(self, now: float) -> Aim:
|
||||
pans = [self.corners[name].pan for name in CORNERS]
|
||||
tilts = [self.corners[name].tilt for name in CORNERS]
|
||||
cx = (min(pans) + max(pans)) / 2.0
|
||||
cy = (min(tilts) + max(tilts)) / 2.0
|
||||
hw = (max(pans) - min(pans)) / 2.0
|
||||
hh = (max(tilts) - min(tilts)) / 2.0
|
||||
t = ((now - self.t0) / self.loop_s) % 1.0 * 2.0 * math.pi
|
||||
return Aim(
|
||||
clamp(cx + (-math.sin(2.0 * t)) * hw),
|
||||
clamp(cy + math.cos(t) * hh),
|
||||
self.corners[self.selected].rotate,
|
||||
)
|
||||
|
||||
def snapshot(self) -> dict:
|
||||
with self._lock:
|
||||
return {
|
||||
"corners": {name: self.corners[name].as_dict() for name in CORNERS},
|
||||
"loop_s": self.loop_s,
|
||||
}
|
||||
|
||||
def state(self, now: float) -> dict:
|
||||
live, label = self.sample(now)
|
||||
with self._lock:
|
||||
return {
|
||||
"selected": self.selected,
|
||||
"mode": self.mode,
|
||||
"loop_s": self.loop_s,
|
||||
"label": label,
|
||||
"live": live.as_dict(),
|
||||
"corners": {name: self.corners[name].as_dict() for name in CORNERS},
|
||||
}
|
||||
|
||||
|
||||
def default_aim() -> Aim:
|
||||
path = ROOT / "shows" / "mover_positions.json"
|
||||
try:
|
||||
down = json.loads(path.read_text())["positions"]["Down"]["m1"]
|
||||
return Aim(int(down["pan"]), int(down["tilt"]), 0)
|
||||
except (OSError, KeyError, TypeError, ValueError):
|
||||
return Aim()
|
||||
|
||||
|
||||
def load_pattern(path: Path) -> Pattern:
|
||||
seed = default_aim()
|
||||
corners = {name: Aim(seed.pan, seed.tilt, seed.rotate) for name in CORNERS}
|
||||
loop_s = 6.0
|
||||
if path.is_file():
|
||||
data = json.loads(path.read_text())
|
||||
loop_s = float(data.get("loop_s", loop_s))
|
||||
for name in CORNERS:
|
||||
raw = data.get("corners", {}).get(name, {})
|
||||
corners[name] = Aim(
|
||||
int(raw.get("pan", seed.pan)),
|
||||
int(raw.get("tilt", seed.tilt)),
|
||||
int(raw.get("rotate", 0)),
|
||||
).clamped()
|
||||
pattern = Pattern(corners)
|
||||
pattern.loop_s = max(0.4, loop_s)
|
||||
return pattern
|
||||
|
||||
|
||||
def save_pattern(path: Path, pattern: Pattern) -> None:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(json.dumps(pattern.snapshot(), indent=2) + "\n")
|
||||
|
||||
|
||||
def list_smc_ports() -> list[tuple[str, str]]:
|
||||
try:
|
||||
text = subprocess.check_output(["aconnect", "-l"], text=True, stderr=subprocess.DEVNULL)
|
||||
except (OSError, subprocess.CalledProcessError):
|
||||
return []
|
||||
found: list[tuple[str, str]] = []
|
||||
client_id = ""
|
||||
client_name = ""
|
||||
for line in text.splitlines():
|
||||
client = CLIENT_RE.match(line)
|
||||
if client:
|
||||
client_id = client.group(1)
|
||||
client_name = client.group(2)
|
||||
continue
|
||||
port = PORT_RE.match(line)
|
||||
if not port or not client_id:
|
||||
continue
|
||||
label = f"{client_name} {port.group(2)}".strip()
|
||||
if "smc-pad" not in label.lower() and "sinco" not in label.lower():
|
||||
continue
|
||||
if "private" in port.group(2).lower():
|
||||
continue
|
||||
found.append((f"{client_id}:{port.group(1)}", label))
|
||||
return found
|
||||
|
||||
|
||||
def parse_midi_line(line: str) -> tuple[str, int, int] | None:
|
||||
note = NOTE_ON_RE.search(line)
|
||||
if note and int(note.group(2)) > 0:
|
||||
return ("note", int(note.group(1)), int(note.group(2)))
|
||||
cc = CC_RE.search(line)
|
||||
if cc:
|
||||
return ("cc", int(cc.group(1)), int(cc.group(2)))
|
||||
return None
|
||||
|
||||
|
||||
class Studio:
|
||||
"""Holds the pattern, sends Art-Net, and listens to the SMC-PAD."""
|
||||
|
||||
def __init__(self, pattern: Pattern, sender: ArtNetSender, movers: list[Mover], path: Path, midi_port: str | None, midi_label: str):
|
||||
self.pattern = pattern
|
||||
self.sender = sender
|
||||
self.movers = movers
|
||||
self.path = path
|
||||
self.artnet = sender.destination()
|
||||
self.midi_port = midi_port
|
||||
self.midi_label = midi_label
|
||||
self._running = True
|
||||
self._midi: subprocess.Popen[str] | None = None
|
||||
self._threads: list[threading.Thread] = []
|
||||
self._seen_notes: set[int] = set()
|
||||
|
||||
def state(self) -> dict:
|
||||
data = self.pattern.state(time.monotonic())
|
||||
data["artnet"] = self.artnet
|
||||
data["midi"] = self.midi_label
|
||||
data["file"] = str(self.path)
|
||||
return data
|
||||
|
||||
def apply(self, aim: Aim) -> None:
|
||||
rgb = (255, 255, 255)
|
||||
for mover in self.movers:
|
||||
mover.apply(
|
||||
pan=aim.pan,
|
||||
tilt=aim.tilt,
|
||||
rgb=rgb,
|
||||
dimmer=255,
|
||||
focus=FOCUS_FULL,
|
||||
speed=0,
|
||||
zoom=0,
|
||||
rotate=aim.rotate,
|
||||
)
|
||||
|
||||
def output_loop(self) -> None:
|
||||
while self._running:
|
||||
aim, _label = self.pattern.sample(time.monotonic())
|
||||
self.apply(aim)
|
||||
time.sleep(0.025)
|
||||
|
||||
def handle_midi(self, kind: str, number: int, value: int) -> None:
|
||||
if kind == "note":
|
||||
name = PAD_NOTES.get(number)
|
||||
if name is None:
|
||||
if number not in self._seen_notes:
|
||||
self._seen_notes.add(number)
|
||||
print(f"pad note {number} is not a corner", flush=True)
|
||||
return
|
||||
self.pattern.select(name)
|
||||
return
|
||||
channel = {CC_PAN: "pan", CC_TILT: "tilt", CC_ROTATE: "rotate"}.get(number)
|
||||
if channel is None:
|
||||
return
|
||||
self.pattern.nudge(channel, encoder_delta(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)
|
||||
if self._running and self._midi.poll() not in (None, 0):
|
||||
self.midi_label = "SMC-PAD disconnected"
|
||||
print("MIDI input stopped. Is the SMC-PAD still connected?", flush=True)
|
||||
|
||||
def start(self) -> None:
|
||||
out = threading.Thread(target=self.output_loop, daemon=True)
|
||||
self._threads.append(out)
|
||||
out.start()
|
||||
if self.midi_port:
|
||||
midi = threading.Thread(target=self.midi_loop, args=(self.midi_port,), daemon=True)
|
||||
self._threads.append(midi)
|
||||
midi.start()
|
||||
|
||||
def save(self) -> None:
|
||||
save_pattern(self.path, self.pattern)
|
||||
|
||||
def close(self) -> None:
|
||||
self._running = False
|
||||
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()
|
||||
for thread in self._threads:
|
||||
thread.join(timeout=1.0)
|
||||
self.save()
|
||||
self.sender.close()
|
||||
|
||||
|
||||
def open_studio(path: Path, ip: str | None, universe: int, address: int, address2: int, 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"
|
||||
pattern = load_pattern(path)
|
||||
node = ip or discover_artnet_node()
|
||||
sender = ArtNetSender(node, universe=universe)
|
||||
movers = [Mover(sender, address, "M1"), Mover(sender, address2, "M2")]
|
||||
studio = Studio(pattern, sender, movers, path, midi_port, midi_label)
|
||||
print(f"Art-Net → {node} universe {universe} M1 @{address} M2 @{address2}")
|
||||
print(f"MIDI {midi_label}")
|
||||
print("Stop QLC+ Art-Net output first. Focus stays at 255 so rotate can spin.")
|
||||
return studio
|
||||
@@ -0,0 +1,141 @@
|
||||
"""HTTP server for the pattern editor. Run via `python -m pattern_pad`."""
|
||||
|
||||
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 pattern_pad.engine import DEFAULT_PATH, M1_ADDR, M2_ADDR, MODES, ROOT, open_studio
|
||||
|
||||
STATIC = Path(__file__).resolve().parent / "static"
|
||||
BOOT = str(time.time_ns())
|
||||
HOST = "127.0.0.1"
|
||||
PORT = 8766
|
||||
|
||||
MIME = {
|
||||
".html": "text/html; charset=utf-8",
|
||||
".css": "text/css; charset=utf-8",
|
||||
".js": "text/javascript; charset=utf-8",
|
||||
".svg": "image/svg+xml",
|
||||
}
|
||||
|
||||
|
||||
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 {}
|
||||
raw = self.rfile.read(length)
|
||||
data = json.loads(raw.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/select":
|
||||
studio.pattern.select(str(body.get("name", "")))
|
||||
elif path == "/api/aim":
|
||||
studio.pattern.set_aim(int(body["pan"]), int(body["tilt"]), int(body["rotate"]))
|
||||
elif path == "/api/play":
|
||||
studio.pattern.play(str(body.get("mode", "")))
|
||||
elif path == "/api/loop":
|
||||
studio.pattern.set_loop(float(body["seconds"]))
|
||||
elif path == "/api/save":
|
||||
studio.save()
|
||||
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 parse_args():
|
||||
p = argparse.ArgumentParser(description="Pattern editor web server")
|
||||
p.add_argument("--host", default=HOST)
|
||||
p.add_argument("--port", type=int, default=PORT)
|
||||
p.add_argument("--ip", default=None, help="Art-Net destination (default: poll the network)")
|
||||
p.add_argument("--universe", type=int, default=0)
|
||||
p.add_argument("--address", type=int, default=M1_ADDR, help="M1 DMX start, 1-based")
|
||||
p.add_argument("--address2", type=int, default=M2_ADDR, help="M2 DMX start, 1-based")
|
||||
p.add_argument("--midi", default=None, help="ALSA port, for example 128:0")
|
||||
p.add_argument("--file", type=Path, default=DEFAULT_PATH, help="Corner file to load and save")
|
||||
return p.parse_args()
|
||||
|
||||
|
||||
def main() -> None:
|
||||
args = parse_args()
|
||||
path = args.file if args.file.is_absolute() else ROOT / args.file
|
||||
studio = open_studio(path, args.ip, args.universe, args.address, args.address2, 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()
|
||||
@@ -0,0 +1,53 @@
|
||||
: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.35rem 0 1rem; }
|
||||
.corners, .modes, .row { display: flex; gap: 0.5rem; }
|
||||
.corners { display: grid; grid-template-columns: 1fr 1fr; }
|
||||
button, input { font: inherit; color: inherit; }
|
||||
button {
|
||||
border: 1px solid #3a4050;
|
||||
background: #1c2030;
|
||||
border-radius: 8px;
|
||||
padding: 0.7rem 0.8rem;
|
||||
cursor: pointer;
|
||||
text-align: left;
|
||||
}
|
||||
.corners button small {
|
||||
display: block;
|
||||
color: #8e98a8;
|
||||
font-size: 0.75rem;
|
||||
margin-top: 0.2rem;
|
||||
}
|
||||
button.active {
|
||||
background: #f0a030;
|
||||
border-color: #f0a030;
|
||||
color: #1a1206;
|
||||
font-weight: 650;
|
||||
}
|
||||
button.active small { color: #5c4316; }
|
||||
.modes { flex-wrap: wrap; margin: 0.4rem 0 1rem; }
|
||||
.modes button { text-align: center; }
|
||||
.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; }
|
||||
.row { align-items: center; margin-top: 0.5rem; }
|
||||
.row label { display: flex; align-items: center; gap: 0.35rem; }
|
||||
input[type="number"] {
|
||||
width: 4.5rem;
|
||||
border: 1px solid #3a4050;
|
||||
background: #1c2030;
|
||||
border-radius: 8px;
|
||||
padding: 0.45rem 0.5rem;
|
||||
}
|
||||
#live { margin-left: auto; font-variant-numeric: tabular-nums; color: #d5dbe6; }
|
||||
.status { min-height: 1.2em; }
|
||||
@@ -0,0 +1,127 @@
|
||||
const $ = (id) => document.getElementById(id);
|
||||
|
||||
const pan = $("pan");
|
||||
const tilt = $("tilt");
|
||||
const rotate = $("rotate");
|
||||
const loop = $("loop");
|
||||
let dragging = false;
|
||||
let seenDev = null;
|
||||
let devDown = false;
|
||||
|
||||
function paint(data, writeSliders) {
|
||||
$("meta").textContent = `${data.artnet} · ${data.midi}`;
|
||||
for (const button of document.querySelectorAll("#corners button")) {
|
||||
const name = button.dataset.corner;
|
||||
const aim = data.corners[name];
|
||||
button.classList.toggle("active", name === data.selected);
|
||||
button.querySelector("small").textContent = `pan ${aim.pan} tilt ${aim.tilt} rot ${aim.rotate}`;
|
||||
}
|
||||
for (const button of document.querySelectorAll("#modes button")) {
|
||||
button.classList.toggle("active", button.dataset.mode === data.mode);
|
||||
}
|
||||
if (writeSliders) {
|
||||
const aim = data.corners[data.selected];
|
||||
pan.value = aim.pan;
|
||||
tilt.value = aim.tilt;
|
||||
rotate.value = aim.rotate;
|
||||
}
|
||||
$("pan-out").textContent = pan.value;
|
||||
$("tilt-out").textContent = tilt.value;
|
||||
$("rot-out").textContent = rotate.value;
|
||||
if (document.activeElement !== loop) loop.value = data.loop_s;
|
||||
const live = data.live;
|
||||
$("live").textContent = `${data.label} ${live.pan} / ${live.tilt} / ${live.rotate}`;
|
||||
}
|
||||
|
||||
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, !dragging);
|
||||
return data;
|
||||
}
|
||||
|
||||
function sendAim() {
|
||||
$("pan-out").textContent = pan.value;
|
||||
$("tilt-out").textContent = tilt.value;
|
||||
$("rot-out").textContent = rotate.value;
|
||||
post("/api/aim", {
|
||||
pan: Number(pan.value),
|
||||
tilt: Number(tilt.value),
|
||||
rotate: Number(rotate.value),
|
||||
}).catch((err) => {
|
||||
$("status").textContent = err.message;
|
||||
});
|
||||
}
|
||||
|
||||
for (const input of [pan, tilt, rotate]) {
|
||||
input.addEventListener("pointerdown", () => {
|
||||
dragging = true;
|
||||
});
|
||||
input.addEventListener("input", sendAim);
|
||||
}
|
||||
window.addEventListener("pointerup", () => {
|
||||
dragging = false;
|
||||
});
|
||||
|
||||
$("corners").addEventListener("click", (ev) => {
|
||||
const button = ev.target.closest("button");
|
||||
if (!button) return;
|
||||
post("/api/select", {name: button.dataset.corner}).catch((err) => {
|
||||
$("status").textContent = err.message;
|
||||
});
|
||||
});
|
||||
|
||||
$("modes").addEventListener("click", (ev) => {
|
||||
const button = ev.target.closest("button");
|
||||
if (!button) return;
|
||||
post("/api/play", {mode: button.dataset.mode}).catch((err) => {
|
||||
$("status").textContent = err.message;
|
||||
});
|
||||
});
|
||||
|
||||
loop.addEventListener("change", () => {
|
||||
post("/api/loop", {seconds: Number(loop.value)}).catch((err) => {
|
||||
$("status").textContent = err.message;
|
||||
});
|
||||
});
|
||||
|
||||
$("save").addEventListener("click", () => {
|
||||
post("/api/save").then(() => {
|
||||
$("status").textContent = "Saved";
|
||||
}).catch((err) => {
|
||||
$("status").textContent = err.message;
|
||||
});
|
||||
});
|
||||
|
||||
async function poll() {
|
||||
try {
|
||||
const data = await fetch("/api/state", {cache: "no-store"}).then((res) => res.json());
|
||||
paint(data, !dragging);
|
||||
} 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();
|
||||
@@ -0,0 +1,53 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>Patterns</title>
|
||||
<link rel="stylesheet" href="/app.css">
|
||||
</head>
|
||||
<body>
|
||||
<main>
|
||||
<h1>Patterns</h1>
|
||||
<p class="meta" id="meta">Connecting…</p>
|
||||
|
||||
<div class="corners" id="corners">
|
||||
<button type="button" data-corner="front_left">Front left<small></small></button>
|
||||
<button type="button" data-corner="front_right">Front right<small></small></button>
|
||||
<button type="button" data-corner="back_left">Back left<small></small></button>
|
||||
<button type="button" data-corner="back_right">Back right<small></small></button>
|
||||
</div>
|
||||
<p class="hint">Pad 13 front left, 14 front right, 9 back left, 10 back right.</p>
|
||||
|
||||
<label class="slider">Pan <output id="pan-out"></output>
|
||||
<input id="pan" type="range" min="0" max="255" value="0">
|
||||
</label>
|
||||
<label class="slider">Tilt <output id="tilt-out"></output>
|
||||
<input id="tilt" type="range" min="0" max="255" value="0">
|
||||
</label>
|
||||
<label class="slider">Rotate <output id="rot-out"></output>
|
||||
<input id="rotate" type="range" min="0" max="255" value="0">
|
||||
</label>
|
||||
<p class="hint">Knob 7 pan, knob 8 tilt, knob 5 rotate. Focus stays at 255 so the lens can spin.</p>
|
||||
|
||||
<div class="modes" id="modes">
|
||||
<button type="button" data-mode="hold">Hold</button>
|
||||
<button type="button" data-mode="box">Box</button>
|
||||
<button type="button" data-mode="cross">Cross</button>
|
||||
<button type="button" data-mode="circle">Circle</button>
|
||||
<button type="button" data-mode="figure8">Figure 8</button>
|
||||
</div>
|
||||
|
||||
<div class="row">
|
||||
<label>Loop
|
||||
<input id="loop" type="number" min="0.4" max="60" step="0.1" value="6">
|
||||
s
|
||||
</label>
|
||||
<button type="button" id="save">Save</button>
|
||||
<span id="live"></span>
|
||||
</div>
|
||||
<p class="status" id="status"></p>
|
||||
</main>
|
||||
<script src="/app.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,25 @@
|
||||
{
|
||||
"corners": {
|
||||
"front_left": {
|
||||
"pan": 133,
|
||||
"tilt": 149,
|
||||
"rotate": 0
|
||||
},
|
||||
"front_right": {
|
||||
"pan": 133,
|
||||
"tilt": 113,
|
||||
"rotate": 0
|
||||
},
|
||||
"back_left": {
|
||||
"pan": 133,
|
||||
"tilt": 113,
|
||||
"rotate": 0
|
||||
},
|
||||
"back_right": {
|
||||
"pan": 133,
|
||||
"tilt": 185,
|
||||
"rotate": 0
|
||||
}
|
||||
},
|
||||
"loop_s": 6.0
|
||||
}
|
||||
Reference in new issue
Block a user