Drive the twisted cans and movers from the SMC-PAD over Art-Net.
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
dc05192a25
commit
9f40933227
1 file changed
+265
@@ -0,0 +1,265 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Twisted show MIDI control: Color1/Color2 slots for cans + movers.
|
||||
|
||||
Loads shows/midi_map.json, listens to the SMC-PAD, and drives the twisted
|
||||
patch over Art-Net. Stop QLC+ Art-Net output first so the two do not fight.
|
||||
|
||||
pipenv run python scripts/twisted_midi.py
|
||||
|
||||
Knob map:
|
||||
Color1 k5 R, k3 G, k1 B
|
||||
Color2 k6 R, k4 G, k2 B
|
||||
Bright k15 cans 1–8, k16 cans 9–12, k7 cans 13–15, k13 movers
|
||||
k8 chaser transition (QLC Speed Dial when using twisted.qxw)
|
||||
Movers k9 pan, k10 tilt, k11 focus, k12 rotate
|
||||
|
||||
Pads:
|
||||
5 mover LEDs all → Color1 (default)
|
||||
6 mover outer → Color1, center → Color2
|
||||
13 all cans → Color1 (default)
|
||||
14 cans 1–12 → C1; cans 13–15 chasers (QLC)
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
|
||||
import mido
|
||||
|
||||
from cabaret_movers import (
|
||||
DEFAULT_NODE,
|
||||
FOCUS_DEFAULT,
|
||||
ArtNetSender,
|
||||
clamp,
|
||||
discover_artnet_node,
|
||||
)
|
||||
from midi import KNOBS, MAP_PATH, PADS, encoder_delta, find_port, load_maps
|
||||
|
||||
# QLC Address is 0-based; ArtNetSender.set_slot is 1-based DMX.
|
||||
CAN_ADDRS = [88 + i * 8 for i in range(15)] # BCC145 #01–#15
|
||||
# Front L/R normal; Back L/R hung 90° and converge inward with the same pan,
|
||||
# so offset them opposite ways (±90° = ±64) to face forward with the fronts.
|
||||
MOVER_ADDRS = (1, 45, 258, 301) # FL, FR, BL, BR
|
||||
MOVER_PAN_OFFSET = (0, 0, 64, 192) # BL +90°, BR −90°
|
||||
|
||||
# Can 8ch offsets (0-based within fixture)
|
||||
CAN_DIM, CAN_R, CAN_G, CAN_B = 0, 2, 3, 4
|
||||
|
||||
# Mover 43ch 1-based (same as cabaret_movers)
|
||||
CH_PAN, CH_TILT = 1, 3
|
||||
CH_ROTATE, CH_FOCUS, CH_DIMMER = 6, 8, 9
|
||||
CH_RED1 = 11
|
||||
PIXELS = 7
|
||||
|
||||
# Can numbers are 1-based in the pad map
|
||||
SPLIT_C1 = frozenset(range(1, 13)) # cans 1–12
|
||||
# cans 13–15 = QLC chasers (not on C1/C2)
|
||||
|
||||
KNOB_STEP = 2 # relative encoder → DMX step
|
||||
|
||||
|
||||
def can_slot(can: int, mode: str) -> str | None:
|
||||
"""Return 'c1', 'c2', or None (off) for a 1-based can number."""
|
||||
if can in (13, 14, 15):
|
||||
return None
|
||||
if mode == "all_c1" or can in SPLIT_C1:
|
||||
return "c1"
|
||||
return None
|
||||
|
||||
|
||||
class TwistedState:
|
||||
def __init__(self, sender: ArtNetSender):
|
||||
self.sender = sender
|
||||
self.can_mode = "all_c1" # pad 13 / 14
|
||||
self.mover_mode = "all_c1" # pad 5 / 6
|
||||
self.color1 = [0, 0, 0] # R, G, B
|
||||
self.color2 = [0, 0, 0]
|
||||
self.bright_1_8 = 0
|
||||
self.bright_9_15 = 0
|
||||
self.bright_auto_cans = 0
|
||||
self.pan = 128
|
||||
self.tilt = 128
|
||||
self.rotate = 0
|
||||
self.mover_bright = 0
|
||||
self.focus = FOCUS_DEFAULT
|
||||
|
||||
def _nudge_list(self, values: list[int], index: int, delta: int) -> bool:
|
||||
nxt = clamp(values[index] + delta * KNOB_STEP)
|
||||
if nxt == values[index]:
|
||||
return False
|
||||
values[index] = nxt
|
||||
return True
|
||||
|
||||
def _nudge_int(self, name: str, delta: int) -> bool:
|
||||
cur = getattr(self, name)
|
||||
nxt = clamp(cur + delta * KNOB_STEP)
|
||||
if nxt == cur:
|
||||
return False
|
||||
setattr(self, name, nxt)
|
||||
return True
|
||||
|
||||
def apply_knob(self, knob: int, delta: int) -> bool:
|
||||
if delta == 0:
|
||||
return False
|
||||
if knob == 1:
|
||||
return self._nudge_list(self.color1, 2, delta)
|
||||
if knob == 2:
|
||||
return self._nudge_list(self.color2, 2, delta)
|
||||
if knob == 3:
|
||||
return self._nudge_list(self.color1, 1, delta)
|
||||
if knob == 4:
|
||||
return self._nudge_list(self.color2, 1, delta)
|
||||
if knob == 5:
|
||||
return self._nudge_list(self.color1, 0, delta)
|
||||
if knob == 6:
|
||||
return self._nudge_list(self.color2, 0, delta)
|
||||
ints = {
|
||||
7: "bright_auto_cans",
|
||||
9: "pan",
|
||||
10: "tilt",
|
||||
11: "focus",
|
||||
12: "rotate",
|
||||
13: "mover_bright",
|
||||
15: "bright_1_8",
|
||||
16: "bright_9_15",
|
||||
}
|
||||
name = ints.get(knob)
|
||||
if name is None:
|
||||
return False
|
||||
return self._nudge_int(name, delta)
|
||||
|
||||
def set_can_mode(self, mode: str) -> bool:
|
||||
if mode == self.can_mode:
|
||||
return False
|
||||
self.can_mode = mode
|
||||
return True
|
||||
|
||||
def set_mover_mode(self, mode: str) -> bool:
|
||||
if mode == self.mover_mode:
|
||||
return False
|
||||
self.mover_mode = mode
|
||||
return True
|
||||
|
||||
def _rgb(self, slot: str | None) -> tuple[int, int, int]:
|
||||
if slot == "c1":
|
||||
return tuple(self.color1) # type: ignore[return-value]
|
||||
if slot == "c2":
|
||||
return tuple(self.color2) # type: ignore[return-value]
|
||||
return (0, 0, 0)
|
||||
|
||||
def _mover_slot(self, pix: int) -> str:
|
||||
# Pixel 0 = center; pixels 1–6 = outer ring.
|
||||
if self.mover_mode == "all_c1":
|
||||
return "c1"
|
||||
if pix == 0:
|
||||
return "c2"
|
||||
return "c1"
|
||||
|
||||
def render(self) -> None:
|
||||
for i, dmx in enumerate(CAN_ADDRS):
|
||||
can = i + 1
|
||||
if can in (13, 14, 15):
|
||||
bright = self.bright_auto_cans
|
||||
elif can <= 8:
|
||||
bright = self.bright_1_8
|
||||
else:
|
||||
bright = self.bright_9_15
|
||||
self.sender.set_slot(dmx + CAN_DIM, bright)
|
||||
if can in (13, 14, 15):
|
||||
continue # RGB from QLC chasers
|
||||
r, g, b = self._rgb(can_slot(can, self.can_mode))
|
||||
self.sender.set_slot(dmx + CAN_R, r)
|
||||
self.sender.set_slot(dmx + CAN_G, g)
|
||||
self.sender.set_slot(dmx + CAN_B, b)
|
||||
|
||||
for addr, pan_off in zip(MOVER_ADDRS, MOVER_PAN_OFFSET):
|
||||
pan = (self.pan + pan_off) & 0xFF
|
||||
self.sender.set_slot(addr + CH_PAN - 1, pan)
|
||||
self.sender.set_slot(addr + CH_PAN, 0) # pan fine
|
||||
self.sender.set_slot(addr + CH_TILT - 1, self.tilt)
|
||||
self.sender.set_slot(addr + CH_TILT, 0) # tilt fine
|
||||
self.sender.set_slot(addr + CH_ROTATE - 1, self.rotate)
|
||||
self.sender.set_slot(addr + CH_FOCUS - 1, self.focus)
|
||||
self.sender.set_slot(addr + CH_DIMMER - 1, self.mover_bright)
|
||||
for pix in range(PIXELS):
|
||||
r, g, b = self._rgb(self._mover_slot(pix))
|
||||
base = addr + CH_RED1 - 1 + pix * 4
|
||||
self.sender.set_slot(base, r)
|
||||
self.sender.set_slot(base + 1, g)
|
||||
self.sender.set_slot(base + 2, b)
|
||||
self.sender.set_slot(base + 3, 0)
|
||||
|
||||
def summary(self) -> str:
|
||||
c1 = tuple(self.color1)
|
||||
c2 = tuple(self.color2)
|
||||
return (
|
||||
f"cans={self.can_mode} movers={self.mover_mode} "
|
||||
f"c1={c1} c2={c2} "
|
||||
f"bright {self.bright_1_8}/{self.bright_9_15} "
|
||||
f"mover pan={self.pan} tilt={self.tilt} rot={self.rotate} "
|
||||
f"dim={self.mover_bright} foc={self.focus}"
|
||||
)
|
||||
|
||||
|
||||
def listen(port: str, state: TwistedState) -> None:
|
||||
with mido.open_input(port) as incoming:
|
||||
for msg in incoming:
|
||||
if msg.type == "note_on" and msg.velocity > 0:
|
||||
pad = PADS.get((msg.channel, msg.note))
|
||||
changed = False
|
||||
if pad == 5:
|
||||
changed = state.set_mover_mode("all_c1")
|
||||
elif pad == 6:
|
||||
changed = state.set_mover_mode("split")
|
||||
elif pad == 13:
|
||||
changed = state.set_can_mode("all_c1")
|
||||
elif pad == 14:
|
||||
changed = state.set_can_mode("split")
|
||||
if changed:
|
||||
state.render()
|
||||
print(state.summary(), flush=True)
|
||||
elif msg.type == "control_change":
|
||||
knob = KNOBS.get((msg.channel, msg.control))
|
||||
if knob is None:
|
||||
continue
|
||||
delta = encoder_delta(msg.value)
|
||||
if state.apply_knob(knob, delta):
|
||||
state.render()
|
||||
print(state.summary(), flush=True)
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("midi", nargs="?", help="MIDI port name substring")
|
||||
parser.add_argument("--ip", default=None, help="Art-Net node IP")
|
||||
parser.add_argument("--universe", type=int, default=0)
|
||||
args = parser.parse_args()
|
||||
|
||||
load_maps(MAP_PATH)
|
||||
if not PADS or not KNOBS:
|
||||
raise SystemExit(f"No MIDI map in {MAP_PATH}. Run scripts/midi.py first.")
|
||||
|
||||
ip = args.ip or discover_artnet_node(DEFAULT_NODE)
|
||||
port = find_port(args.midi)
|
||||
sender = ArtNetSender(ip, universe=args.universe)
|
||||
state = TwistedState(sender)
|
||||
state.render()
|
||||
|
||||
print(f"Art-Net {ip} universe {args.universe}", flush=True)
|
||||
print(f"MIDI {port} map {MAP_PATH}", flush=True)
|
||||
print(
|
||||
"Pad 5/6 = mover LEDs. Pad 13/14 = cans. Ctrl+C to stop.",
|
||||
flush=True,
|
||||
)
|
||||
print(state.summary(), flush=True)
|
||||
try:
|
||||
listen(port, state)
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
finally:
|
||||
sender.close()
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
Reference in new issue
Block a user