#!/usr/bin/env python3 """Smooth SMC-PAD 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 "SMC-PAD Smooth". On start it also sets the pad lamps over USB (pad_colours.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 pad_layer.py). Point QLC+ MIDI input at that virtual port (midi.qxw does this via patch_smc_pad.py once the smoother is running). Usage: .venv/bin/python scripts/smooth_smc_pad.py # optional: --tau 0.05 (seconds; lower = snappier, higher = silkier) """ from __future__ import annotations import argparse import math import re import subprocess import sys import time 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 sys.path.insert(0, str(Path(__file__).resolve().parent)) from pad_lamps import set_lamps # noqa: E402 from pad_layer import PlayLayer # noqa: E402 VIRTUAL_NAME = "SMC-PAD Smooth" SOURCE_HINTS = ( "SMC-PAD Bluetooth", "SINCO SMC-PAD-Private", "SINCO SMC-PAD-Master", "SINCO", "SMC-PAD", ) def find_source_port(midiin: rtmidi.MidiIn) -> int: ports = midiin.get_ports() for hint in SOURCE_HINTS: for i, name in enumerate(ports): if hint in name and VIRTUAL_NAME not in name: return i raise SystemExit( "No SMC-PAD MIDI source found. Ports:\n " + "\n ".join(ports or ["(none)"]) ) def _alsa_port(client_substr: str, port_substr: str | None = None) -> str | None: """Return 'client:port' for an aconnect client/port name match.""" try: out = subprocess.check_output(["aconnect", "-l"], text=True) except (FileNotFoundError, subprocess.CalledProcessError): return None client = None client_name = None for line in out.splitlines(): m = re.match(r"client (\d+): '([^']+)'", line) if m: client, client_name = int(m.group(1)), m.group(2) continue m = re.match(r"\s+(\d+)\s+'([^']+)'", line) if not m or client is None or client_name is None: continue port, pname = int(m.group(1)), m.group(2).strip() if client_substr not in client_name and client_substr not in pname: continue if port_substr and port_substr not in pname and port_substr not in client_name: continue if VIRTUAL_NAME in pname: continue return f"{client}:{port}" return None def ensure_alsa_link() -> None: """Bluetooth MIDI sometimes drops the ALSA subscription; re-subscribe.""" src = None for hint in ("SMC-PAD Bluetooth", "SINCO", "SMC-PAD"): src = _alsa_port(hint) if src: break dst = _alsa_port("smc-smooth-in") if not src or not dst: return subprocess.run(["aconnect", src, dst], capture_output=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="smc-smooth-in") midiout = rtmidi.MidiOut(rtapi=rtmidi.API_LINUX_ALSA, name="smc-smooth-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_alsa_link() 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: ensure_alsa_link() 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: # 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, 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()