Files
qlcplus/padcontroller/midi.py
T
jimmyandClaude Opus 5.5 f674dc9fe0 Give the movers every EFX shape and drop their Strobe in the test show.
The movers layer loses its Strobe (pad 9): its button, its scene and the
forced-HTP strobe channel it needed. Its pad, the rest of the second row
and pad 5 take the five shapes the movers did not have yet: Diamond, Square,
Corners (SquareChoppy), Leaf, and Tilt (Line2 on tilt alone). All nine sit in
the Movement solo frame, one at a time, mirrored and relative to the knobs.
Knob 13's speed dial gives Corners an eighth of its time and the rest a
quarter (scripts/shows/mover_all_efx.py). The pad controller settles the
knobs after all nine.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 01:47:15 +13:00

338 lines
13 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Pad controller: intercept the SMC-PAD's MIDI and smooth its knob CCs so RGBW fades feel less stepped.
Reads the physical pad (Bluetooth or USB), passes pad notes through
immediately, and eases Control Change values toward their targets at
~120 Hz before emitting on a virtual port named "padcontroller".
On start it also sets the pad lamps over USB (scripts/pad/pad_lamps.py): bank 1 off and
bank 2 in the colours from shows/test.qxw. On Bluetooth it says so and carries on.
While it runs, the Pump and Threshold pads (notes 36 and 37) light while their mode is on.
While Play is held, bank 2 notes 52–67 go out as 68–83 (see padcontroller/layer.py).
Point QLC+ MIDI input at that virtual port (midi.qxw does this via
patch_smc_pad.py once the pad controller is running). Every 2 s it checks the
links: it reopens the pad when it is replugged (or moves to Bluetooth when that
turns up) and re-links QLC+ to the virtual port after a restart, so QLC+ can stay open.
QLC+ reopens its MIDI port when it loads a show, so a new link to QLC+ while
the pad controller runs means the show has just loaded with every button off.
REOPEN_DELAY later it presses the last colour pads again (see PlayLayer.colours),
which it keeps in COLOURS_FILE so they outlive a restart of the pad controller.
When one of the movers' movement pads goes off, SETTLE_DELAY later it
nudges the Pan and Tilt knobs a step and puts them back, so QLC+ drops
the EFX's last offset (see PlayLayer.settle).
Usage:
.venv/bin/python -m padcontroller.midi
# optional: --tau 0.05 (seconds; lower = snappier, higher = silkier)
padcontroller/systemd/install.sh runs it as a systemd user service.
"""
from __future__ import annotations
import argparse
import json
import math
import os
import re
import subprocess
import sys
import threading
import time
from dataclasses import dataclass, field
from pathlib import Path
from typing import Callable
ROOT = Path(__file__).resolve().parents[1]
import glob
for p in glob.glob(str(ROOT / ".venv" / "lib" / "python*" / "site-packages")):
sys.path.insert(0, p)
import rtmidi
from padcontroller.layer import SUBMASTER_CC, PlayLayer # noqa: E402
# The lamp colours come from the show scripts, which are not part of this package.
sys.path.insert(0, str(ROOT / "scripts" / "pad"))
from pad_lamps import set_lamps, set_sound_lamps # noqa: E402
VIRTUAL_NAME = "padcontroller"
COLOURS_FILE = Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local" / "state")) / "padcontroller" / "colours.json"
REOPEN_DELAY = 1.5 # s for QLC+ to finish loading the virtual console
SETTLE_DELAY = 0.1 # s for QLC+ to stop a relative EFX before the knob nudge, and between its two steps
# Bluetooth first when the pad is paired, USB otherwise.
SOURCE_HINTS = (
"SMC-PAD Bluetooth",
"SINCO SMC-PAD-Master",
"SINCO SMC-PAD-Private",
"SINCO",
"SMC-PAD",
)
def pick_source(names: list[str]) -> int | None:
"""Index of the best SMC-PAD port in names, or None when the pad is not there."""
for hint in SOURCE_HINTS:
for i, name in enumerate(names):
if hint in name and VIRTUAL_NAME not in name:
return i
return None
def find_source_port(midiin: rtmidi.MidiIn) -> int:
ports = midiin.get_ports()
i = pick_source(ports)
if i is None:
raise SystemExit(
"No SMC-PAD MIDI source found. Ports:\n " + "\n ".join(ports or ["(none)"])
)
return i
@dataclass
class AlsaPort:
addr: str # "client:port"
client: str
name: str
to: set[str] = field(default_factory=set)
sources: set[str] = field(default_factory=set)
def parse_aconnect(text: str) -> list[AlsaPort]:
"""The ports in `aconnect -l` output, with who they connect to and from."""
ports: list[AlsaPort] = []
client = client_name = None
for line in text.splitlines():
m = re.match(r"client (\d+): '([^']+)'", line)
if m:
client, client_name = m.group(1), m.group(2)
continue
m = re.match(r"\s+(\d+)\s+'([^']+)'", line)
if m and client is not None:
ports.append(AlsaPort(f"{client}:{m.group(1)}", client_name, m.group(2).strip()))
continue
m = re.match(r"\s+(Connecting To|Connected From):(.*)", line)
if m and ports:
addrs = set(re.findall(r"\d+:\d+", m.group(2)))
(ports[-1].to if m.group(1) == "Connecting To" else ports[-1].sources).update(addrs)
return ports
def missing_links(ports: list[AlsaPort], src_name: str | None) -> list[tuple[str, str]]:
"""(from, to) ALSA links the pad controller should have but doesn't.
The pad into padcontroller-in (Bluetooth MIDI sometimes drops it, and a replugged
USB pad comes back without it), and padcontroller out to every QLC+ client
(QLC+ only subscribes when it opens the port, so it loses it when we restart).
"""
links = []
ours_in = next((p for p in ports if p.client == "padcontroller-in"), None)
ours_out = next((p for p in ports if p.client == "padcontroller-out"), None)
m = re.search(r"(\d+:\d+)$", src_name or "")
if ours_in and m and m.group(1) not in ours_in.sources:
links.append((m.group(1), ours_in.addr))
if ours_out:
for p in ports:
if p.client == "qlcplus" and p.addr not in ours_out.to:
links.append((ours_out.addr, p.addr))
return links
def ensure_links(src_name: str | None) -> bool:
"""Make the missing links. True when one of them is to QLC+."""
try:
out = subprocess.check_output(["aconnect", "-l"], text=True)
except (FileNotFoundError, subprocess.CalledProcessError):
return False
ports = parse_aconnect(out)
qlc = {p.addr for p in ports if p.client == "qlcplus"}
to_qlc = False
for src, dst in missing_links(ports, src_name):
if subprocess.run(["aconnect", src, dst], capture_output=True).returncode == 0:
print(f"Linked {src} -> {dst}", flush=True)
to_qlc = to_qlc or dst in qlc
return to_qlc
def load_colours(layer: PlayLayer) -> None:
try:
saved = json.loads(COLOURS_FILE.read_text())
layer.colours = {int(k): tuple(v) if v else None for k, v in saved.items()}
except (OSError, ValueError, TypeError):
pass
def save_colours(layer: PlayLayer) -> None:
try:
COLOURS_FILE.parent.mkdir(parents=True, exist_ok=True)
COLOURS_FILE.write_text(json.dumps(layer.colours) + "\n")
except OSError as exc:
print(f"Colours not saved: {exc}", flush=True)
class SoundLamps:
"""Show which sound pad is on, off the MIDI loop: each write takes ~60 ms."""
def __init__(self) -> None:
self.wanted: tuple[bool, bool] | None = None
self.wake = threading.Event()
threading.Thread(target=self._run, daemon=True).start()
def show(self, pump: bool, threshold: bool) -> None:
self.wanted = (pump, threshold)
self.wake.set()
def _run(self) -> None:
shown = None
while True:
self.wake.wait()
self.wake.clear()
wanted = self.wanted
if wanted is None or wanted == shown:
continue
try:
set_sound_lamps(*wanted)
shown = wanted
except (SystemExit, Exception) as exc: # no Private port on Bluetooth
print(f"Sound lamps not set: {exc}", flush=True)
def main() -> None:
ap = argparse.ArgumentParser(description=__doc__)
ap.add_argument(
"--tau",
type=float,
default=0.055,
help="smoothing time constant in seconds (default 0.055)",
)
ap.add_argument("--rate", type=float, default=120.0, help="update Hz")
ap.add_argument("--no-lamps", action="store_true", help="leave the pad lamp colours alone")
args = ap.parse_args()
midiin = rtmidi.MidiIn(rtapi=rtmidi.API_LINUX_ALSA, name="padcontroller-in")
midiout = rtmidi.MidiOut(rtapi=rtmidi.API_LINUX_ALSA, name="padcontroller-out")
src = find_source_port(midiin)
src_name = midiin.get_ports()[src]
midiin.open_port(src)
midiin.ignore_types(timing=True, active_sense=True, sysex=True)
midiout.open_virtual_port(VIRTUAL_NAME)
# current/target as floats 0..127, keyed by (channel, cc)
current: dict[tuple[int, int], float] = {}
target: dict[tuple[int, int], float] = {}
last_sent: dict[tuple[int, int], int] = {}
layer = PlayLayer()
load_colours(layer)
saved_colours = dict(layer.colours)
reopen_at: float | None = None
# (when, messages to send then), for the settle after a mover EFX
later: list[tuple[float, Callable[[], list[list[int]]]]] = []
# Links made this soon after start are ours being restored, with QLC+'s buttons as they were.
reopen_from = time.monotonic() + 5.0
print(f"Source: {src_name}", flush=True)
print(f"Virtual: {VIRTUAL_NAME} (tau={args.tau}s @ {args.rate} Hz)", flush=True)
print("Pass notes through (Play held shifts bank 2 up 16); smooth CC. Ctrl+C to stop.", flush=True)
ensure_links(src_name)
sound_lamps = None
if not args.no_lamps:
set_lamps()
sound_lamps = SoundLamps()
dt = 1.0 / args.rate
alpha = 1.0 - math.exp(-dt / max(args.tau, 1e-4))
next_link_check = time.monotonic() + 2.0
try:
while True:
now = time.monotonic()
if now >= next_link_check:
# Follow the pad: reopen it when it comes back, and move to Bluetooth when paired.
names = midiin.get_ports()
best = pick_source(names)
best_name = names[best] if best is not None else None
if best_name != src_name:
midiin.close_port()
if best is not None:
midiin.open_port(best)
print(f"Source: {best_name}", flush=True)
else:
print("Source: (pad gone, waiting)", flush=True)
src_name = best_name
if ensure_links(src_name) and now >= reopen_from:
reopen_at = now + REOPEN_DELAY
next_link_check = now + 2.0
if reopen_at is not None and now >= reopen_at:
reopen_at = None
taps = layer.reopen()
for out in taps:
midiout.send_message(out)
print(f"QLC+ reopened: pressed {sum(out[0] & 0xF0 == 0x90 for out in taps)} colour pad(s) again", flush=True)
if sound_lamps:
sound_lamps.show(layer.pump, layer.threshold)
# Drain inbound
while True:
msg = midiin.get_message()
if msg is None:
break
data, _ = msg
if not data:
continue
for out in layer.handle(list(data)):
cmd = out[0] & 0xF0
if cmd == 0xB0 and len(out) >= 3 and out[1] != SUBMASTER_CC:
# Control Change → smooth
key = (out[0] & 0x0F, out[1])
target[key] = float(out[2])
if key not in current:
current[key] = float(out[2])
last_sent[key] = -1
else:
# Notes, aftertouch, PC, the Sound reset (always resent), etc. → immediate
midiout.send_message(out)
if sound_lamps:
sound_lamps.show(layer.pump, layer.threshold)
if layer.settle:
layer.settle = False
later += [(now + SETTLE_DELAY, layer.nudge), (now + 2 * SETTLE_DELAY, layer.positions)]
for due in [item for item in later if now >= item[0]]:
later.remove(due)
for out in due[1]():
midiout.send_message(out)
if layer.colours != saved_colours:
save_colours(layer)
saved_colours = dict(layer.colours)
# Ease CC toward targets and emit when quantized value moves
for key, tgt in list(target.items()):
cur = current.get(key, tgt)
cur = cur + (tgt - cur) * alpha
# Snap when close so we actually reach the endpoint
if abs(tgt - cur) < 0.15:
cur = tgt
current[key] = cur
q = int(round(cur))
q = 0 if q < 0 else 127 if q > 127 else q
if last_sent.get(key) != q:
ch, cc = key
midiout.send_message([0xB0 | ch, cc, q])
last_sent[key] = q
time.sleep(dt)
except KeyboardInterrupt:
print("\nStopped.", flush=True)
finally:
midiin.close_port()
midiout.close_port()
del midiin
del midiout
if __name__ == "__main__":
main()