Drive the two cabaret Small Eyes over Art-Net without QLC+.
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
7ff1519abc
commit
6c5223eec5
1 file changed
+648
Executable
+648
@@ -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()
|
||||
Reference in new issue
Block a user