#!/usr/bin/env python3 """Store scene colours in an SMC-PAD preset bank. Pad bank 1 is notes 36–51 and pad bank 2 is notes 52–67, bottom-left first. Note messages do not change these lamps. The colour is three bytes in the preset, written over the Private USB port. .venv/bin/python scripts/pad/pad_colours.py --xchc --bank 2 .venv/bin/python scripts/pad/pad_colours.py --colour-set --bank 2 .venv/bin/python scripts/pad/pad_colours.py --dry-run .venv/bin/python scripts/pad/pad_colours.py --clear .venv/bin/python scripts/pad/pad_colours.py --identify --identify lights every pad on a page in that page's colour, in rainbow order, in all eight presets, so the page on show can be read at a glance. The write is checked by reading it back. It is sent to the running copy and to the stored preset, and it leaves notes, channels, and knobs as they are. An empty write at the start of the preset then commits it, which is what MidiSuite's Save button sends. """ from __future__ import annotations import argparse import glob import sys from pathlib import Path ROOT = Path(__file__).resolve().parents[2] sys.path.insert(0, str(ROOT)) sys.path.insert(0, str(ROOT / "scripts" / "pad")) from patch_smc_pad import PAD_COLORS # noqa: E402 from padcontroller import preset # noqa: E402 from padcontroller.device import PadError, read_image, save_image, transact # noqa: E402 from padcontroller.device import private_port as _private_port # noqa: E402 from padcontroller.preset import scale # noqa: E402 from padcontroller.sysex import ( # noqa: E402 RAM, decode, encode, payload_data, read_request, save_request, write_request, ) # Preset image, memory type 5. Each of these offsets is a note-36 pad, # and the next 15 records are notes 37–51. The running copy is at RAM. RECORD = 26 RGB_AT = 4 BANKS = (1044, 8122, 11661, 15200, 18739, 22278, 25817) def led_rgb(r: int, g: int, b: int, w: int) -> tuple[int, int, int]: return (min(255, r + w), min(255, g + w), min(255, b + w)) # shows/xchc.qxw functions 0–8, in that order. The pad lamps are RGB, so # the white scene is stored as white rather than the can's white channel. XCHC_COLOURS = ( ("Red", 255, 0, 0), ("Orange", 255, 127, 0), ("Yellow", 255, 255, 0), ("Green", 0, 255, 0), ("Cyan", 0, 255, 255), ("Blue", 0, 0, 255), ("Violet", 127, 0, 255), ("Magenta", 255, 0, 255), ("White", 255, 255, 255), ) # One colour per pad page, page 1 first. Rainbow order, so the page # number can be counted from red. PAGE_COLOURS = ( ("Red", 255, 0, 0), ("Orange", 255, 100, 0), ("Yellow", 255, 255, 0), ("Green", 0, 255, 0), ("Cyan", 0, 255, 255), ("Blue", 0, 0, 255), ("Violet", 160, 0, 255), ("White", 255, 255, 255), ) def identify_image(image: bytes) -> bytes: """The image with each pad page lit in its PAGE_COLOURS colour.""" out = bytearray(image) for number in range(preset.PRESET_COUNT): for index in range(preset.PAD_COUNT): _name, red, green, blue = PAGE_COLOURS[index // preset.PAGE_LEN] at = preset.colour_offset(number, index) out[at:at + 3] = bytes((scale(red), scale(green), scale(blue))) return bytes(out) def scene_colours(clear: bool = False) -> list[tuple[str, bytes]]: colours = [] for name, r, g, b, w in PAD_COLORS: if clear: colours.append((name, b"\x00\x00\x00")) continue red, green, blue = led_rgb(r, g, b, w) colours.append((name, bytes((scale(red), scale(green), scale(blue))))) return colours def xchc_colours(clear: bool = False) -> list[tuple[str, bytes]]: """The nine xchc colour scenes, then the rest of the 16-pad bank off.""" colours = [] for name, red, green, blue in XCHC_COLOURS: rgb = b"\x00\x00\x00" if clear else bytes((scale(red), scale(green), scale(blue))) colours.append((name, rgb)) colours.extend(("", b"\x00\x00\x00") for _ in range(16 - len(colours))) return colours def colour_set(clear: bool = False) -> list[tuple[str, bytes]]: """The colours of shows/test.qxw in pad order, then the rest of the bank off.""" sys.path.insert(0, str(ROOT / "scripts" / "shows")) from colour_sets import COLOURS colours = [] for name, r, g, b, w in COLOURS: rgb = b"\x00\x00\x00" if clear else bytes(scale(c) for c in led_rgb(r, g, b, w)) colours.append((name, rgb)) colours.extend(("", b"\x00\x00\x00") for _ in range(16 - len(colours))) return colours # Preset page whose records light each pad bank. Page 3 also sends notes # 52–67 but its colours are not shown; bank 2 takes them from page 7. BANK_PAGE = {1: 2, 2: 7} def bank_bases(bank: int) -> tuple[int, ...]: """Preset addresses where this pad bank's note records start.""" if bank < 1: raise ValueError(f"pad bank {bank} is not on this controller") page = BANK_PAGE.get(bank, bank + 1) skip = (page - 2) * 16 * RECORD return tuple(base + skip for base in BANKS) def colour_writes( clear: bool = False, bank: int = 1, colours: list[tuple[str, bytes]] | None = None, ) -> list[tuple[str, int, bytes]]: """(name, address, rgb) for one pad bank in every preset.""" palette = scene_colours(clear) if colours is None else list(colours) if clear and colours is not None: palette = [(name, b"\x00\x00\x00") for name, _rgb in palette] placed = [] for base in bank_bases(bank): for index, (name, rgb) in enumerate(palette): placed.append((name, base + index * RECORD + RGB_AT, rgb)) return placed def payload_data(decoded: bytes) -> bytes: """Bytes after the type, address, and length in a read reply.""" if decoded[:3] != b"\x00\x59\x23": raise ValueError(f"unexpected reply {decoded[:8].hex()}") payload = decoded[6:-1] return payload[8:] def private_port(names: list[str]) -> str: try: return _private_port(names) except PadError as exc: raise SystemExit(str(exc)) from exc def apply( clear: bool, bank: int = 1, colours: list[tuple[str, bytes]] | None = None, any_note: bool = False, ) -> None: for path in glob.glob(str(ROOT / ".venv" / "lib" / "python*" / "site-packages")): if path not in sys.path: sys.path.insert(0, path) import rtmidi midiout = rtmidi.MidiOut(rtapi=rtmidi.API_LINUX_ALSA) midiin = rtmidi.MidiIn(rtapi=rtmidi.API_LINUX_ALSA) port = private_port(midiout.get_ports()) index = midiout.get_ports().index(port) midiin.open_port(index) midiin.ignore_types(sysex=False, timing=True, active_sense=True) midiout.open_port(index) print(f"Port: {port}", flush=True) try: note = 36 + (bank - 1) * 16 for base in bank_bases(bank): reply = transact(midiout, midiin, read_request(base, 2)) mark = payload_data(reply) if mark[0] != 0x09 or (not any_note and mark[1] != note): raise SystemExit( f"preset at {base} is {mark.hex()}, not the note-{note} pads; nothing was written" ) bases = (RAM, 0) shown = set() for name, address, rgb in colour_writes(clear, bank, colours): for base in bases: transact(midiout, midiin, write_request(base + address, rgb)) if name in shown: continue check = payload_data(transact(midiout, midiin, read_request(address, 3))) if check != rgb: raise SystemExit(f"{name or 'pad'} read back {check.hex()}, expected {rgb.hex()}") shown.add(name) if name: print(f" {name:<8} {address:#06x} {rgb.hex()}", flush=True) reply = transact(midiout, midiin, save_request()) if reply[:3] != b"\x00\x59\x00" or reply[6:7] != b"\x00": raise SystemExit(f"the pad did not accept the save ({reply.hex()})") print("Saved on the pad.", flush=True) finally: for port in (midiout, midiin): port.close_port() port.delete() def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("--bank", type=int, default=1, help="pad bank to write (2 is notes 52–67)") parser.add_argument("--page", type=int, help="write preset page 0–7 instead (page 2 is bank 1, 3 is bank 2; 7 repeats 52–67)") parser.add_argument("--xchc", action="store_true", help="use the solid colour scenes from shows/xchc.qxw") parser.add_argument("--colour-set", action="store_true", help="use the 16 colours from shows/test.qxw") parser.add_argument("--clear", action="store_true", help="store black on every scene pad") parser.add_argument("--identify", action="store_true", help="light each pad page in its own colour") parser.add_argument("--dry-run", action="store_true", help="print the colours and do not open a port") args = parser.parse_args(argv) if args.page is not None: if not 2 <= args.page < preset.PAGE_COUNT: parser.error("--page must be 2–7") args.bank = args.page - 1 if args.identify: for page, (name, red, green, blue) in enumerate(PAGE_COLOURS, 1): print(f"page {page} {name:<7} {bytes((scale(red), scale(green), scale(blue))).hex()}") if not args.dry_run: try: written = save_image(identify_image(read_image())) except PadError as exc: raise SystemExit(str(exc)) from exc print(f"Saved on the pad ({written} bytes changed).") return 0 palette = xchc_colours(args.clear) if args.xchc else colour_set(args.clear) if args.colour_set else None if args.dry_run: seen = set() for name, address, rgb in colour_writes(args.clear, args.bank, palette): if not name or name in seen: continue seen.add(name) print(f"{name:<8} {address:#06x} {rgb.hex()}") return 0 apply(args.clear, args.bank, palette, any_note=args.page is not None) return 0 if __name__ == "__main__": raise SystemExit(main())