#!/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()