Files
BetterDSPControl/sim.py
T
GivouandClaude Opus 5.5 86ee492ec3 Beta models DSP 206 and FIR DSP 408 (without the FIR filters), read-only until allowed
Never tested on real hardware, so they are only selectable by hand and send no
changes until the user has compared the shown values with the DSP.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 16:47:56 +01:00

124 lines
5.2 KiB
Python

"""Simulated t.racks DSP for testing without hardware.
Usage: python sim.py --model 204 --port 9761
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 asyncio
import copy
import logging
import math
import time
from dsp import protocol as P
log = logging.getLogger("sim")
class SimDSP:
def __init__(self, model_key: str, lock_code: str = ""):
self.key = model_key
self.lock_code = lock_code # hardware lock: "" = none
self.unlocked = not lock_code
self.model = P.MODELS[model_key]
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[0]["preset_name"] = "Default"
self.pending_name = ""
def preset_names(self) -> list[str]:
return [p["preset_name"] if p else "" for p in self.presets]
def handle(self, cmd: int, p: bytes) -> tuple[int, bytes]:
m = self.model
if cmd == P.CMD_DEVICE_INFO:
return cmd, f"{m.name.replace(' ', '')} V010 SIM".encode()
if cmd == P.CMD_PRESET_COUNT:
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:
return cmd, bytes([p[0]]) + self.preset_names()[p[0]].encode("latin1").ljust(14, b" ")
if cmd == P.CMD_CONFIG_REQUEST:
buf = P.build_state_buffer(m, self.state)
n = p[0]
return P.CMD_CONFIG_CHUNK, bytes([n]) + bytes(buf[n * P.CHUNK_SIZE:(n + 1) * P.CHUNK_SIZE])
if cmd == P.CMD_METER:
t = time.monotonic()
levels = [0.0] * 12
noise = self.state.get("test", {}).get("source", 0) # test generator instead of the analog inputs
for i in range(m.n_in):
ch = self.state["inputs"][i]
src = 0.7 + 0.05 * math.sin(t * 40 + i) if noise else 0.25 * (1 + math.sin(t * (1.3 + i)))
lv = 0.0 if ch["mute"] else src * 10 ** (P.gain_to_db(ch["gain"]) / 20)
levels[m.meter_index("in", i)] = lv
flags = 0
for o in range(m.n_out):
ch = self.state["outputs"][o]
src = sum(levels[m.meter_index("in", i)] for i in range(m.n_in) if ch["matrix"] >> i & 1)
lv = 0.0 if ch["mute"] else min(1.5, src * 10 ** (P.gain_to_db(ch["gain"]) / 20))
levels[m.meter_index("out", o)] = lv
if lv > 0 and 20 * math.log10(lv) > P.threshold_to_db(ch["limit"]["threshold"]):
flags |= 1 << o
return cmd, P.encode_meters(levels, flags)
if cmd == P.CMD_PRESET_RECALL:
preset = self.presets[p[0] - 1]
if preset:
self.state = copy.deepcopy(preset)
elif cmd == P.CMD_PRESET_STORE_NAME:
self.pending_name = p.decode("latin1").strip()
elif cmd == P.CMD_PRESET_STORE:
self.state["preset_name"] = self.pending_name or f"Preset {p[0]}"
self.presets[p[0] - 1] = copy.deepcopy(self.state)
else:
P.apply_command(m, self.state, cmd, p)
return P.CMD_ACK, b"\x00"
async def serve(self, reader, writer):
peer = writer.get_extra_info("peername")
log.info("client %s connected", peer)
self.unlocked = not self.lock_code
parser = P.FrameParser()
try:
while data := await reader.read(4096):
for f in parser.feed(data):
if f.cmd != P.CMD_METER:
log.info("rx cmd=0x%02x payload=%s", f.cmd, f.payload.hex(" "))
cmd, payload = self.handle(f.cmd, f.payload)
writer.write(P.build_frame(cmd, payload, addr=0, src=1))
await writer.drain()
except ConnectionError:
pass
log.info("client %s disconnected", peer)
writer.close()
async def main():
ap = argparse.ArgumentParser()
ap.add_argument("--model", choices=list(P.MODELS), default="204")
ap.add_argument("--port", type=int, default=P.PORT)
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()
logging.basicConfig(level=logging.INFO, format=f"%(asctime)s sim{args.model} %(message)s")
sim = SimDSP(args.model, args.lock.upper())
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)
async with server:
await server.serve_forever()
if __name__ == "__main__":
try:
asyncio.run(main())
except KeyboardInterrupt:
pass