The SMC-PAD latches Pause itself: one message a press, 127 and 0 on alternate presses, nothing on release. The pad controller flipped the layer only on 127, so every second press did nothing. Bank 1 now follows the value: 0 is the cans, 127 the movers. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
144 lines
6.6 KiB
Python
144 lines
6.6 KiB
Python
"""Hold Play to move the bank 2 pads up a layer.
|
||
|
||
The SMC-PAD sends CC 27 as 127 when Play goes down and 0 when it comes up.
|
||
While it is down, pad notes 52–67 go out as 68–83, so QLC+ can tell a
|
||
second set of buttons from the first. Play itself is not passed on.
|
||
|
||
Pause (CC 28) does the same for bank 1, but latches: the SMC-PAD sends one
|
||
message a press, 127 and 0 on alternate presses and nothing on release, and
|
||
bank 1 follows it. At 0, bank 1 pads 36–51 go out as they are, for the cans.
|
||
At 127, they go out as 84–99, for the movers. Pause itself is not passed on.
|
||
|
||
colours holds the last colour pad pressed in each set, as sent (52–67 for the
|
||
cans, 68–83 for the movers), or None once it is pressed again: the colour
|
||
buttons toggle in a solo frame. QLC+ does not save which buttons are on, so
|
||
reopen() presses them again when QLC+ loads the show.
|
||
|
||
The movers' movement pads (pads 13–16, 9–12 and 5 on the movers layer: notes
|
||
96–99, 92–95 and 88) each toggle a relative EFX around the Pan and Tilt knobs (9
|
||
and 10, CC 38 and 39). They share a solo frame in QLC+, so starting one stops the others.
|
||
QLC+ 4.12 leaves an EFX's last offset on the movers when it stops, until those
|
||
sliders change, so when the one that is on goes off, settle asks for the two
|
||
knobs one step off and then back (nudge() and positions()). Swapping needs
|
||
none: the new EFX writes over the old one's offset. moving holds the note whose
|
||
EFX is on, from the presses: only a guess, as QLC+ sends no feedback for it.
|
||
|
||
The cans' pattern pads (pads 1–8 on the cans layer: notes 36–43) each toggle a
|
||
pattern, in a solo frame like the movement pads; pattern holds the note of the
|
||
one that is on. A Colour 1 pad starts a colour scene on the cans, and the
|
||
newest function wins their colour, so the scene would cover the pattern. While
|
||
a pattern is on, a Colour 1 press sets restart_pattern, and the caller sends
|
||
pattern_tap() twice a moment later, off and on again, so the pattern restarts on
|
||
top in the new colour. Taps sent with the colour itself land in the same QLC+
|
||
tick and change nothing.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
PLAY_CC = 27
|
||
FIRST_NOTE = 52
|
||
LAST_NOTE = 67
|
||
SHIFT = 16
|
||
PAUSE_CC = 28
|
||
BANK_1_FIRST = 36
|
||
BANK_1_LAST = 51
|
||
MOVERS_SHIFT = 48 # bank 1 goes out as 84–99 while Pause is on, above bank 2's held layer
|
||
KNOB_CHANNEL = 0
|
||
# Wander, Ballyhoo, Circle, Sweep; Diamond, Square, Corners, Leaf; Tilt: pads 13–16, 9–12, 5
|
||
RELATIVE_NOTES = (96, 97, 98, 99, 92, 93, 94, 95, 88)
|
||
POSITION_CCS = (38, 39) # knobs 9 and 10: the movers' Pan and Tilt
|
||
PATTERN_NOTES = range(36, 44) # the can patterns: pads 1–8 on the cans layer
|
||
|
||
|
||
class PlayLayer:
|
||
def __init__(self) -> None:
|
||
self.held = False
|
||
self.movers = False # Pause latched on puts bank 1 on the movers
|
||
# (channel, note as pressed) -> note sent, so a release matches its press
|
||
self.sent: dict[tuple[int, int], int] = {}
|
||
# Pan and Tilt as last sent; QLC+ starts them at 0.
|
||
self.position = {cc: 0 for cc in POSITION_CCS}
|
||
self.moving: int | None = None
|
||
self.settle = False # a relative EFX just went off: the caller sends nudge(), then positions()
|
||
self.pattern: int | None = None
|
||
self.pattern_channel = 0
|
||
self.restart_pattern = False # a Colour 1 press covered the pattern: the caller sends pattern_tap() twice
|
||
# set -> (channel, note sent) of the colour that is on
|
||
self.colours: dict[int, tuple[int, int] | None] = {1: None, 2: None}
|
||
|
||
def handle(self, data: list[int]) -> list[list[int]]:
|
||
"""The messages to send on. Empty when the message is swallowed."""
|
||
status = data[0]
|
||
kind = status & 0xF0
|
||
channel = status & 0x0F
|
||
if kind == 0xB0 and len(data) >= 3 and data[1] == PLAY_CC:
|
||
self.held = data[2] > 0
|
||
return []
|
||
if kind == 0xB0 and len(data) >= 3 and data[1] == PAUSE_CC:
|
||
self.movers = data[2] > 0
|
||
return []
|
||
if kind == 0xB0 and len(data) >= 3 and channel == KNOB_CHANNEL and data[1] in self.position:
|
||
self.position[data[1]] = data[2]
|
||
return [list(data)]
|
||
if kind not in (0x80, 0x90) or len(data) < 3:
|
||
return [list(data)]
|
||
key = (channel, data[1])
|
||
is_on = kind == 0x90 and data[2] > 0
|
||
if is_on:
|
||
out = self.shifted(data[1])
|
||
self.sent[key] = out
|
||
else:
|
||
out = self.sent.pop(key, data[1])
|
||
note = out
|
||
if note in RELATIVE_NOTES and is_on:
|
||
if note == self.moving:
|
||
self.moving = None
|
||
self.settle = True
|
||
else:
|
||
self.moving = note
|
||
elif note in PATTERN_NOTES and is_on:
|
||
self.pattern = None if note == self.pattern else note
|
||
self.pattern_channel = channel
|
||
elif FIRST_NOTE <= note <= LAST_NOTE and is_on and self.pattern is not None:
|
||
self.restart_pattern = True
|
||
if is_on and FIRST_NOTE <= out <= LAST_NOTE + SHIFT:
|
||
colour_set = 1 if out <= LAST_NOTE else 2
|
||
pressed = (channel, out)
|
||
self.colours[colour_set] = None if self.colours[colour_set] == pressed else pressed
|
||
return [[status, out, *data[2:]]]
|
||
|
||
def shifted(self, note: int) -> int:
|
||
"""The note a press goes out as: bank 2 up while Play is held, bank 1 up while Pause is on."""
|
||
if self.held and FIRST_NOTE <= note <= LAST_NOTE:
|
||
return note + SHIFT
|
||
if self.movers and BANK_1_FIRST <= note <= BANK_1_LAST:
|
||
return note + MOVERS_SHIFT
|
||
return note
|
||
|
||
def reopen(self) -> list[list[int]]:
|
||
"""QLC+ has loaded the show: everything is off. Press the colours that were on."""
|
||
self.moving = None
|
||
self.pattern = None
|
||
out = []
|
||
for colour in self.colours.values():
|
||
if colour is not None:
|
||
out += tap(*colour)
|
||
return out
|
||
|
||
def pattern_tap(self) -> list[list[int]]:
|
||
"""A tap of the can pattern that is on, to toggle it; nothing once none is."""
|
||
return [] if self.pattern is None else tap(self.pattern_channel, self.pattern)
|
||
|
||
def nudge(self) -> list[list[int]]:
|
||
"""Pan and Tilt one step off their knobs, so QLC+ writes them again."""
|
||
return [[0xB0 | KNOB_CHANNEL, cc, v - 1 if v else 1] for cc, v in self.position.items()]
|
||
|
||
def positions(self) -> list[list[int]]:
|
||
"""Pan and Tilt back at their knobs."""
|
||
return [[0xB0 | KNOB_CHANNEL, cc, v] for cc, v in self.position.items()]
|
||
|
||
|
||
def tap(channel: int, note: int) -> list[list[int]]:
|
||
"""A press and release of note, to toggle a QLC+ button off."""
|
||
return [[0x90 | channel, note, 127], [0x80 | channel, note, 0]]
|