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:
jimmyandCursor committed 2026-10-21 15:53:22 +13:00
1 parent dc05192a25
commit 9f40933227
1 file changed
+265
+265
View File
@@ -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())