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

+12 -3
View File
@@ -33,7 +33,14 @@ pi_writer.py → pi_image.py (cloud-init SD card, installs server.py as a system
current view (`mixer`, `channel`, `routing`, `link`, `limiter`, `settings`). Live widgets register in `live` and are current view (`mixer`, `channel`, `routing`, `link`, `limiter`, `settings`). Live widgets register in `live` and are
updated without a full redraw. **All UI text goes through `t("English text", {vars})`**; German lives in updated without a full redraw. **All UI text goes through `t("English text", {vars})`**; German lives in
`static/i18n.js` (`DE`, plus `DE_PATTERNS` for server messages with variables, applied by `trMsg()`). `static/i18n.js` (`DE`, plus `DE_PATTERNS` for server messages with variables, applied by `trMsg()`).
* **`sim.py`** – simulated DSP 204/408 speaking the same protocol (meters, limiter flags, links). Use it for all tests. * **`sim.py`** – simulated DSP 204/408 speaking the same protocol (meters, limiter flags, links, lock code via
`--lock`). Use it for all tests. The server also imports it for the **demo mode** (`App.start_demo`: real
devices are stopped, a `SimDSP` runs on a random localhost port, a `Device` with `demo = True` connects to it;
demo devices are never saved, exported or editable). `sim.py` therefore ships with the Pi image and the EXEs.
* **Device lock** (hardware, unrelated to the app lock) – `Device._wait_for_unlock` holds the init after `0x2C`
reports a lock, tries the remembered code (`lock_code` + `auto_unlock` in `config.json`, clients only see a
boolean) or sets status `locked` and waits for `POST /api/devices/<id>/unlock {code, remember}`.
`POST …/lockcode {code}` sets a new code.
* **`desktop.py`** – starts `server.App` on 127.0.0.1 with a random port in a thread and opens a pywebview window. * **`desktop.py`** – starts `server.App` on 127.0.0.1 with a random port in a thread and opens a pywebview window.
`Api` exposes native file dialogs to the page (`window.pywebview.api.save_file/open_file`). Single instance via a `Api` exposes native file dialogs to the page (`window.pywebview.api.save_file/open_file`). Single instance via a
named mutex (Windows) or lock file (macOS). Data in `%APPDATA%\DSP Control` / `~/Library/Application Support/DSP Control`. named mutex (Windows) or lock file (macOS). Data in `%APPDATA%\DSP Control` / `~/Library/Application Support/DSP Control`.
@@ -77,8 +84,10 @@ Not verified yet – ask for a log (`python server.py -v`) from real hardware be
* **DSP 408 on real hardware** (layout and frames match published captures, limiter bits for Out 5–8 assumed) * **DSP 408 on real hardware** (layout and frames match published captures, limiter bits for Out 5–8 assumed)
* USB on Windows and Linux against a real DSP (only tested against a fake HID device) * USB on Windows and Linux against a real DSP (only tested against a fake HID device)
* Where the PEQ bypass flag lives in the memory image; format of the set-command acknowledgement; payload of the * Where the PEQ bypass flag lives in the memory image; format of the set-command acknowledgement; where the number
preset-count answer (`0x2C`) of preset slots comes from (20 is assumed when the `0x2C` answer carries the lock state)
* Device lock (`0x2C` byte 5, `0x2D`, `0x2F`, `0x11`) – implemented from the control software's behaviour and
tested against the simulator only; no command to remove a lock is known
* Limiter calculator reference level (assumes limiter 0 dB = 0 dBu at the output; adjustable per device) * Limiter calculator reference level (assumes limiter 0 dB = 0 dBu at the output; adjustable per device)
* Pi Writer: raw write to a real SD card and first boot on a real Pi (only tested with an image file) * Pi Writer: raw write to a real SD card and first boot on a real Pi (only tested with an image file)
+18 -1
View File
@@ -36,7 +36,7 @@ All 16-bit words are little endian.
|-----|-----------|---------|---------| |-----|-----------|---------|---------|
| `10` | → | – | Handshake | | `10` | → | – | Handshake |
| `13` | → / ← | – / ASCII | Device info, answer starts with `DSP204` or `DSP408` | | `13` | → / ← | – / ASCII | Device info, answer starts with `DSP204` or `DSP408` |
| `2C` | → / ← | – / `[?][count]` | Number of presets (payload meaning partly *assumed*) | | `2C` | → / ← | – / `[time lock][4 bytes][device lock]` | Lock state, see [Device lock](#device-lock) |
| `22`, `14` | → | – | Init queries (sent during connect, content unknown) | | `22`, `14` | → | – | Init queries (sent during connect, content unknown) |
| `29` | → / ← | `[idx]` / `[idx][name…]` | Preset name (idx 0-based) | | `29` | → / ← | `[idx]` / `[idx][name…]` | Preset name (idx 0-based) |
| `20` | → | `[idx+1]` | Recall preset | | `20` | → | `[idx+1]` | Recall preset |
@@ -45,6 +45,9 @@ All 16-bit words are little endian.
| `27` | → | `[chunk]` | Request config chunk | | `27` | → | `[chunk]` | Request config chunk |
| `24` | ← | `[chunk][50 bytes]` | Config chunk; 204: chunks 0…14, 408: 0…28 | | `24` | ← | `[chunk][50 bytes]` | Config chunk; 204: chunks 0…14, 408: 0…28 |
| `12` | → | – | Status (sent after the dump) | | `12` | → | – | Status (sent after the dump) |
| `2D` | → / ← | `[0][code 4]` / `[0][result]` | Unlock with the lock code, result `1` = unlocked, `0` = wrong code |
| `2F` | → | `[code 4]` | Set a new lock code |
| `11` | → | – | Sent after setting a lock code (meaning not fully known) |
| `40` | → / ← | – / meters | Read levels (also serves as keepalive) | | `40` | → / ← | – / meters | Read levels (also serves as keepalive) |
### Meter answer ### Meter answer
@@ -126,6 +129,20 @@ or within the outputs):
* A member with mask `00` that is not part of a group ignores changes: when unlinking, give every channel its own * A member with mask `00` that is not part of a group ignores changes: when unlinking, give every channel its own
bit again. bit again.
## Device lock
The DSP can be protected with a 4-character code (digits and upper-case letters, e.g. `A1BA`, sent as ASCII).
* During connect, the answer to `2C` reports the lock state: byte 5 ≠ 0 means the device is locked. Byte 0 and
bytes 1–4 belong to a separate time-based lock that this app does not use.
* A locked device waits for `2D [00][code]` before the rest of the initialisation (`22`, `14`, preset names, dump).
The answer `2D [00][01]` means unlocked, `2D [00][00]` wrong code.
* `2F [code]` stores a new code; the control software sends `11` afterwards. The device asks for the new code from
the next connection on. A command to remove the lock is not known.
Status: derived from the behaviour of the control software and implemented against the simulator; **not yet
verified on a real device**.
## Config dump = memory image ## Config dump = memory image
Chunk `n` carries bytes `n·50 … n·50+49` of the device memory image. Chunk `n` carries bytes `n·50 … n·50+49` of the device memory image.
+6 -1
View File
@@ -29,6 +29,10 @@ Control both devices at the same time from your phone, tablet or computer – ov
outputs, and see the resulting power when the limiter engages, the clipping headroom and the speaker load. outputs, and see the resulting power when the limiter engages, the clipping headroom and the speaker load.
"Limit to … W" calculates the threshold. Attack/release presets per band (infra, sub, kick, mid, high) "Limit to … W" calculates the threshold. Attack/release presets per band (infra, sub, kick, mid, high)
* **Settings backup** – devices, amplifier data, PIN and remote access in one file * **Settings backup** – devices, amplifier data, PIN and remote access in one file
* **Device lock** – DSPs locked with their 4-character code (e.g. `A1BA`) are detected on connect and the app asks
for the code; optionally it remembers the code and unlocks automatically. A new code can be set under ⚙
* **Demo mode** – one switch under ⚙ starts a simulated DSP 204 or 408 inside the app to try everything; the real
DSPs are disconnected meanwhile and nothing is sent to them
* **Many phones at once** – every change is pushed live to all connected clients * **Many phones at once** – every change is pushed live to all connected clients
* Tap a value to type it in (`-3.5`, `1.2k`, delay in metres `2.5m`); faders snap at 0 dB, double-tap = 0 dB * Tap a value to type it in (`-3.5`, `1.2k`, delay in metres `2.5m`); faders snap at 0 dB, double-tap = 0 dB
@@ -117,7 +121,8 @@ DSPs on USB, pick the right one in the drop-down.
## Testing without hardware ## Testing without hardware
A simulator emulates both models: The quickest way is the **demo mode** (⚙ → Demo mode). For development, a stand-alone simulator emulates both
models (`--lock A1BA` makes it ask for a lock code):
```bash ```bash
python sim.py --model 204 --port 9761 python sim.py --model 204 --port 9761
+67 -7
View File
@@ -20,7 +20,8 @@ LINK_RESYNC_DELAY = 1.5 # re-read the config this long after the last change on
class Device: class Device:
def __init__(self, dev_id: str, name: str, host: str, port: int = P.PORT, model: str = "auto", def __init__(self, dev_id: str, name: str, host: str, port: int = P.PORT, model: str = "auto",
addr: int = 1, autoconnect: bool = True, on_event=None, transport: str = "tcp", usb: str = ""): addr: int = 1, autoconnect: bool = True, on_event=None, transport: str = "tcp", usb: str = "",
lock_code: str = "", auto_unlock: bool = False):
self.id = dev_id self.id = dev_id
self.name = name self.name = name
self.host = host self.host = host
@@ -31,8 +32,12 @@ class Device:
self.transport = "usb" if transport == "usb" else "tcp" self.transport = "usb" if transport == "usb" else "tcp"
self.usb = usb # HID device path, "" = first DSP found self.usb = usb # HID device path, "" = first DSP found
self.on_event = on_event or (lambda ev: None) self.on_event = on_event or (lambda ev: None)
# hardware lock of the DSP itself (not the app lock): remembered code for automatic unlocking
self.lock_code = lock_code if P.LOCK_CODE.fullmatch(lock_code or "") else ""
self.auto_unlock = auto_unlock
self.demo = False # in-process simulator of the demo mode, never saved
self.status = "disconnected" # disconnected | connecting | loading | online | error self.status = "disconnected" # disconnected | connecting | loading | locked | online | error
self.error = "" self.error = ""
self.info = "" self.info = ""
self.model: P.Model | None = P.MODELS.get(model) self.model: P.Model | None = P.MODELS.get(model)
@@ -53,16 +58,20 @@ class Device:
self._want_connected = False self._want_connected = False
self._resync: asyncio.TimerHandle | None = None self._resync: asyncio.TimerHandle | None = None
self._changes = 0 # bumped on every local change, so a resync never overwrites newer edits self._changes = 0 # bumped on every local change, so a resync never overwrites newer edits
self._codes: asyncio.Queue | None = None # (code, future) entered while the DSP is locked
# ------------------------------------------------------------ public API # ------------------------------------------------------------ public API
def config(self) -> dict: def config(self) -> dict:
return {"id": self.id, "name": self.name, "host": self.host, "port": self.port, return {"id": self.id, "name": self.name, "host": self.host, "port": self.port,
"model": self.model_key, "addr": self.addr, "autoconnect": self.autoconnect, "model": self.model_key, "addr": self.addr, "autoconnect": self.autoconnect,
"transport": self.transport, "usb": self.usb} "transport": self.transport, "usb": self.usb,
"lock_code": self.lock_code, "auto_unlock": self.auto_unlock}
def snapshot(self) -> dict: def snapshot(self) -> dict:
return {**self.config(), "status": self.status, "error": self.error, "info": self.info, cfg = self.config()
cfg["lock_code"] = bool(self.lock_code) # clients only learn whether a code is remembered
return {**cfg, "demo": self.demo, "status": self.status, "error": self.error, "info": self.info,
"detected_model": self.model_name or None, "detected_model": self.model_name or None,
"n_in": self.model.n_in if self.model else 0, "n_in": self.model.n_in if self.model else 0,
"n_out": self.model.n_out if self.model else 0, "n_out": self.model.n_out if self.model else 0,
@@ -75,8 +84,6 @@ class Device:
async def stop(self): async def stop(self):
self._want_connected = False self._want_connected = False
self._resync: asyncio.TimerHandle | None = None
self._changes = 0 # bumped on every local change, so a resync never overwrites newer edits
if self._supervisor: if self._supervisor:
self._supervisor.cancel() self._supervisor.cancel()
try: try:
@@ -121,6 +128,29 @@ class Device:
await asyncio.sleep(0.3) await asyncio.sleep(0.3)
await self.refresh() await self.refresh()
async def unlock(self, code: str) -> bool:
"""Try a lock code while the DSP waits for it. True if the DSP accepted it."""
code = str(code or "").strip().upper()
if not P.LOCK_CODE.fullmatch(code):
raise ValueError("The code has 4 characters: digits and letters A–Z")
if self.status != "locked" or not self._codes:
raise RuntimeError("The DSP is not locked")
fut = asyncio.get_running_loop().create_future()
await self._codes.put((code, fut))
return await fut
async def set_lock_code(self, code: str):
"""Store a new lock code in the DSP; it asks for it from the next connection on."""
code = str(code or "").strip().upper()
if not P.LOCK_CODE.fullmatch(code):
raise ValueError("The code has 4 characters: digits and letters A–Z")
if self.status != "online":
raise RuntimeError("DSP is not connected")
if self.lock_code: # keep auto-unlock working with the new code
self.lock_code = code
await self._request(P.CMD_SET_LOCK_CODE, code.encode("ascii"))
await self._request(P.CMD_LOGOUT) # as the original software does after setting the code
def _schedule_resync(self): def _schedule_resync(self):
"""Re-read the config shortly after edits on linked channels, so the app shows exactly """Re-read the config shortly after edits on linked channels, so the app shows exactly
what the DSP applied to the group (e.g. mute, which we don't mirror for certain).""" what the DSP applied to the group (e.g. mute, which we don't mirror for certain)."""
@@ -293,8 +323,11 @@ class Device:
if detected and detected != self.model_key: if detected and detected != self.model_key:
log.warning("%s: configured as %s but device reports %s", self.name, self.model_key, self.info) log.warning("%s: configured as %s but device reports %s", self.name, self.model_key, self.info)
count_frame = await self._request(P.CMD_PRESET_COUNT, expect=P.CMD_PRESET_COUNT) count_frame = await self._request(P.CMD_PRESET_COUNT, expect=P.CMD_PRESET_COUNT)
count = count_frame.payload[-1] if count_frame and count_frame.payload else 20 payload = count_frame.payload if count_frame else b""
count = payload[-1] if 0 < len(payload) < 6 else 20 # the long answer carries the lock state instead
count = count if 0 < count <= 60 else 20 count = count if 0 < count <= 60 else 20
if P.device_locked(payload):
await self._wait_for_unlock()
await self._request(P.CMD_INIT_22) await self._request(P.CMD_INIT_22)
await self._request(P.CMD_INIT_14) await self._request(P.CMD_INIT_14)
presets = [] presets = []
@@ -304,6 +337,33 @@ class Device:
self.presets = presets self.presets = presets
await self._load_config() await self._load_config()
async def _try_code(self, code: str) -> bool:
f = await self._request(P.CMD_UNLOCK, b"\x00" + code.encode("ascii"), timeout=2.0, expect=P.CMD_UNLOCK)
return bool(f and len(f.payload) > 1 and f.payload[1] == 1)
async def _wait_for_unlock(self):
"""The DSP is locked with its code: unlock automatically or wait until a code is entered."""
if self.auto_unlock and self.lock_code:
if await self._try_code(self.lock_code):
log.info("%s: unlocked automatically", self.name)
return
log.warning("%s: remembered lock code was rejected", self.name)
self.error = "The remembered lock code was rejected"
self._codes = asyncio.Queue()
self._set_status("locked")
try:
while True:
code, fut = await self._codes.get()
ok = await self._try_code(code)
if not fut.done():
fut.set_result(ok)
if ok:
self.error = ""
self._set_status("loading")
return
finally:
self._codes = None
async def _load_config(self): async def _load_config(self):
self.state = await self._read_config() self.state = await self._read_config()
+11 -1
View File
@@ -2,6 +2,7 @@
import copy import copy
import math import math
import re
import struct import struct
from dataclasses import dataclass from dataclasses import dataclass
@@ -10,6 +11,7 @@ PORT = 9761
# Read / system commands # Read / system commands
CMD_ACK = 0x01 CMD_ACK = 0x01
CMD_HANDSHAKE = 0x10 CMD_HANDSHAKE = 0x10
CMD_LOGOUT = 0x11 # sent after setting a lock code
CMD_STATUS = 0x12 CMD_STATUS = 0x12
CMD_DEVICE_INFO = 0x13 CMD_DEVICE_INFO = 0x13
CMD_INIT_14 = 0x14 CMD_INIT_14 = 0x14
@@ -20,7 +22,9 @@ CMD_CONFIG_CHUNK = 0x24
CMD_PRESET_STORE_NAME = 0x26 CMD_PRESET_STORE_NAME = 0x26
CMD_CONFIG_REQUEST = 0x27 CMD_CONFIG_REQUEST = 0x27
CMD_PRESET_NAME = 0x29 CMD_PRESET_NAME = 0x29
CMD_PRESET_COUNT = 0x2C CMD_PRESET_COUNT = 0x2C # answer: [time lock][4 bytes time lock data][device lock] (see device_locked)
CMD_UNLOCK = 0x2D # [0][code 4] -> answer [0][1 = unlocked, 0 = wrong code]
CMD_SET_LOCK_CODE = 0x2F # [code 4]
CMD_METER = 0x40 CMD_METER = 0x40
# Parameter commands # Parameter commands
@@ -41,6 +45,12 @@ CMD_GEQ = 0x48
CMD_LINK = 0x3B # [ch][u16 link mask], see link_masks() CMD_LINK = 0x3B # [ch][u16 link mask], see link_masks()
CHUNK_SIZE = 50 CHUNK_SIZE = 50
LOCK_CODE = re.compile(r"[A-Z0-9]{4}") # device lock code: 4 characters, digits and upper-case letters
def device_locked(count_payload: bytes) -> bool:
"""True if the answer to CMD_PRESET_COUNT says the DSP waits for its lock code."""
return len(count_payload) > 5 and count_payload[5] != 0
def checksum(data: bytes) -> int: def checksum(data: bytes) -> int:
+1 -1
View File
@@ -58,6 +58,6 @@ pyinstaller("--name", "DSP Control", "--icon", str(ROOT / "packaging" / "dsp-con
*data("static", "static"), str(ROOT / "desktop.py")) *data("static", "static"), str(ROOT / "desktop.py"))
pyinstaller("--name", "DSP Control Pi Writer", "--icon", str(ROOT / "packaging" / "pi-writer.ico"), "--uac-admin", pyinstaller("--name", "DSP Control Pi Writer", "--icon", str(ROOT / "packaging" / "pi-writer.ico"), "--uac-admin",
*data("server.py"), *data("dsp", "dsp"), *data("static", "static"), str(ROOT / "pi_writer.py")) *data("server.py"), *data("sim.py"), *data("dsp", "dsp"), *data("static", "static"), str(ROOT / "pi_writer.py"))
print("\nDone:", *(p.name for p in (ROOT / "dist").glob("*.exe")), sep="\n ") print("\nDone:", *(p.name for p in (ROOT / "dist").glob("*.exe")), sep="\n ")
+1 -1
View File
@@ -19,7 +19,7 @@ import server
OS_LIST_URL = "https://downloads.raspberrypi.com/os_list_imagingutility_v4.json" OS_LIST_URL = "https://downloads.raspberrypi.com/os_list_imagingutility_v4.json"
IMAGE_NAMES = {64: "Raspberry Pi OS Lite (64-bit)", 32: "Raspberry Pi OS Lite (32-bit)"} IMAGE_NAMES = {64: "Raspberry Pi OS Lite (64-bit)", 32: "Raspberry Pi OS Lite (32-bit)"}
APP_FILES = ["server.py", "dsp", "static"] # what gets installed on the Pi APP_FILES = ["server.py", "sim.py", "dsp", "static"] # what gets installed on the Pi
USER_AGENT = "DSP-Control-Pi-Writer/1.0" USER_AGENT = "DSP-Control-Pi-Writer/1.0"
# Pi models offered in the writer: (name, description, os bits) # Pi models offered in the writer: (name, description, os bits)
+93 -6
View File
@@ -21,6 +21,7 @@ import uuid
from pathlib import Path from pathlib import Path
from urllib.parse import parse_qs, urlsplit from urllib.parse import parse_qs, urlsplit
import sim
from dsp import preset, usbhid from dsp import preset, usbhid
from dsp.device import Device from dsp.device import Device
@@ -112,6 +113,10 @@ class App:
self.remote_error = "" self.remote_error = ""
self.locked = False # desktop app window read-only until unlocked with the PIN 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) 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 # ------------------------------------------------------------ config
@@ -149,13 +154,13 @@ class App:
def export_config(self) -> dict: def export_config(self) -> dict:
"""App backup: devices, PIN (hashed), amplifiers/limiter data, remote access - no logins.""" """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"), 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} "limiter": self.limiter, "remote": self.remote}
async def restore_config(self, doc: dict, session: str): async def restore_config(self, doc: dict, session: str):
if not isinstance(doc, dict) or doc.get("format") != CONFIG_FORMAT: if not isinstance(doc, dict) or doc.get("format") != CONFIG_FORMAT:
raise ValueError("Not a DSP Control settings backup") raise ValueError("Not a DSP Control settings backup")
for dev in list(self.devices.values()): for dev in self.real_devices():
await dev.stop() await dev.stop()
del self.devices[dev.id] del self.devices[dev.id]
self.broadcast({"type": "removed", "device": dev.id}) self.broadcast({"type": "removed", "device": dev.id})
@@ -204,7 +209,7 @@ class App:
def save(self): def save(self):
sessions = {k: v for k, v in self.sessions.items() if k not in self.app_sessions} 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} "sessions": sessions, "limiter": self.limiter, "remote": self.remote, "locked": self.locked}
if self.lang: if self.lang:
cfg["lang"] = 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 ""), 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)), int(d.get("port", 9761)), str(d.get("model", "auto")), int(d.get("addr", 1)),
bool(d.get("autoconnect", True)), on_event=self.broadcast, 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 self.devices[dev_id] = dev
if dev.autoconnect: if dev.autoconnect:
dev.start() if self.demo["enabled"]:
self.demo_resume.add(dev_id)
else:
dev.start()
if save: if save:
self.save() self.save()
return dev 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 # ------------------------------------------------------------ auth
def set_pin(self, pin: str, save=True): def set_pin(self, pin: str, save=True):
@@ -356,6 +416,9 @@ class App:
async def shutdown(self): async def shutdown(self):
self.stop_remote() self.stop_remote()
if self.demo["enabled"]:
self.demo_resume = set()
await self.stop_demo()
for d in self.devices.values(): for d in self.devices.values():
await d.stop() await d.stop()
@@ -375,6 +438,8 @@ class App:
return [d.snapshot() for d in self.devices.values()] return [d.snapshot() for d in self.devices.values()]
if path == "/api/devices" and method == "POST": if path == "/api/devices" and method == "POST":
return self.add_device(body).snapshot() 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": if path == "/api/usb" and method == "GET":
return await asyncio.to_thread(usbhid.list_devices) return await asyncio.to_thread(usbhid.list_devices)
if path == "/api/limiter" and method == "GET": if path == "/api/limiter" and method == "GET":
@@ -389,6 +454,10 @@ class App:
raise KeyError(path) raise KeyError(path)
dev = self.devices[m.group(1)] dev = self.devices[m.group(1)]
action = "/".join(g for g in m.groups()[1:] if g) 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: if method == "DELETE" and not action:
await dev.stop() await dev.stop()
del self.devices[dev.id] del self.devices[dev.id]
@@ -408,6 +477,10 @@ class App:
setattr(dev, k, int(body[k])) setattr(dev, k, int(body[k]))
if "autoconnect" in body: if "autoconnect" in body:
dev.autoconnect = bool(body["autoconnect"]) 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() self.save()
if was_running: if was_running:
dev.start() dev.start()
@@ -446,6 +519,19 @@ class App:
if action == "refresh": if action == "refresh":
await dev.refresh() await dev.refresh()
return {"ok": True} 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) raise KeyError(path)
# ------------------------------------------------------------ HTTP # ------------------------------------------------------------ HTTP
@@ -608,7 +694,8 @@ class App:
q: asyncio.Queue = asyncio.Queue() q: asyncio.Queue = asyncio.Queue()
self.clients.add(q) self.clients.add(q)
try: 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()) writer.write(f"data: {json.dumps(hello)}\n\n".encode())
await writer.drain() await writer.drain()
while True: while True:
+16 -3
View File
@@ -2,6 +2,7 @@
Usage: python sim.py --model 204 --port 9761 Usage: python sim.py --model 204 --port 9761
python sim.py --model 408 --port 9762 python sim.py --model 408 --port 9762
python sim.py --model 204 --port 9761 --lock A1BA (asks for that lock code on every connection)
""" """
import argparse import argparse
@@ -17,8 +18,10 @@ log = logging.getLogger("sim")
class SimDSP: class SimDSP:
def __init__(self, model_key: str): def __init__(self, model_key: str, lock_code: str = ""):
self.key = model_key self.key = model_key
self.lock_code = lock_code # hardware lock: "" = none
self.unlocked = not lock_code
self.model = P.MODELS[model_key] self.model = P.MODELS[model_key]
self.state = P.default_state(self.model) self.state = P.default_state(self.model)
self.presets = [copy.deepcopy(self.state) if i == 0 else None for i in range(20)] self.presets = [copy.deepcopy(self.state) if i == 0 else None for i in range(20)]
@@ -33,7 +36,15 @@ class SimDSP:
if cmd == P.CMD_DEVICE_INFO: if cmd == P.CMD_DEVICE_INFO:
return cmd, f"DSP{self.key} V010 SIM".encode() return cmd, f"DSP{self.key} V010 SIM".encode()
if cmd == P.CMD_PRESET_COUNT: if cmd == P.CMD_PRESET_COUNT:
return cmd, bytes([0, len(self.presets)]) return cmd, bytes([0, 0, 0, 0, 0, 0 if self.unlocked else 1])
if cmd == P.CMD_UNLOCK:
self.unlocked = self.unlocked or p[1:5].decode("latin1") == self.lock_code
return cmd, bytes([0, 1 if self.unlocked else 0])
if cmd == P.CMD_SET_LOCK_CODE:
self.lock_code = p[:4].decode("latin1")
return P.CMD_ACK, b"\x00"
if not self.unlocked and cmd not in (P.CMD_HANDSHAKE, P.CMD_METER, P.CMD_LOGOUT):
return P.CMD_ACK, b"\x00" # locked: ignores everything until the code was entered
if cmd == P.CMD_PRESET_NAME: if cmd == P.CMD_PRESET_NAME:
return cmd, bytes([p[0]]) + self.preset_names()[p[0]].encode("latin1").ljust(14, b" ") return cmd, bytes([p[0]]) + self.preset_names()[p[0]].encode("latin1").ljust(14, b" ")
if cmd == P.CMD_CONFIG_REQUEST: if cmd == P.CMD_CONFIG_REQUEST:
@@ -72,6 +83,7 @@ class SimDSP:
async def serve(self, reader, writer): async def serve(self, reader, writer):
peer = writer.get_extra_info("peername") peer = writer.get_extra_info("peername")
log.info("client %s connected", peer) log.info("client %s connected", peer)
self.unlocked = not self.lock_code
parser = P.FrameParser() parser = P.FrameParser()
try: try:
while data := await reader.read(4096): while data := await reader.read(4096):
@@ -92,9 +104,10 @@ async def main():
ap.add_argument("--model", choices=list(P.MODELS), default="204") ap.add_argument("--model", choices=list(P.MODELS), default="204")
ap.add_argument("--port", type=int, default=P.PORT) ap.add_argument("--port", type=int, default=P.PORT)
ap.add_argument("--host", default="127.0.0.1") ap.add_argument("--host", default="127.0.0.1")
ap.add_argument("--lock", default="", help="lock code (4 characters A-Z/0-9) the DSP asks for")
args = ap.parse_args() args = ap.parse_args()
logging.basicConfig(level=logging.INFO, format=f"%(asctime)s sim{args.model} %(message)s") logging.basicConfig(level=logging.INFO, format=f"%(asctime)s sim{args.model} %(message)s")
sim = SimDSP(args.model) sim = SimDSP(args.model, args.lock.upper())
server = await asyncio.start_server(sim.serve, args.host, args.port) server = await asyncio.start_server(sim.serve, args.host, args.port)
log.info("simulated DSP %s on %s:%d", args.model, args.host, args.port) log.info("simulated DSP %s on %s:%d", args.model, args.host, args.port)
async with server: async with server:
+129 -13
View File
@@ -60,6 +60,7 @@ const S = {
sel: { kind: "in", idx: 0 }, band: 0, busy: false, dirty: false, sel: { kind: "in", idx: 0 }, band: 0, busy: false, dirty: false,
routeOpen: null, es: null, linkSel: { in: [], out: [] }, routeOpen: null, es: null, linkSel: { in: [], out: [] },
lim: { amps: [], assign: {}, ref: {} }, lim: { amps: [], assign: {}, ref: {} },
demo: { enabled: false, model: "408" },
}; };
const $ = sel => document.querySelector(sel); const $ = sel => document.querySelector(sel);
const main = $("#main"); const main = $("#main");
@@ -510,19 +511,116 @@ requestAnimationFrame(meterFrame);
function renderTabs() { function renderTabs() {
const tabs = $("#devtabs"); const tabs = $("#devtabs");
tabs.replaceChildren(...S.order.map(id => { const order = [...S.order].sort((a, b) => !!S.devices[b].demo - !!S.devices[a].demo); // demo tab first
tabs.replaceChildren(...order.map(id => {
const d = S.devices[id]; const d = S.devices[id];
const model = d.detected_model || (d.model !== "auto" ? d.model : ""); const model = d.detected_model || (d.model !== "auto" ? d.model : "");
return h("button", { class: "devtab" + (id === S.cur && !S.settings ? " active" : ""), title: `${d.name} · ${where(d)}`, const paused = S.demo.enabled && !d.demo; // demo mode: the real DSPs are disconnected
onclick: () => { S.cur = id; S.settings = false; store.set("dsp.cur", id); render(); } }, return h("button", { class: "devtab" + (id === S.cur && !S.settings ? " active" : "") + (paused ? " paused" : "") + (d.demo ? " demo" : ""),
h("span", { class: "dot " + d.status }), h("span", { class: "dn" }, d.name), model ? h("small", {}, model) : null); title: paused ? t("Disconnected while demo mode is on") : d.demo ? t("Demo mode – simulated DSP") : `${d.name} · ${where(d)}`,
disabled: paused, onclick: () => { S.cur = id; S.settings = false; store.set("dsp.cur", id); render(); } },
h("span", { class: "dot " + d.status }), h("span", { class: "dn" }, d.name),
d.demo ? h("small", { class: "demo-badge" }, "DEMO") : model ? h("small", {}, model) : null);
})); }));
$("#btn-settings").classList.toggle("on", S.settings); $("#btn-settings").classList.toggle("on", S.settings);
document.querySelectorAll("#viewtabs button").forEach(b => b.classList.toggle("active", !S.settings && b.dataset.view === S.view)); document.querySelectorAll("#viewtabs button").forEach(b => b.classList.toggle("active", !S.settings && b.dataset.view === S.view));
} }
const STATUS_TEXT = { disconnected: t("Disconnected"), connecting: t("Connecting…"), loading: t("Loading configuration…"), const STATUS_TEXT = { disconnected: t("Disconnected"), connecting: t("Connecting…"), loading: t("Loading configuration…"),
online: "Online", error: t("Error") }; locked: t("Locked with a code"), online: "Online", error: t("Error") };
// ------------------------------------------------------------------ hardware lock of the DSP (not the app lock)
const LOCK_RE = /^[A-Z0-9]{4}$/;
const codeInput = () => {
const el = h("input", { type: "text", maxlength: 4, autocomplete: "off", autocapitalize: "characters", spellcheck: "false",
class: "code", placeholder: "A1B2", "aria-label": t("Lock code") });
el.addEventListener("input", () => { el.value = el.value.toUpperCase().replace(/[^A-Z0-9]/g, "").slice(0, 4); });
return el;
};
async function unlockDialog(d) {
let error = "";
for (;;) {
const code = codeInput();
const remember = h("input", { type: "checkbox", checked: !!d.auto_unlock || !d.lock_code });
const res = await modal({
title: t("DSP locked"),
body: h("div", {},
h("p", { class: "dlg-text" }, t("{name} is locked with a code. Enter the 4-character code (digits and letters A–Z).", { name: q(d.name) })),
code,
error ? h("div", { class: "err" }, error) : null,
h("label", { class: "chk" }, remember, t("Remember the code and unlock automatically"))),
actions: [{ label: t("Cancel") },
{ label: t("Unlock"), primary: true, value: () => LOCK_RE.test(code.value) ? { code: code.value, remember: remember.checked } : (code.focus(), undefined) }],
});
if (!res) return false;
try {
const r = await api("POST", `/api/devices/${d.id}/unlock`, res);
if (r.ok) { toast(t("DSP unlocked")); return true; }
error = t("Wrong code – please try again.");
} catch (e) { error = trMsg(e.message); }
}
}
// ask once per lock episode when the DSP on screen turns out to be locked
const lockAsked = new Set();
function maybeAskUnlock(d) {
if (d.status !== "locked") { lockAsked.delete(d.id); return; }
if (lockAsked.has(d.id) || d.id !== S.cur || S.settings || S.locked) return;
lockAsked.add(d.id);
setTimeout(() => unlockDialog(S.devices[d.id] || d), 50);
}
const lockOpen = new Set(); // device ids whose lock section is open (survives re-rendering)
function lockSection(d) {
const online = d.status === "online";
const auto = h("input", { type: "checkbox", checked: !!d.auto_unlock, disabled: !d.lock_code,
onchange: () => api("PUT", `/api/devices/${d.id}`, { auto_unlock: auto.checked }).catch(e => toast(e.message)) });
const code = codeInput();
const setCode = async () => {
if (!LOCK_RE.test(code.value)) { code.focus(); return toast(t("The code has 4 characters: digits and letters A–Z")); }
if (!await askConfirm(t("Set lock code"), t("From the next connection on, {name} asks for the code {code} – also in the original software. Note it down: this app cannot remove the lock again.",
{ name: q(d.name), code: code.value }), t("Set code"), true)) return;
try { await api("POST", `/api/devices/${d.id}/lockcode`, { code: code.value }); toast(t("Lock code set")); }
catch (e) { toast(t("Error: ") + trMsg(e.message)); }
};
const box = h("details", { class: "more full lockbox", open: lockOpen.has(d.id),
ontoggle: () => box.open ? lockOpen.add(d.id) : lockOpen.delete(d.id) },
h("summary", {}, t("Device lock (code)"), d.lock_code ? h("span", { class: "tag" }, t("code remembered")) : null),
h("p", { class: "info" }, t("Hardware lock of the DSP: a locked DSP only accepts a connection after its code was entered. Independent of the lock of this app.")),
h("label", { class: "chk" }, auto, t("Unlock automatically with the remembered code")),
d.lock_code
? h("div", { class: "row" }, h("span", { class: "grow info" }, t("A code is remembered for this DSP.")),
h("button", { class: "small", onclick: () => api("PUT", `/api/devices/${d.id}`, { lock_code: "" }).then(() => toast(t("Code forgotten"))).catch(e => toast(e.message)) }, t("Forget code")))
: h("div", { class: "info" }, t("No code remembered – it is asked for when the DSP is locked.")),
h("div", { class: "sub" }, t("Set a new lock code")),
h("div", { class: "row" }, code, h("button", { class: "small", disabled: !online, onclick: setCode }, t("Set code"))),
online ? null : h("div", { class: "info" }, t("Connect the DSP to set a code.")));
return box;
}
// ------------------------------------------------------------------ demo mode
async function setDemo(body) {
try {
S.demo = await api("PUT", "/api/demo", body);
if (S.demo.enabled) { S.cur = "demo"; S.settings = false; S.view = "mixer"; }
render();
} catch (e) { toast(t("Error: ") + trMsg(e.message)); }
}
function demoCard() {
const on = S.demo.enabled;
return h("div", { class: "card" + (on ? " demo-on" : "") },
h("h3", {}, h("span", { class: "grow" }, t("Demo mode")), on ? h("span", { class: "demo-badge" }, "DEMO") : null),
h("p", { class: "info" }, t("Try everything with a simulated DSP – nothing is sent to real devices. While demo mode is on, the real DSPs are disconnected.")),
h("div", { class: "row" },
h("div", { class: "seg grow" }, [[false, t("Off")], [true, t("On")]].map(([v, label]) =>
h("button", { class: v === on ? "on" : "", "aria-pressed": String(v === on), onclick: () => v !== on && setDemo({ enabled: v }) }, label))),
h("div", { class: "seg" }, ["204", "408"].map(m =>
h("button", { class: m === S.demo.model ? "on" : "", onclick: () => m !== S.demo.model && setDemo({ model: m }) }, "DSP " + m)))));
}
async function storePresetDialog(d) { async function storePresetDialog(d) {
const slot = h("select", {}, d.presets.map((p, i) => h("option", { value: i }, `U${String(i + 1).padStart(2, "0")} ${p || t("— empty —")}`))); const slot = h("select", {}, d.presets.map((p, i) => h("option", { value: i }, `U${String(i + 1).padStart(2, "0")} ${p || t("— empty —")}`)));
@@ -603,8 +701,11 @@ function renderStatus() {
bar.replaceChildren( bar.replaceChildren(
h("div", { class: "preset" }, h("small", {}, `${STATUS_TEXT[d.status] || d.status} · ${d.transport === "usb" ? "USB" : d.host + ":" + d.port}`), h("b", {}, d.name), h("div", { class: "preset" }, h("small", {}, `${STATUS_TEXT[d.status] || d.status} · ${d.transport === "usb" ? "USB" : d.host + ":" + d.port}`), h("b", {}, d.name),
d.error ? h("div", { class: "err" }, trMsg(d.error)) : null), d.error ? h("div", { class: "err" }, trMsg(d.error)) : null),
d.status === "disconnected" || d.status === "error" d.status === "locked"
? h("button", { class: "on", onclick: () => api("POST", `/api/devices/${d.id}/connect`).catch(e => toast(e.message)) }, t("Connect")) ? h("div", { class: "presetrow" }, h("button", { class: "on", onclick: () => unlockDialog(d) }, t("Enter code")),
h("button", { onclick: () => api("POST", `/api/devices/${d.id}/disconnect`) }, t("Disconnect")))
: d.status === "disconnected" || d.status === "error"
? h("button", { class: "on", disabled: S.demo.enabled && !d.demo, onclick: () => api("POST", `/api/devices/${d.id}/connect`).catch(e => toast(trMsg(e.message))) }, t("Connect"))
: h("button", { onclick: () => api("POST", `/api/devices/${d.id}/disconnect`) }, t("Cancel"))); : h("button", { onclick: () => api("POST", `/api/devices/${d.id}/disconnect`) }, t("Cancel")));
return; return;
} }
@@ -622,7 +723,7 @@ function renderStatus() {
presetSel.disabled = false; presetSel.disabled = false;
}); });
bar.replaceChildren( bar.replaceChildren(
h("div", { class: "preset" }, h("small", {}, `${d.info || d.name} · ${where(d)}`), h("b", {}, d.state.preset_name || "—")), h("div", { class: "preset" }, h("small", {}, d.demo ? t("Demo mode · simulated DSP") : `${d.info || d.name} · ${where(d)}`), h("b", {}, d.state.preset_name || "—")),
h("div", { class: "presetrow" }, presetSel, h("button", { onclick: () => storePresetDialog(d) }, t("Save")), h("div", { class: "presetrow" }, presetSel, h("button", { onclick: () => storePresetDialog(d) }, t("Save")),
h("button", { onclick: () => presetFileDialog(d), title: t("Export / import preset"), "data-view-ok": "" }, t("File…")))); h("button", { onclick: () => presetFileDialog(d), title: t("Export / import preset"), "data-view-ok": "" }, t("File…"))));
} }
@@ -1348,7 +1449,7 @@ function deviceForm(d) {
: [ : [
h("button", { onclick: async () => { try { await api("PUT", `/api/devices/${d.id}`, values()); toast(t("Saved")); } catch (e) { toast(e.message); } } }, t("Save")), h("button", { onclick: async () => { try { await api("PUT", `/api/devices/${d.id}`, values()); toast(t("Saved")); } catch (e) { toast(e.message); } } }, t("Save")),
d.status === "disconnected" || d.status === "error" d.status === "disconnected" || d.status === "error"
? h("button", { class: "on", onclick: async () => { // connects with what the form shows, saved or not ? h("button", { class: "on", disabled: S.demo.enabled, onclick: async () => { // connects with what the form shows, saved or not
try { await api("PUT", `/api/devices/${d.id}`, values()); await api("POST", `/api/devices/${d.id}/connect`); } try { await api("PUT", `/api/devices/${d.id}`, values()); await api("POST", `/api/devices/${d.id}/connect`); }
catch (e) { toast(e.message); } catch (e) { toast(e.message); }
} }, t("Connect")) } }, t("Connect"))
@@ -1358,7 +1459,9 @@ function deviceForm(d) {
await api("DELETE", `/api/devices/${d.id}`).catch(e => toast(e.message)); await api("DELETE", `/api/devices/${d.id}`).catch(e => toast(e.message));
} }, t("Remove")), } }, t("Remove")),
]; ];
return h("div", { class: "card" }, const paused = S.demo.enabled && !isNew;
return h("div", { class: "card" + (paused ? " paused" : "") },
paused ? h("div", { class: "info" }, t("Disconnected while demo mode is on")) : null,
h("h3", {}, isNew ? null : h("span", { class: "dot " + d.status }), h("span", { class: "grow" }, isNew ? t("New device") : d.name), h("h3", {}, isNew ? null : h("span", { class: "dot " + d.status }), h("span", { class: "grow" }, isNew ? t("New device") : d.name),
isNew ? null : h("span", { class: "info" }, STATUS_TEXT[d.status])), isNew ? null : h("span", { class: "info" }, STATUS_TEXT[d.status])),
!isNew && d.info ? h("div", { class: "info" }, t("Device reports: ") + d.info) : null, !isNew && d.info ? h("div", { class: "info" }, t("Device reports: ") + d.info) : null,
@@ -1369,6 +1472,7 @@ function deviceForm(d) {
...netRows, usbRow, ...netRows, usbRow,
h("label", {}, t("Model"), f.model), h("label", {}, t("Model"), f.model),
h("label", { class: "chk" }, f.autoconnect, t("Connect automatically")), h("label", { class: "chk" }, f.autoconnect, t("Connect automatically")),
isNew ? null : lockSection(d),
h("div", { class: "actions" }, actions))); h("div", { class: "actions" }, actions)));
} }
@@ -1471,9 +1575,9 @@ function langCard() {
function viewSettings() { function viewSettings() {
return [ return [
h("div", { class: "cards" }, langCard()), h("div", { class: "cards" }, langCard(), demoCard()),
h("h2", { class: "section" }, t("Devices")), h("h2", { class: "section" }, t("Devices")),
h("div", { class: "cards" }, ...S.order.map(id => deviceForm(S.devices[id])), deviceForm(null)), h("div", { class: "cards" }, ...S.order.filter(id => !S.devices[id].demo).map(id => deviceForm(S.devices[id])), deviceForm(null)),
h("p", { class: "info" }, t("Both DSPs can be connected at the same time – switch between them at the top. "), h("p", { class: "info" }, t("Both DSPs can be connected at the same time – switch between them at the top. "),
t("The DSPs accept only one connection: close the Thomann editor first.")), t("The DSPs accept only one connection: close the Thomann editor first.")),
h("h2", { class: "section" }, S.isApp ? t("Remote access") : t("Security")), h("h2", { class: "section" }, S.isApp ? t("Remote access") : t("Security")),
@@ -1508,12 +1612,16 @@ function render() {
else if (d.status !== "online" || !d.state) else if (d.status !== "online" || !d.state)
content = h("div", { class: "empty" }, h("div", { class: "spinner" + (["loading", "connecting"].includes(d.status) ? "" : " off") }), content = h("div", { class: "empty" }, h("div", { class: "spinner" + (["loading", "connecting"].includes(d.status) ? "" : " off") }),
d.status === "loading" ? t("Loading the configuration from the DSP…") d.status === "loading" ? t("Loading the configuration from the DSP…")
: d.status === "connecting" ? t("Connecting to {where}…", { where: where(d) }) : t("Not connected.")); : d.status === "connecting" ? t("Connecting to {where}…", { where: where(d) })
: d.status === "locked" ? h("div", {}, h("p", {}, t("This DSP is locked with a code.")),
h("button", { class: "on", onclick: () => unlockDialog(d) }, t("Enter code")))
: S.demo.enabled && !d.demo ? t("Disconnected while demo mode is on") : t("Not connected."));
else content = ({ mixer: viewMixer, channel: viewChannel, routing: viewRouting, link: viewLink, limiter: viewLimiter }[S.view] || viewMixer)(d); else content = ({ mixer: viewMixer, channel: viewChannel, routing: viewRouting, link: viewLink, limiter: viewLimiter }[S.view] || viewMixer)(d);
main.replaceChildren(...[content].flat().filter(Boolean)); main.replaceChildren(...[content].flat().filter(Boolean));
main.querySelectorAll(H_SCROLL).forEach((e, i) => { if (xs[i]) e.scrollLeft = xs[i]; }); main.querySelectorAll(H_SCROLL).forEach((e, i) => { if (xs[i]) e.scrollLeft = xs[i]; });
window.scrollTo(0, y); window.scrollTo(0, y);
collectMeters(); collectMeters();
if (d) maybeAskUnlock(d);
} }
// flush deferred renders once a text field loses focus // flush deferred renders once a text field loses focus
main.addEventListener("focusout", () => setTimeout(() => { main.addEventListener("focusout", () => setTimeout(() => {
@@ -1596,6 +1704,9 @@ function connectEvents() {
case "hello": case "hello":
setDevices(ev.devices); setDevices(ev.devices);
if (ev.limiter) S.lim = ev.limiter; if (ev.limiter) S.lim = ev.limiter;
if (ev.demo) S.demo = ev.demo;
if (S.demo.enabled && S.devices.demo && !S.devices[S.cur]?.demo) S.cur = "demo";
S.order.forEach(id => maybeAskUnlock(S.devices[id]));
if (!S.order.length) S.settings = true; if (!S.order.length) S.settings = true;
render(); break; render(); break;
case "device": case "device":
@@ -1610,8 +1721,13 @@ function connectEvents() {
if (!d) break; if (!d) break;
Object.assign(d, { status: ev.status, error: ev.error, info: ev.info }); Object.assign(d, { status: ev.status, error: ev.error, info: ev.info });
if (ev.status !== "online") render(); else renderTabs(); if (ev.status !== "online") render(); else renderTabs();
maybeAskUnlock(d);
break; break;
} }
case "demo":
S.demo = ev.data;
if (!S.demo.enabled && S.cur === "demo") S.cur = S.order.find(id => id !== "demo") || null;
render(); break;
case "param": { case "param": {
const d = S.devices[ev.device]; const d = S.devices[ev.device];
if (!d || !d.state) break; if (!d || !d.state) break;
+35 -1
View File
@@ -286,7 +286,41 @@ const DE = {
"{pct} % of {rated}": "{pct} % von {rated}", "{pct} % of {rated}": "{pct} % von {rated}",
"— empty —": "— leer —", "— empty —": "— leer —",
"— no amplifier —": "— kein Verstärker —", "— no amplifier —": "— kein Verstärker —",
"“{s}”": "„{s}“" "“{s}”": "„{s}“",
// device lock, demo mode
"A code is remembered for this DSP.": "Für diesen DSP ist ein Code gespeichert.",
"Code forgotten": "Code vergessen",
"Connect the DSP to set a code.": "Zum Festlegen eines Codes den DSP verbinden.",
"DSP locked": "DSP gesperrt",
"DSP unlocked": "DSP entsperrt",
"Device lock (code)": "Gerätesperre (Code)",
"Enter code": "Code eingeben",
"Forget code": "Code vergessen",
"From the next connection on, {name} asks for the code {code} – also in the original software. Note it down: this app cannot remove the lock again.": "Ab der nächsten Verbindung fragt {name} nach dem Code {code} – auch in der Original-Software. Bitte notieren: Diese App kann die Sperre nicht wieder entfernen.",
"Hardware lock of the DSP: a locked DSP only accepts a connection after its code was entered. Independent of the lock of this app.": "Sperre im DSP selbst: Ein gesperrter DSP lässt sich erst nach Eingabe seines Codes bedienen. Unabhängig von der Sperre dieser App.",
"Lock code": "Sperrcode",
"Lock code set": "Sperrcode festgelegt",
"Locked with a code": "Mit Code gesperrt",
"No code remembered – it is asked for when the DSP is locked.": "Kein Code gespeichert – er wird abgefragt, wenn der DSP gesperrt ist.",
"Remember the code and unlock automatically": "Code merken und automatisch entsperren",
"Set a new lock code": "Neuen Sperrcode festlegen",
"Set code": "Code festlegen",
"Set lock code": "Sperrcode festlegen",
"The code has 4 characters: digits and letters A–Z": "Der Code hat 4 Zeichen: Ziffern und Buchstaben A–Z",
"This DSP is locked with a code.": "Dieser DSP ist mit einem Code gesperrt.",
"Unlock automatically with the remembered code": "Mit dem gespeicherten Code automatisch entsperren",
"Wrong code – please try again.": "Falscher Code – bitte erneut versuchen.",
"code remembered": "Code gespeichert",
"{name} is locked with a code. Enter the 4-character code (digits and letters A–Z).": "{name} ist mit einem Code gesperrt. Bitte den 4-stelligen Code eingeben (Ziffern und Buchstaben A–Z).",
"The DSP is not locked": "Der DSP ist nicht gesperrt",
"The remembered lock code was rejected": "Der gespeicherte Sperrcode wurde abgelehnt",
"Demo mode": "Demo-Modus",
"Demo mode · simulated DSP": "Demo-Modus · simulierter DSP",
"Demo mode – simulated DSP": "Demo-Modus – simulierter DSP",
"Disconnected while demo mode is on": "Getrennt, solange der Demo-Modus aktiv ist",
"Try everything with a simulated DSP – nothing is sent to real devices. While demo mode is on, the real DSPs are disconnected.": "Alles gefahrlos mit einem simulierten DSP ausprobieren – an echte Geräte wird nichts gesendet. Solange der Demo-Modus aktiv ist, sind die echten DSPs getrennt.",
"Not available for the demo device": "Für das Demo-Gerät nicht verfügbar",
"Demo mode is on – switch it off to connect the real DSPs": "Der Demo-Modus ist aktiv – zum Verbinden der echten DSPs bitte ausschalten",
}; };
const DE_PATTERNS = [ const DE_PATTERNS = [
+20
View File
@@ -442,3 +442,23 @@ body.locked #statusbar :is(button, select):not([data-view-ok]) { cursor: not-all
.limled.h { width: auto; height: auto; margin: 0; padding: 2px 6px; font-size: 10px; font-weight: 700; letter-spacing: .06em; .limled.h { width: auto; height: auto; margin: 0; padding: 2px 6px; font-size: 10px; font-weight: 700; letter-spacing: .06em;
color: color-mix(in srgb, var(--led-o) 45%, transparent); } color: color-mix(in srgb, var(--led-o) 45%, transparent); }
.limled.h.on { color: #1a1000; } .limled.h.on { color: #1a1000; }
/* ---- demo mode */
.demo-badge { font-size: 10px; font-weight: 700; letter-spacing: .08em; color: #1a1000 !important;
background: var(--warn) !important; border-radius: 5px; padding: 1px 6px; }
.devtab.demo { border-color: var(--warn); }
.devtab.paused, .card.paused { opacity: .45; }
.devtab.paused { cursor: not-allowed; }
.card.demo-on { border-color: var(--warn); }
/* ---- device lock (hardware) */
input.code { width: 7.5em; text-align: center; font-family: ui-monospace, Menlo, Consolas, monospace;
font-size: 20px; letter-spacing: .3em; text-transform: uppercase; }
.dialog input.code { display: block; margin: 8px auto 4px; }
.lockbox .row { align-items: center; gap: 8px; margin: 6px 0; }
.lockbox .sub { margin-top: 10px; }
.dot.locked { background: var(--warn); }
.dialog label.chk { display: flex; align-items: center; gap: 8px; margin-top: 12px; font-size: 14px; }
.dialog label.chk input { width: 20px; height: 20px; }
.dialog .err { text-align: center; }
.lockbox input.code { flex: none; width: 7.5em; }
+17
View File
@@ -120,6 +120,23 @@ def test_channel_names():
assert P.param_command(m, "in", 0, {"name": "Süd"}, "name") == (0x3D, b"\x00Sued ") assert P.param_command(m, "in", 0, {"name": "Süd"}, "name") == (0x3D, b"\x00Sued ")
def test_device_lock():
# answer to 0x2C: [time lock][4 bytes time lock data][device lock]
assert P.device_locked(bytes([0, 0, 0, 0, 0, 1]))
assert not P.device_locked(bytes([0, 0, 0, 0, 0, 0]))
assert not P.device_locked(bytes([0, 20])) # short answer: no lock information
assert P.LOCK_CODE.fullmatch("A1BA") and not P.LOCK_CODE.fullmatch("a1ba") and not P.LOCK_CODE.fullmatch("A1B")
assert P.build_frame(P.CMD_UNLOCK, b"\x00A1BA")[5:11] == bytes([0x2D, 0x00]) + b"A1BA"
import sim
dsp = sim.SimDSP("204", "A1BA")
assert P.device_locked(dsp.handle(P.CMD_PRESET_COUNT, b"")[1])
assert dsp.handle(P.CMD_UNLOCK, b"\x00ZZZZ") == (P.CMD_UNLOCK, bytes([0, 0]))
assert dsp.handle(P.CMD_UNLOCK, b"\x00A1BA") == (P.CMD_UNLOCK, bytes([0, 1]))
assert not P.device_locked(dsp.handle(P.CMD_PRESET_COUNT, b"")[1])
dsp.handle(P.CMD_SET_LOCK_CODE, b"B2C3")
assert dsp.lock_code == "B2C3"
if __name__ == "__main__": if __name__ == "__main__":
for name, fn in list(globals().items()): for name, fn in list(globals().items()):
if name.startswith("test_"): if name.startswith("test_"):