From 6c5223eec553688426812ad558f95a5dce9a9a71 Mon Sep 17 00:00:00 2001 From: Jimmy Date: Wed, 21 Oct 2026 15:53:22 +1300 Subject: [PATCH] Drive the two cabaret Small Eyes over Art-Net without QLC+. Co-authored-by: Cursor --- scripts/cabaret_movers.py | 648 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 648 insertions(+) create mode 100755 scripts/cabaret_movers.py diff --git a/scripts/cabaret_movers.py b/scripts/cabaret_movers.py new file mode 100755 index 0000000..c6356cf --- /dev/null +++ b/scripts/cabaret_movers.py @@ -0,0 +1,648 @@ +#!/usr/bin/env python3 +"""Drive the two cabaret Small Eye 7 movers over Art-Net. + +Self-contained: no QLC+, no other repo imports. Stop QLC+ output first so +the two sources do not fight. Ctrl+C blackout. + +Patch (same as shows/cabaret.qxw, 43ch pixel mode): + M1 DMX 1–43 Small Eye 7 #1 + M2 DMX 45–87 Small Eye 7 #2 (hung 180° — same DMX pan = split) + +Examples: + python3 scripts/cabaret_movers.py + python3 scripts/cabaret_movers.py --position Wall --color Pink + python3 scripts/cabaret_movers.py --pattern figure8 --position Down + python3 scripts/cabaret_movers.py --interactive +""" + +from __future__ import annotations + +import argparse +import math +import socket +import sys +import threading +import time + +ARTNET_PORT = 6454 +HEADER = b"Art-Net\x00" +OP_DMX = 0x5000 +OP_POLL = 0x2000 +OP_POLL_REPLY = 0x2100 +PROT_VER = 14 +DEFAULT_NODE = "192.168.1.227" + +# 1-based 43ch map (QLC channel index = these − 1) +CH_PAN, CH_TILT = 1, 3 +CH_SPEED, CH_ROTATE, CH_ZOOM, CH_FOCUS = 5, 6, 7, 8 +CH_DIMMER, CH_STROBE = 9, 10 +CH_RED1 = 11 +FIXTURE_CHANNELS = 43 +PIXELS = 7 + +M1_ADDR, M2_ADDR = 1, 45 +FADE_S = 2.0 +LOOP_S = 3.0 # cabaret EFX duration +FOCUS_DEFAULT = 70 + +# name -> (M1 pan/tilt, M2 pan/tilt) +POSITIONS: dict[str, tuple[tuple[int, int], tuple[int, int]]] = { + "down": ((80, 161), (74, 145)), + "roof": ((179, 0), (179, 0)), + "wall": ((179, 36), (179, 36)), + "mid": ((164, 18), (164, 18)), + "cross": ((140, 26), (140, 26)), + "out": ((200, 22), (200, 22)), +} +POSITION_ORDER = ("down", "roof", "wall", "mid", "cross", "out") + +PALETTE: dict[str, tuple[int, int, int]] = { + "amber": (255, 90, 0), + "pink": (255, 50, 160), + "red": (255, 0, 0), + "green": (0, 255, 0), + "blue": (0, 0, 255), + "orange": (255, 127, 0), + "yellow": (255, 255, 0), + "purple": (127, 0, 255), +} +COLOR_ORDER = tuple(PALETTE) + +# name -> (algorithm, width, height, extras) +PATTERNS: dict[str, tuple[str, int, int, dict]] = { + "still": ("Still", 0, 0, {}), + "figure8": ("Eight", 56, 56, {}), + "zigzag": ("Lissajous", 80, 40, {"x_freq": 3, "cross": True}), + "swirl": ("Circle", 50, 50, {}), +} +PATTERN_ORDER = ("still", "figure8", "zigzag", "swirl") + + +def clamp(value: float, lo: int = 0, hi: int = 255) -> int: + return max(lo, min(hi, int(round(value)))) + + +def efx_fit(tilt: int, height: int) -> tuple[int, int]: + """Keep the Position aim. Shrink height to fit; only nudge off a hard stop.""" + height = min(int(height), 127) + if tilt <= 0: + h = min(height, 24) + return h, h + if tilt >= 255: + h = min(height, 24) + return 255 - h, h + h = min(height, tilt, 255 - tilt) + if h < 8: + h = min(height, 16) + return max(h, min(255 - h, tilt)), h + return tilt, h + + +def efx_xy(algorithm: str, t: float, x_freq: int = 1) -> tuple[float, float]: + """QLC+ EFX unit path, t in 0..2π → x,y in -1..1.""" + if algorithm == "Eight": + return -math.sin(2.0 * t), math.cos(t) + if algorithm == "Circle": + return math.cos(t), math.sin(t) + if algorithm == "Lissajous": + return math.sin(x_freq * t), math.cos(t) + return 0.0, 0.0 + + +def build_artdmx(channels: bytes, universe: int = 0, sequence: int = 1) -> bytes: + data = bytearray(channels) + n = len(data) + if n < 2: + data.extend(b"\x00" * (2 - n)) + n = 2 + if n & 1: + data.append(0) + n += 1 + if n > 512: + data = data[:512] + n = 512 + pkt = bytearray(18 + n) + pkt[0:8] = HEADER + pkt[8:10] = bytes((OP_DMX & 0xFF, OP_DMX >> 8)) + pkt[10] = 0 + pkt[11] = PROT_VER + pkt[12] = sequence & 0xFF + pkt[13] = 0 + pkt[14] = universe & 0xFF + pkt[15] = 0 + pkt[16] = (n >> 8) & 0xFF + pkt[17] = n & 0xFF + pkt[18 : 18 + n] = data + return bytes(pkt) + + +def _artnet_name(data: bytes) -> str: + short = data[26:44].split(b"\x00", 1)[0].decode("latin1", "replace").strip() + if short or len(data) < 108: + return short + return data[44:108].split(b"\x00", 1)[0].decode("latin1", "replace").strip() + + +def discover_artnet_nodes(fallback: str = DEFAULT_NODE) -> list[dict[str, str]]: + """Art-Net PollReply nodes as {ip, name}. Falls back to one saved address.""" + poll = bytearray(14) + poll[0:8] = HEADER + poll[8:10] = bytes((OP_POLL & 0xFF, OP_POLL >> 8)) + poll[11] = PROT_VER + sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + sock.settimeout(0.25) + found: list[dict[str, str]] = [] + try: + sock.bind(("", 0)) + for dest in ("255.255.255.255", "192.168.1.255", fallback): + try: + sock.sendto(poll, (dest, ARTNET_PORT)) + except OSError: + pass + seen: set[str] = set() + deadline = time.monotonic() + 1.2 + while time.monotonic() < deadline: + try: + data, addr = sock.recvfrom(1024) + except (TimeoutError, socket.timeout): + continue + if not data.startswith(HEADER) or len(data) < 44: + continue + opcode = data[8] | (data[9] << 8) + if opcode != OP_POLL_REPLY: + continue + ip = addr[0] + if ip.startswith("127.") or ip in seen: + continue + seen.add(ip) + found.append({"ip": ip, "name": _artnet_name(data)}) + except OSError: + pass + finally: + sock.close() + if not found: + return [{"ip": fallback, "name": "no reply"}] + return found + + +def discover_artnet_node(fallback: str = DEFAULT_NODE) -> str: + nodes = discover_artnet_nodes(fallback) + for node in nodes: + name = node["name"].lower() + if "gateway" in name or "dmx" in name: + return node["ip"] + return nodes[0]["ip"] + + +class ArtNetSender: + def __init__(self, dest: str, universe: int = 0, hz: float = 40.0): + self.dest = dest + self.universe = universe + self.period = 1.0 / hz + self.frame = bytearray(512) + self.sequence = 1 + self._lock = threading.Lock() + self._running = True + self._blackout_dest = "" + self._blackout_left = 0 + self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) + self._thread = threading.Thread(target=self._loop, daemon=True) + self._thread.start() + + def _loop(self): + while self._running: + with self._lock: + pkt = build_artdmx(self.frame, self.universe, self.sequence) + self.sequence = 1 if self.sequence >= 255 else self.sequence + 1 + dest = self.dest + black_dest = "" + black_pkt = b"" + if self._blackout_left and self._blackout_dest != dest: + black_dest = self._blackout_dest + black_pkt = build_artdmx(bytes(512), self.universe, self.sequence) + self.sequence = 1 if self.sequence >= 255 else self.sequence + 1 + self._blackout_left -= 1 + if black_dest: + try: + self.sock.sendto(black_pkt, (black_dest, ARTNET_PORT)) + except OSError as exc: + print(f"Art-Net blackout failed: {exc}", file=sys.stderr) + try: + self.sock.sendto(pkt, (dest, ARTNET_PORT)) + except OSError as exc: + print(f"Art-Net send failed: {exc}", file=sys.stderr) + time.sleep(self.period) + + def destination(self) -> str: + with self._lock: + return self.dest + + def set_dest(self, dest: str): + """Send the next frames to dest and black out the previous node.""" + with self._lock: + if dest == self.dest: + return + self._blackout_dest = self.dest + self._blackout_left = 4 + self.dest = dest + + def set_universe(self, universe: int): + with self._lock: + self.universe = int(universe) & 0x7FFF + + def set_slot(self, dmx_addr: int, value: int): + with self._lock: + self.frame[dmx_addr - 1] = clamp(value) + + def blackout(self): + with self._lock: + self.frame[:] = b"\x00" * 512 + + def close(self): + self.blackout() + time.sleep(self.period * 3) + self._running = False + self._thread.join(timeout=1.0) + self.sock.close() + + +class Mover: + def __init__(self, sender: ArtNetSender, address: int, name: str): + self.artnet = sender + self.address = address + self.name = name + + def set(self, channel: int, value: int): + self.artnet.set_slot(self.address + channel - 1, value) + + def apply( + self, + *, + pan: int, + tilt: int, + rgb: tuple[int, int, int], + dimmer: int, + focus: int, + speed: int, + zoom: int = 0, + rotate: int = 0, + ): + r, g, b = rgb + self.set(CH_PAN, pan) + self.set(CH_PAN + 1, 0) + self.set(CH_TILT, tilt) + self.set(CH_TILT + 1, 0) + self.set(CH_SPEED, speed) + self.set(CH_ZOOM, zoom) + self.set(CH_ROTATE, rotate) + self.set(CH_FOCUS, focus) + self.set(CH_DIMMER, dimmer) + self.set(CH_STROBE, 0) + for i in range(PIXELS): + base = CH_RED1 + i * 4 + self.set(base, r) + self.set(base + 1, g) + self.set(base + 2, b) + self.set(base + 3, 0) + + +class CabaretMovers: + def __init__( + self, + movers: list[Mover], + *, + position: str = "down", + color: str = "amber", + pattern: str = "still", + dimmer: int = 255, + focus: int = FOCUS_DEFAULT, + speed: int = 0, + loop_s: float = LOOP_S, + which: str = "both", + ): + self.movers = movers + self.position = position + self.color = color + self.pattern = pattern + self.dimmer = dimmer + self.focus = focus + self.speed = speed + self.loop_s = max(0.2, loop_s) + self.which = which + self._lock = threading.Lock() + self._t0 = time.monotonic() + self._fade_from = self._current_pts() + self._fade_t0 = time.monotonic() + + def _enabled(self) -> list[Mover]: + if self.which == "1": + return self.movers[:1] + if self.which == "2": + return self.movers[1:] + return self.movers + + def _current_pts(self) -> list[tuple[int, int]]: + m1, m2 = POSITIONS[self.position] + pts = [m1, m2] + return pts[: len(self.movers)] + + def set_look( + self, + *, + position: str | None = None, + color: str | None = None, + pattern: str | None = None, + dimmer: int | None = None, + focus: int | None = None, + speed: int | None = None, + loop_s: float | None = None, + which: str | None = None, + fade: bool = True, + ): + with self._lock: + from_pts = self.tick_points(time.monotonic(), fading=False) + if position is not None: + self.position = position + if color is not None: + self.color = color + if pattern is not None: + self.pattern = pattern + if dimmer is not None: + self.dimmer = clamp(dimmer) + if focus is not None: + self.focus = clamp(focus) + if speed is not None: + self.speed = clamp(speed) + if loop_s is not None: + self.loop_s = max(0.2, loop_s) + if which is not None: + self.which = which + if fade: + self._fade_from = from_pts + self._fade_t0 = time.monotonic() + print(self.status(), flush=True) + + def status(self) -> str: + rgb = PALETTE[self.color] + return ( + f"{self.position} {self.color} {rgb} {self.pattern} " + f"dim {self.dimmer} focus {self.focus} {self.which}" + ) + + def tick_points(self, now: float, *, fading: bool = True) -> list[tuple[int, int]]: + algo, width, height, extra = PATTERNS[self.pattern] + m1, m2 = POSITIONS[self.position] + homes = [m1, m2] + elapsed = now - self._t0 + t = (elapsed / self.loop_s) * 2.0 * math.pi + pts: list[tuple[int, int]] = [] + for i, (pan0, tilt0) in enumerate(homes[: len(self.movers)]): + if algo == "Still": + pan, tilt = pan0, tilt0 + else: + y, h = efx_fit(tilt0, height) + x_freq = int(extra.get("x_freq", 1)) + cross = bool(extra.get("cross")) + tt = t + if cross and i == 1: + tt = -t + math.pi + x, y_u = efx_xy(algo, tt, x_freq=x_freq) + pan = clamp(pan0 + x * (width / 2.0)) + tilt = clamp(y + y_u * (h / 2.0)) + pts.append((pan, tilt)) + if fading: + fade_u = (now - self._fade_t0) / FADE_S + if fade_u < 1.0: + out = [] + for (p0, t0), (p1, t1) in zip(self._fade_from, pts): + u = fade_u + out.append((clamp(p0 + (p1 - p0) * u), clamp(t0 + (t1 - t0) * u))) + return out + return pts + + def tick(self, now: float | None = None): + now = time.monotonic() if now is None else now + with self._lock: + pts = self.tick_points(now) + rgb = PALETTE[self.color] + enabled = set(id(m) for m in self._enabled()) + for mover, (pan, tilt) in zip(self.movers, pts): + if id(mover) not in enabled: + mover.apply( + pan=pan, + tilt=tilt, + rgb=(0, 0, 0), + dimmer=0, + focus=self.focus, + speed=self.speed, + ) + continue + mover.apply( + pan=pan, + tilt=tilt, + rgb=rgb, + dimmer=self.dimmer, + focus=self.focus, + speed=self.speed, + ) + + +class Animator: + def __init__(self, show: CabaretMovers, hz: float = 40.0): + self.show = show + self.period = 1.0 / hz + self._running = True + self._thread = threading.Thread(target=self._loop, daemon=True) + self._thread.start() + + def _loop(self): + while self._running: + self.show.tick() + time.sleep(self.period) + + def close(self): + self._running = False + self._thread.join(timeout=1.0) + + +def print_map(): + print("Cabaret movers (43ch, universe 0)") + print(f" M1 start {M1_ADDR:3d} M2 start {M2_ADDR:3d} (M2 hung 180°)") + print("Positions (DMX pan/tilt):") + for name in POSITION_ORDER: + m1, m2 = POSITIONS[name] + print(f" {name:6s} M1 {m1[0]:3d}/{m1[1]:3d} M2 {m2[0]:3d}/{m2[1]:3d}") + print("Colours:", ", ".join(COLOR_ORDER)) + print("Patterns:", ", ".join(PATTERN_ORDER)) + + +def run_demo(show: CabaretMovers, hold_s: float): + print(f"Demo: positions, then patterns. {hold_s:.1f}s each. Ctrl+C to stop.") + colours = list(COLOR_ORDER) + ci = 0 + while True: + show.set_look(pattern="still") + for pos in POSITION_ORDER: + show.set_look(position=pos, color=colours[ci % len(colours)]) + ci += 1 + time.sleep(hold_s) + for pat in PATTERN_ORDER[1:]: + for pos in POSITION_ORDER: + show.set_look( + position=pos, + pattern=pat, + color=colours[ci % len(colours)], + ) + ci += 1 + time.sleep(hold_s) + + +def run_hold(show: CabaretMovers): + print("Holding look. Ctrl+C to blackout.") + while True: + time.sleep(0.25) + + +def parse_token(token: str) -> str: + return token.strip().lower().replace(" ", "").replace("-", "").replace("_", "") + + +HELP = """commands: + down roof wall mid cross out + still figure8|f8 zigzag|zz swirl + amber pink red green blue orange yellow purple + dim N focus N speed N loop N m1|m2|both + demo status help quit +""" + + +def run_interactive(show: CabaretMovers): + print(HELP) + print(show.status()) + while True: + try: + line = input("> ").strip() + except EOFError: + break + if not line: + continue + parts = line.split() + cmd = parse_token(parts[0]) + if cmd in ("quit", "exit", "q"): + break + if cmd in ("help", "?"): + print(HELP) + continue + if cmd == "status": + print(show.status()) + continue + if cmd == "demo": + try: + run_demo(show, hold_s=4.0) + except KeyboardInterrupt: + print("\nback to prompt") + continue + if cmd in POSITIONS: + show.set_look(position=cmd) + continue + aliases = {"f8": "figure8", "eight": "figure8", "zz": "zigzag", "circle": "swirl"} + pat = aliases.get(cmd, cmd) + if pat in PATTERNS: + show.set_look(pattern=pat) + continue + if cmd in PALETTE: + show.set_look(color=cmd) + continue + if cmd in ("m1", "1"): + show.set_look(which="1", fade=False) + continue + if cmd in ("m2", "2"): + show.set_look(which="2", fade=False) + continue + if cmd == "both": + show.set_look(which="both", fade=False) + continue + if cmd in ("dim", "focus", "speed", "loop") and len(parts) >= 2: + try: + value = float(parts[1]) + except ValueError: + print("need a number") + continue + kw = {"dim": "dimmer", "focus": "focus", "speed": "speed", "loop": "loop_s"} + show.set_look(**{kw[cmd]: value}, fade=False) + continue + print(f"unknown: {line!r} (help)") + + +def parse_args(): + p = argparse.ArgumentParser( + description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter, + ) + p.add_argument("--ip", default=None, help=f"Art-Net destination (default: poll, else {DEFAULT_NODE})") + 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("--position", default="down", choices=POSITION_ORDER) + p.add_argument("--color", default="amber", choices=COLOR_ORDER) + p.add_argument("--pattern", default="still", choices=PATTERN_ORDER) + p.add_argument("--dimmer", type=int, default=255) + p.add_argument("--focus", type=int, default=FOCUS_DEFAULT) + p.add_argument("--speed", type=int, default=0, help="Pan/tilt speed: 0=fast, 255=slow") + p.add_argument("--loop", type=float, default=LOOP_S, help="Seconds per EFX loop") + p.add_argument("--which", choices=("both", "1", "2"), default="both") + p.add_argument("--hold", type=float, default=4.0, help="Seconds per demo step") + p.add_argument("--demo", action="store_true", help="Walk every position then every pattern") + p.add_argument("--interactive", action="store_true", help="Type looks at a prompt") + p.add_argument("--list", action="store_true", help="Print cabaret mover map and exit") + return p.parse_args() + + +def main(): + args = parse_args() + if args.list: + print_map() + return + + ip = args.ip or discover_artnet_node() + print_map() + print(f"Art-Net → {ip} universe {args.universe}") + print("Stop QLC+ Art-Net output first. Ctrl+C blackout.") + + sender = ArtNetSender(ip, universe=args.universe) + movers = [ + Mover(sender, args.address, "M1"), + Mover(sender, args.address2, "M2"), + ] + show = CabaretMovers( + movers, + position=args.position, + color=args.color, + pattern=args.pattern, + dimmer=args.dimmer, + focus=args.focus, + speed=args.speed, + loop_s=args.loop, + which=args.which, + ) + animator = Animator(show) + try: + print(show.status()) + if args.interactive or (not args.demo and sys.stdin.isatty() and args.pattern == "still"): + run_interactive(show) + elif args.demo: + run_demo(show, args.hold) + else: + run_hold(show) + except KeyboardInterrupt: + print("\nstopped") + finally: + animator.close() + sender.close() + + +if __name__ == "__main__": + main()