Files

649 lines
20 KiB
Python
Executable File
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/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()