From 9f40933227910df8e15082bbf4fe53275e3a1c52 Mon Sep 17 00:00:00 2001 From: Jimmy Date: Wed, 21 Oct 2026 15:53:22 +1300 Subject: [PATCH] Drive the twisted cans and movers from the SMC-PAD over Art-Net. Co-authored-by: Cursor --- scripts/twisted_midi.py | 265 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 265 insertions(+) create mode 100644 scripts/twisted_midi.py diff --git a/scripts/twisted_midi.py b/scripts/twisted_midi.py new file mode 100644 index 0000000..77ad6b2 --- /dev/null +++ b/scripts/twisted_midi.py @@ -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())