649 lines
20 KiB
Python
Executable File
649 lines
20 KiB
Python
Executable File
#!/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()
|