266 lines
8.8 KiB
Python
266 lines
8.8 KiB
Python
#!/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())
|