Add device lock support and demo mode

Device lock (hardware lock of the DSP, independent of the app lock):
- detect a locked DSP from the 0x2C answer during connect and wait for the code
- unlock with 0x2D, optionally remember the code and unlock automatically
- set a new code (0x2F) from the device settings
- simulator: --lock CODE

Demo mode:
- switch in the settings starts a simulated DSP 204/408 inside the server
- real DSPs are disconnected and greyed out meanwhile and resume afterwards
- demo devices are never saved or exported; sim.py ships with the Pi image and EXEs

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
GivouandClaude Opus 5.5 committed 2026-11-01 21:14:04 +01:00
1 parent fe13f261f7
commit 61400df667
13 files changed
+426 -38

No files matched your search

+93 -6
View File
@@ -21,6 +21,7 @@ import uuid
from pathlib import Path
from urllib.parse import parse_qs, urlsplit
import sim
from dsp import preset, usbhid
from dsp.device import Device
@@ -112,6 +113,10 @@ class App:
self.remote_error = ""
self.locked = False # desktop app window read-only until unlocked with the PIN
self.lang = "" # UI language chosen in the desktop app ("" = not chosen yet, English)
# demo mode: the real DSPs are disconnected and a simulated one runs inside the server
self.demo = {"enabled": False, "model": "408"}
self.demo_server: asyncio.Server | None = None
self.demo_resume: set[str] = set() # real devices to reconnect when the demo ends
# ------------------------------------------------------------ config
@@ -149,13 +154,13 @@ class App:
def export_config(self) -> dict:
"""App backup: devices, PIN (hashed), amplifiers/limiter data, remote access - no logins."""
return {"format": CONFIG_FORMAT, "version": 1, "exported": time.strftime("%Y-%m-%dT%H:%M:%S"),
"devices": [d.config() for d in self.devices.values()], "auth": self.auth,
"devices": [d.config() for d in self.real_devices()], "auth": self.auth,
"limiter": self.limiter, "remote": self.remote}
async def restore_config(self, doc: dict, session: str):
if not isinstance(doc, dict) or doc.get("format") != CONFIG_FORMAT:
raise ValueError("Not a DSP Control settings backup")
for dev in list(self.devices.values()):
for dev in self.real_devices():
await dev.stop()
del self.devices[dev.id]
self.broadcast({"type": "removed", "device": dev.id})
@@ -204,7 +209,7 @@ class App:
def save(self):
sessions = {k: v for k, v in self.sessions.items() if k not in self.app_sessions}
cfg = {"devices": [d.config() for d in self.devices.values()], "auth": self.auth,
cfg = {"devices": [d.config() for d in self.real_devices()], "auth": self.auth,
"sessions": sessions, "limiter": self.limiter, "remote": self.remote, "locked": self.locked}
if self.lang:
cfg["lang"] = self.lang
@@ -216,14 +221,69 @@ class App:
dev = Device(dev_id, d.get("name") or d.get("host") or "DSP (USB)", str(d.get("host") or ""),
int(d.get("port", 9761)), str(d.get("model", "auto")), int(d.get("addr", 1)),
bool(d.get("autoconnect", True)), on_event=self.broadcast,
transport="usb" if usb else "tcp", usb=str(d.get("usb") or ""))
transport="usb" if usb else "tcp", usb=str(d.get("usb") or ""),
lock_code=str(d.get("lock_code") or ""), auto_unlock=bool(d.get("auto_unlock")))
self.devices[dev_id] = dev
if dev.autoconnect:
dev.start()
if self.demo["enabled"]:
self.demo_resume.add(dev_id)
else:
dev.start()
if save:
self.save()
return dev
def real_devices(self) -> list[Device]:
return [d for d in self.devices.values() if not d.demo]
# ------------------------------------------------------------ demo mode
def demo_info(self) -> dict:
return {**self.demo, "error": ""}
async def set_demo(self, body: dict) -> dict:
enabled = bool(body.get("enabled", self.demo["enabled"]))
model = body.get("model") if body.get("model") in ("204", "408") else self.demo["model"]
if self.demo["enabled"] and (not enabled or model != self.demo["model"]):
await self.stop_demo()
self.demo["model"] = model
if enabled and not self.demo["enabled"]:
await self.start_demo()
self.broadcast({"type": "demo", "data": self.demo_info()})
return self.demo_info()
async def start_demo(self):
"""Disconnect the real DSPs and start a simulated one inside this server."""
self.demo_resume = {d.id for d in self.real_devices() if d._want_connected}
for d in self.real_devices():
await d.stop()
model = self.demo["model"]
logging.getLogger("sim").setLevel(logging.WARNING)
dsp = sim.SimDSP(model)
dsp.presets[1] = {**dsp.presets[0], "preset_name": "Demo"}
self.demo_server = await asyncio.start_server(dsp.serve, "127.0.0.1", 0)
port = self.demo_server.sockets[0].getsockname()[1]
dev = Device("demo", f"Demo DSP {model}", "127.0.0.1", port, model, autoconnect=False, on_event=self.broadcast)
dev.demo = True
self.devices[dev.id] = dev
self.demo["enabled"] = True
self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()})
dev.start()
async def stop_demo(self):
dev = self.devices.pop("demo", None)
if dev:
await dev.stop()
self.broadcast({"type": "removed", "device": dev.id})
if self.demo_server:
self.demo_server.close()
self.demo_server = None
self.demo["enabled"] = False
for dev_id in self.demo_resume:
if dev_id in self.devices:
self.devices[dev_id].start()
self.demo_resume = set()
# ------------------------------------------------------------ auth
def set_pin(self, pin: str, save=True):
@@ -356,6 +416,9 @@ class App:
async def shutdown(self):
self.stop_remote()
if self.demo["enabled"]:
self.demo_resume = set()
await self.stop_demo()
for d in self.devices.values():
await d.stop()
@@ -375,6 +438,8 @@ class App:
return [d.snapshot() for d in self.devices.values()]
if path == "/api/devices" and method == "POST":
return self.add_device(body).snapshot()
if path == "/api/demo":
return await self.set_demo(body) if method == "PUT" else self.demo_info()
if path == "/api/usb" and method == "GET":
return await asyncio.to_thread(usbhid.list_devices)
if path == "/api/limiter" and method == "GET":
@@ -389,6 +454,10 @@ class App:
raise KeyError(path)
dev = self.devices[m.group(1)]
action = "/".join(g for g in m.groups()[1:] if g)
if dev.demo and (method in ("DELETE", "PUT") or action in ("unlock", "lockcode")):
raise RuntimeError("Not available for the demo device")
if self.demo["enabled"] and not dev.demo and action == "connect":
raise RuntimeError("Demo mode is on – switch it off to connect the real DSPs")
if method == "DELETE" and not action:
await dev.stop()
del self.devices[dev.id]
@@ -408,6 +477,10 @@ class App:
setattr(dev, k, int(body[k]))
if "autoconnect" in body:
dev.autoconnect = bool(body["autoconnect"])
if "auto_unlock" in body:
dev.auto_unlock = bool(body["auto_unlock"])
if body.get("lock_code") == "":
dev.lock_code, dev.auto_unlock = "", False # forget the remembered code
self.save()
if was_running:
dev.start()
@@ -446,6 +519,19 @@ class App:
if action == "refresh":
await dev.refresh()
return {"ok": True}
if action == "unlock": # hardware lock of the DSP, independent of the app lock
code = str(body.get("code") or "").strip().upper()
ok = await dev.unlock(code)
if ok and body.get("remember"):
dev.lock_code, dev.auto_unlock = code, True
self.save()
self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()})
return {"ok": ok}
if action == "lockcode":
await dev.set_lock_code(body.get("code"))
self.save()
self.broadcast({"type": "device", "device": dev.id, "data": dev.snapshot()})
return {"ok": True}
raise KeyError(path)
# ------------------------------------------------------------ HTTP
@@ -608,7 +694,8 @@ class App:
q: asyncio.Queue = asyncio.Queue()
self.clients.add(q)
try:
hello = {"type": "hello", "devices": [d.snapshot() for d in self.devices.values()], "limiter": self.limiter}
hello = {"type": "hello", "devices": [d.snapshot() for d in self.devices.values()], "limiter": self.limiter,
"demo": self.demo_info()}
writer.write(f"data: {json.dumps(hello)}\n\n".encode())
await writer.drain()
while True: