Drive the two cabaret Small Eyes over Art-Net without QLC+.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
jimmyandCursor committed 2026-10-21 15:53:22 +13:00
1 parent 7ff1519abc
commit 6c5223eec5
1 file changed
+648
+648
View File
@@ -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()