"""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 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 USB when that turns up) and re-links QLC+ to the virtual port after a restart, so QLC+ can stay open. 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 math import re import subprocess import sys import time from dataclasses import dataclass, field from pathlib import Path 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 # noqa: E402 VIRTUAL_NAME = "padcontroller" # USB first when the pad is plugged in, Bluetooth otherwise. SOURCE_HINTS = ( "SINCO SMC-PAD-Master", "SMC-PAD Bluetooth", "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) -> None: try: out = subprocess.check_output(["aconnect", "-l"], text=True) except (FileNotFoundError, subprocess.CalledProcessError): return for src, dst in missing_links(parse_aconnect(out), src_name): if subprocess.run(["aconnect", src, dst], capture_output=True).returncode == 0: print(f"Linked {src} -> {dst}", 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( "--lock-knobs", action="store_true", help="knobs 1-10 move test.qxw's custom sliders only after the Custom pad is pressed", ) 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(lock_knobs=args.lock_knobs) 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) if not args.no_lamps: set_lamps() 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 USB when plugged in. 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 ensure_links(src_name) next_link_check = now + 2.0 # 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) # 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()