DMR bench testing on the SDR bench

How to test the DMR work (the board's modem driver behind hal/hal_dmr_modem.h, the call stack in core/dmr/call/, the AMBE FEC and vocoder hosting, the audio path) on the bench, what the tools are, each test case with its pass criteria, and the order to run them. The tools are in tools/bench/; tools/bench/dmr_bench.py runs any case end to end.

Status words as in docs/spec/gotchas.md: "on air" = checked with the SDR or another radio.

A radio's checklist of required HIL tests is tools/bringup.py list --radio <id> (tests/hil/README.md). The cases here are the manual procedures and what the HIL tests don't script yet.

1. The rig

Configuration: the tools take the bench's names from the environment, so no host name lives in the repository. The easiest setup is an ssh config alias Host sdr-bench pointing at the bench board (with its user and key).

Test channel used so far: 461.6875 MHz, color code 2 (Ch 15). The radio's codeplug also has DMR channels; any free channel works as long as it sits well away from the SDR's tuner center (section 3).

While the bench modem or the RTL-SDR is used by a test, the gateway service must not hold it. The bench modem is in the gateway's config now, so any bench modem test stops the service. dmr_bench.py does this with a lease that always restores the service (section 4). The earlier SFR rounds instead ran with the bench modem taken out of the gateway's config; that is a config change and needs the owner.

2. The tools

All in tools/bench/, MIT. They build and decode bursts with the rfoundry_sdrbench package, which lives in its own repository and is installed on the SDR bench (and on the Mac for the Mac-side tools, or found through $RFOUNDRY_SDRBENCH). What the tools import from it:

The DMR codec in rfoundry_sdrbench.dmr is also the reference several host tests cite for their vectors (dmrDataTest, lrrpTest, dmrDataServiceTest). Copy the bench-side tools with dmr_bench.py sync (to $RFOUNDRY_SDR_BENCH_HOST:~/rfoundry-bench/).

Where they came from: bench_tx.py, sdrmon.py, sdr_watch.py, hotspot_cases.py (from hs_normal.py), mmdvm_hotspot.py (from hotspot_test.py) and sfr_call.sh (from run_sfr_call.sh) are adapted from our own earlier bench tools; dmr_bench.py and bench_repeater.py are new.

What the bench modem can and cannot do:

• Simplex (DMO) transmit of any burst we build, one burst per 60 ms, any sync family, any CC. The MMDVM_HS keeps its carrier up for the whole call (one keyed segment on the SDR), unlike a radio, which keys per burst.
• Simplex receive: MS sync only. BS-synced and TDMA direct mode (TS1/TS2) bursts from the radio are not reported; use the SDR for those.
• Duplex (dual modem): a real repeater outbound (BS sync, CACH, both slots, idle bursts) on a TX frequency different from its RX frequency. It cannot be a single frequency repeater.
• The bench modem does not decode or encode audio. It never needs a vocoder: voice content is AMBE frames we supply.

3. Clean SDR captures: levels and the DC spike

Clipping. With the radio on the bench, the RTL-SDR saturates: at gain 15 dB (sdrmon's old default; the gateway runs 30) 28 % of samples were at the rails when the radio keyed at 1 W nearby, and an existing bench modem capture at gain 15 shows 8.4 %. A clipped capture has wrong power, ramps and frequency offset and loses bursts. sdrmon.py capture now records the clipping share in the capture's JSON and warns above 1 %; analyze recomputes it and dmr_bench.py fails a TX check on a capture over 1 %.

• Run case C0 first: it captures 4 s at gains 0, 5, 10 and 15 dB while the radio holds PTT, and prints the clipping at each. Pick the highest gain with clipping under 0.1 % and bursts at or below about -6 dBFS; pass it as --gain (the dmr_bench default is 5).
• Radio on low power for all TX captures; the bench modem at --modem-power 40 (of 255), as in the earlier clean runs.
• Still clipping at gain 0: move the SDR antenna away (a meter helps a lot), put a 20-30 dB SMA attenuator on the SDR, or run the radio into a dummy load (it leaks enough for the bench modem and the SDR at bench distance). The bias tee powers an LNA; sdrmon.py capture --no-biastee turns it off, but check that the unpowered LNA still passes signal.

DC spike. The RTL has a spike (and IQ imbalance) at the tuner center. sdrmon.py tunes the dongle --offset-khz (default -200 kHz) away from the channel: for 461.6875 MHz the tuner sits at 461.8875. Keep the channel at least 100 kHz from the tuner center and don't pick a test channel near the tuner center of the capture (461.8875 MHz with the defaults). The repeater case puts the center 100 kHz beside the midpoint of the pair so both channels are clear of it.

Timing of a capture. READY is printed before samples really flow; wait 2 s after READY before keying (dmr_bench does). The SDR bench's 824 MB RAM: analysis reads captures in chunks (about 150 MB for 15 s); don't load a whole capture into numpy there (the old ~/sfrtest/sdrmon/fmana.py FM analysis does, and is not carried over).

4. Running a case, and the service

tools/bench/dmr_bench.py sync                       # once, and after any tool change
tools/bench/dmr_bench.py show T1                    # what it does, the pass criteria
tools/bench/dmr_bench.py run T1 --dry-run --radio-id <ID> --tg 9    # print every command, run nothing
tools/bench/dmr_bench.py run T1 --radio-id <ID> --tg 9 --gain 5

The dry run lists the exact commands, including the service stop and start. Get the owner's OK on that before the first real run of a case that keys a transmitter (the bench modem, or the repeater) or stops the service.

The lease: a case that needs the bench modem or the raw SDR starts one detached process on the SDR bench that runs sudo systemctl stop $RFOUNDRY_SDR_BENCH_SERVICE, waits while ~/rfoundry-bench/hold exists (at most --lease-max, 300 s by default), then runs sudo systemctl start $RFOUNDRY_SDR_BENCH_SERVICE and logs it to ~/rfoundry-bench/lease.log. The script removes the hold file in a finally block and checks that the service is active again. If the Mac, the script or the ssh link dies, the service still comes back when the lease expires. Ctrl-C at a prompt ends the case and restores the service. T0 needs no lease.

Results: bench-results/<date>_<case>/ on the Mac (report.md, report.json, the sdrmon JSON and text, the bench modem listen JSON lines, the repeater log); the captures stay on the SDR bench in ~/rfoundry-bench/runs/<run>/ (about 50 MB per 16 s; nothing is deleted automatically).

Report format (report.json): case, title, run, args, steps (each bench modem command and outcome), radio (each question asked and the user's answer: the diagnostics counters), checks (each automatic check: check, ok true / false / null for manual, detail), verdict (PASS, FAIL, or MANUAL when only the user's observations decide), commands (every command run, in order). report.md is the same as a table. Re-run the checks on saved results with dmr_bench.py check T1 <sdrmon.json> --modem <listen.jsonl> --radio-id <ID>.

5. Bring-up order and the test cases

Run them in this order. The key-press cases (C, T0, R, T, Q, P) need only the radio's keys and its diagnostics page. The hotspot cases (H, S) cover the modem driver and the call stack better, because every burst the radio hears comes back over USB and every burst it sends is under our control: run H1 after every driver change. Most of these cases are now also automated in tests/hil (README.md section 3).

Note the diagnostics counters (the page, or rfoundry_debug.py diag) before each case; the cases ask for the new values.

5.0 Setup

T0 is the first thing to run after flashing a DMR TX build: it stops nothing.

5.1 The radio receives (a)

The bench modem sends; the user reads the diagnostics page and the main screen. Each bench modem transmission is a known stimulus: source 9990301 (and 9990302), AMBE silence unless stated, 8 voice LC headers and 3 terminators (the MMDVM_HS profile). To check the stimulus itself, run the same bench_tx.py command during an sdrmon.py capture.

5.2 The radio transmits (b)

The user keys the radio; the SDR captures raw IQ (sdrmon.py), the bench modem listens (bench_tx.py listen --json), and dmr_bench.py checks the capture automatically (only the radio's bursts: from its first header with --radio-id, on that header's slot).

T1 pass criteria (all automatic):

• capture clipping < 1 %;
• every burst MS sync (direct mode), color code = the channel's;
• at least one voice LC header (three expected, docs/spec/dmr-modem.md 2.5), header and terminator LC with source = the radio's ID, destination = the TG, FLCO 0;
• voice A-F in order, whole superframes; the embedded LC from B-E decodes and equals the header's;
• at least one terminator with LC after the last voice burst;
• same-slot spacing 60.00 +- 0.05 ms, standard deviation < 0.1 ms;
• median frequency offset within +-500 Hz (the FM carrier was within 50 Hz);
• the carrier keyed per burst (off in the other slot), each burst on 27-31.5 ms, key-up and key-down ramps < 1.5 ms;
• no overlapping bursts, no power step inside a burst, no carrier without a decoded burst;
• the bench modem hears one call, started by its header, ended by its terminator, AMBE FEC corrections 0 on the bench.

5.3 Voice quality (c)

Decoding AMBE to audio needs an AMBE+2 vocoder, and this project ships none (README, docs/CLEANROOM.md). What exists on the rig, checked 2026-10-09:

• Nothing on the SDR bench decodes AMBE: no mbelib, dsd / dsd-fme, md380-emu or Unicorn, and no DV dongle on its USB (only the RTL2832U and the WiFi chip).
• bench_tx.py writes .amb files, which dsd-fme -r, dsd -r and md380-emu -d read, if the person running the test has one of those on their own machine.

Options, best first: (1) a DVSI hardware vocoder on USB (ThumbDV / DV3000 class, AMBE-3000 chip): licensed hardware, decode .amb / raw frames with its own host tool on the Mac or the SDR bench; the cleanest for objective quality numbers; (2) an open decoder installed by the tester locally (dsd-fme + mbelib), never vendored here. Independent of any vocoder, the radio's own decoder judges a call (Q3: voice.rx_peak, the radio's own over played back to it), and the objective checks are the AMBE FEC correction count (0 on a clean bench), bit-exact comparison of a known transmitted pattern (firmware request 3) and of a known received pattern (request 4).

5.4 Repeater mode (d)

The bench modem can be a real repeater (BS outbound, CACH, both slots) with bench_repeater.py; it needs a split frequency pair you may use, ideally within 1 MHz so one SDR capture holds both (the case analyzes both channels from one capture). bench_tx.py --family bs alone only gives BS sync in DMO timing (R10), not an outbound.

Then (later cases, same tools): a call heard through the repeater on the radio (bench modem simplex can't key the duplex repeater from the other side, so use a second radio or the repeater's network input), slot filter on / off, the radio not ending its next reception on its own echoed terminator (docs/spec/dmr-modem.md 2.2), late entry on a BS outbound, wakeup retries when the repeater is off (radio sends BS_Dwn_Act every ~600 ms, then gives up).

5.5 Privacy, talker alias, late entry, data and SMS (e)

Covered in part by R3 (late entry), R13 (PI bit and privacy flag), R14 (talker alias received), R7-R9 (CSBK, data). To add as the features land: the radio sending talker alias and GPS (sdrmon decodes the embedded LC at each voice E, FLCO 4-8); basic privacy both ways (needs AMBE scrambling in bench_tx.py; rfoundry_sdrbench.dmr would need a basic privacy decoder to check the radio's encrypted TX off air); SMS both ways (bench_tx.py data sends a 40-octet test payload; a real SMS payload builder is still to write; the radio's SMS is heard by bench_tx.py listen as a data header + blocks).

5.6 Hotspot and SFR

sfr_call.sh is the quick SFR loop with the gateway's decode (needs the bench modem out of the gateway's config); mmdvm_hotspot.py --debug sends our 0xD5 experiment switches and prints the SFR counters from GET_STATUS.

6. Firmware requests (radio-side observation)

Historical: the requests made before the firmware had USB. Requests 1 and 2 became the diagnostics page and the debug link's diag and view sections (debuglink.md); request 4 became the USB MMDVM hotspot, with the counters in debug link view sections instead of a vendor command (0xD6 is now the split duplex command, split-duplex.md); request 5 is in (core/hotspot/hotspotSfr.c). Request 3 (a fixed TX test pattern) was not built; the HIL TX tests key the radio through the debug link instead.

1. DMR diagnostics page (key presses only, now). One page, decimal, counters 16 bit: slot ticks; bursts received by kind (voice LC header, terminator, voice A, voice B-F, CSBK, data header, rate 1/2, 3/4, 1, idle, PI header); CRC errors by kind; bursts per sync family (MS, BS, TS1, TS2); last CC, last sync family, last data type; last header / terminator LC (FLCO, src, dst) and last embedded LC; TX: bursts sent, TX_REJECTED, TX_DONE; SYNC_LOST and VOICE_LOST counts; the radio's own ID and the channel's CC / TS / DMO-RMO. A key to zero the counters and a key to freeze the display (reading during a call).
2. RX content check: on the same page, the number of AMBE frames of the last call, the AMBE FEC bits corrected, and a CRC-32 of the 9-byte AMBE frames as received (before decoding). A bench modem call of N superframes of AMBE silence then has a known frame count and CRC (bench_tx.py can print it), so RX is checked bit-exact without a vocoder.
3. TX test pattern on a key in the diagnostics page: a DMR group call from the own ID to TG 9 on the current channel, 3 headers, 4 superframes of a fixed AMBE pattern (AMBE silence, or a fixed valid non-silence frame), terminator, without the vocoder or the microphone; a second key for one CSBK (e.g. BS_Dwn_Act or a call alert) and a short unconfirmed data packet. bench_tx.py listen and sdrmon.py then compare it bit for bit (frames, LC, embedded LC) and the TX timing is tested before the codec is.
4. USB CDC (when USB lands): the MMDVM protocol on one CDC ACM interface (enables H1 / S1). For logging, use the standard MMDVM debug frames (0xF1-0xF5: text + up to 4 integers), which MMDVMHost and mmdvm_hotspot.py already log, for modem events (burst kind, sync family, CC, CRC, slot, time in us from the slot interrupt). For the counters of request 1, one extension command alongside our 0xD5: 0xD6 GET_DMR_COUNTERS, reply payload = a version byte then little-endian uint16 counters in the request 1 order (new fields only appended), so the tools read the counters without anyone reading the screen.
5. Keep the SFR counters and 0xD5 switches (hrcSfr.h) in GET_STATUS when SFR comes back, as the tools already parse them.

7. First three tests once the DMR driver is flashed

1. C0 (SDR levels) and T0 (TX smoke through the gateway's decode, no service stop): T0 is safe to run first: it stops nothing and only the radio transmits. If the build only receives, skip T0.
2. R1 (group voice from the bench modem; diagnostics counters): the first RX check of the driver (slot ticks, burst kinds, CRC, CC, sync family) and of the call stack's header / terminator handling.
3. T1 (radio group call: SDR + bench modem listen, automatic checks): the full TX timing check (sync, CC, headers, superframes, embedded LC, terminator, 60 ms spacing, ramps, frequency offset).

View the source of this page