Add an SMC-PAD preset editor that saves pad colours the way MidiSuite does.

The record layout and writes come from usbmon captures of MidiSuite:
a pad colour is one three-byte write to its preset address, which lights
the lamp straight away, and Save is the empty write that keeps it after
a power cycle. Pad records are channel, note, min and max velocity, RGB,
then Led. Tempo, swing, pad curve, and transpose come from the global
block, memory type 4. The factory image from MidiSuite's Reset is kept
as a test fixture, and scripts/decode_usbmon.py prints the SysEx in a
capture.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
jimmyandClaude Opus 5.5 committed 2026-10-21 19:30:34 +13:00
1 parent adca8e17a4
commit 63b3129cca
13 files changed
+1811

No files matched your search

+195
View File
@@ -0,0 +1,195 @@
"""Local editor: load the SMC-PAD preset, edit it, save it back."""
from __future__ import annotations
import json
import mimetypes
import threading
import traceback
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import urlparse
from padeditor.device import Link, PadError, connected, read_global, read_image, save_image, write_colour
from padeditor.preset import IMAGE_LEN, PresetError, pack, pack_global, unpack, unpack_global
STATIC_DIR = Path(__file__).parent / "static"
class ApiError(Exception):
def __init__(self, message: str, status: int = 400):
super().__init__(message)
self.status = status
class Editor:
def __init__(self):
self.lock = threading.Lock()
def status(self) -> dict:
port = connected()
return {"connected": port is not None, "port": port}
def load(self) -> dict:
with self.lock:
try:
with Link() as link:
document = unpack(read_image(link))
document["global"] = unpack_global(read_global(link))
return document
except PadError as exc:
raise ApiError(str(exc), 503) from exc
def save(self, document: dict) -> dict:
try:
desired = pack(document)
block = document.get("global")
settings = pack_global(block) if isinstance(block, dict) else None
except PresetError as exc:
raise ApiError(str(exc)) from exc
with self.lock:
try:
written = save_image(desired, settings=settings)
except PadError as exc:
raise ApiError(str(exc), 503) from exc
if written:
message = f"Saved on the pad. {written} bytes written."
else:
message = "Saved on the pad."
return {"ok": True, "message": message, "bytes": written}
def colour(self, body: dict) -> dict:
try:
preset = int(body["preset"])
index = int(body["index"])
rgb = body["rgb"]
if not isinstance(rgb, list) or len(rgb) != 3:
raise PresetError("a pad colour needs red, green, and blue")
except (KeyError, TypeError, ValueError) as exc:
raise ApiError("colour needs a preset, a pad, and an rgb colour") from exc
with self.lock:
try:
offset = write_colour(preset, index, rgb)
except PresetError as exc:
raise ApiError(str(exc)) from exc
except PadError as exc:
raise ApiError(str(exc), 503) from exc
return {"ok": True, "offset": offset}
def imported(self, raw: bytes) -> dict:
try:
return unpack(raw)
except PresetError as exc:
raise ApiError(str(exc)) from exc
def exported(self, document: dict) -> bytes:
try:
return pack(document)
except PresetError as exc:
raise ApiError(str(exc)) from exc
def make_server(host: str = "127.0.0.1", port: int = 8770) -> ThreadingHTTPServer:
editor = Editor()
handler = type("BoundHandler", (Handler,), {"editor": editor})
server = ThreadingHTTPServer((host, port), handler)
server.editor = editor # type: ignore[attr-defined]
return server
class Handler(BaseHTTPRequestHandler):
editor: Editor
def log_message(self, fmt: str, *args) -> None:
return
def _json(self, status: int, body: dict) -> None:
raw = json.dumps(body).encode()
self.send_response(status)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(raw)))
self.send_header("Cache-Control", "no-store")
self.end_headers()
self.wfile.write(raw)
def _bytes(self, raw: bytes, content_type: str, filename: str | None = None) -> None:
self.send_response(200)
self.send_header("Content-Type", content_type)
self.send_header("Content-Length", str(len(raw)))
self.send_header("Cache-Control", "no-store")
if filename:
self.send_header("Content-Disposition", f'attachment; filename="{filename}"')
self.end_headers()
self.wfile.write(raw)
def _read(self) -> bytes:
n = int(self.headers.get("Content-Length") or 0)
return self.rfile.read(n) if n > 0 else b""
def _json_body(self) -> dict:
raw = self._read()
if not raw:
return {}
try:
body = json.loads(raw.decode("utf-8"))
except json.JSONDecodeError as exc:
raise ApiError(f"invalid JSON: {exc}") from exc
if not isinstance(body, dict):
raise ApiError("expected a JSON object")
return body
def _static(self, rel: str) -> None:
rel = rel.lstrip("/") or "index.html"
path = (STATIC_DIR / rel).resolve()
if STATIC_DIR.resolve() not in path.parents or not path.is_file():
self.send_error(404)
return
ctype = mimetypes.guess_type(path.name)[0] or "application/octet-stream"
if ctype.startswith("text/") or ctype.endswith(("javascript", "json")):
ctype = f"{ctype}; charset=utf-8"
self._bytes(path.read_bytes(), ctype)
def _dispatch(self, method: str) -> None:
url = urlparse(self.path)
editor = self.editor
try:
if not url.path.startswith("/api/"):
if method != "GET":
self.send_error(405)
return
if url.path == "/favicon.ico":
self.send_response(204)
self.send_header("Content-Length", "0")
self.end_headers()
return
self._static(url.path)
return
route = (method, url.path)
if route == ("GET", "/api/status"):
self._json(200, editor.status())
elif route == ("POST", "/api/load"):
self._json(200, editor.load())
elif route == ("POST", "/api/save"):
self._json(200, editor.save(self._json_body()))
elif route == ("POST", "/api/colour"):
self._json(200, editor.colour(self._json_body()))
elif route == ("POST", "/api/import"):
raw = self._read()
if len(raw) != IMAGE_LEN:
raise ApiError(f"preset file is {len(raw)} bytes, expected {IMAGE_LEN}")
self._json(200, editor.imported(raw))
elif route == ("POST", "/api/export"):
self._bytes(editor.exported(self._json_body()), "application/octet-stream", "smc-pad-preset.bin")
else:
self._json(404, {"error": f"no route {method} {url.path}"})
except ApiError as exc:
self._json(exc.status, {"error": str(exc)})
except Exception as exc: # noqa: BLE001 — surface anything else to the UI
traceback.print_exc()
self._json(500, {"error": f"{type(exc).__name__}: {exc}"})
def do_GET(self) -> None: # noqa: N802
self._dispatch("GET")
def do_POST(self) -> None: # noqa: N802
self._dispatch("POST")