freedv-test

name

freedv-test

description

Run an end-to-end FreeDV RADE EOO-callsign round-trip between two virtual wfweb rigs. Boots the testrig bench, puts both rigs in RADE mode, transmits from one by injecting synthesized audio into the server's RADE encoder (the headless browser has no mic), and verifies the other decodes the EOO callsign from the server log. Use when the user asks to test FreeDV, test RADE, or verify the RADE EOO callsign TX/RX path. (RADE only — classic 700D/700E/1600 are out of scope.)

Run an end-to-end FreeDV RADE EOO-callsign round-trip between two virtual rigs: one station transmits a RADE signal and the other must decode the transmitting station's callsign from the EOO (End-Of-Over) frame. Bench-only (virtual rigs, no hardware, no real RF). RADE only — the classic FreeDV modes (700D/700E/1600) are out of scope.

This is the outlier among the mode-test skills. Unlike CW/FT8/JS8 (browser-side codecs), RADE runs server-side (C++), and it breaks the pure-browser pattern in three ways you must handle:

1. No browser mic. The headless Playwright chromium denies getUserMedia, so you can't drive a real voice TX. Instead you inject synthesized audio straight into the server's RADE encoder by sending 0x03 TX-audio WebSocket frames (the same frame type the mic worklet uses) via window.sendTxAudio().
2. The assert is the server log, not the DOM. The decoded callsign appears in the browser for only 5 seconds (the server clears it via a timer), so reading window.radeRxCallsign is racy. The authoritative, race-free signal is the RX rig's log line RADE: decoded callsign from EOO: "<CALL>".
3. Sync is unreliable with synthetic audio. This is the honest limitation: feeding the neural RADE codec synthesized (non-speech) audio produces a modem signal that arrives fine — the receiver sees a healthy SNR (measured up to +15 dB) — but RADE's modem sync still fails most of the time, so the EOO doesn't decode. It works (proven both directions), just not dependably: expect to retry several times, and a clean-room run can miss 5×+ in a row. The robust fix is to inject real speech instead of tones/noise (see "Improving reliability"). Retry on miss and transmit a long burst (~12–15 s).

Prerequisites (verify before starting; fix and stop if missing)

1. ./wfweb and ./tools/virtualrig/virtualrig are built (qmake wfweb.pro && make -j$(nproc); cd tools/virtualrig && qmake && make -j$(nproc)). The server build is required — RADE is server-side and disabled in the Standalone bundle.
2. Repo .mcp.json includes --ignore-https-errors for the playwright MCP. Verify: pgrep -af @playwright/mcp must show --ignore-https-errors. If .mcp.json was just edited, the user must restart Claude Code. Stop and tell them.
3. Load the playwright tools via ToolSearch: select:mcp__playwright__browser_navigate,mcp__playwright__browser_snapshot,mcp__playwright__browser_click,mcp__playwright__browser_type,mcp__playwright__browser_take_screenshot,mcp__playwright__browser_wait_for,mcp__playwright__browser_evaluate,mcp__playwright__browser_close,mcp__playwright__browser_tabs,mcp__playwright__browser_select_option.

Boot the bench

./scripts/testrig.sh up 2

Both rigs come up on 14.074.000 USB (FreeDV is a USB data mode — same freq + mode means audio gates and A's RADE signal reaches B). Prefer a freshly-booted bench: RADE sync gets flakier after many TX cycles on a long-lived bench.

• A → https://127.0.0.1:9080 (virtual-IC7300-A) — log: .testrig/wfweb_0.log
• B → https://127.0.0.1:9090 (virtual-IC7300-B) — log: .testrig/wfweb_1.log

Per-tab UI bring-up (do for both A and B)

1. browser_navigate to the rig URL.
2. Wipe stale browser state: browser_evaluate () => { localStorage.clear(); sessionStorage.clear(); }, then browser_navigate to the same URL again.
3. Click the CLICK TO START splash; poll until window.audioEnabled === true (RX audio enables ~1 s later — B's RADE decoder is fed from this RX-audio path).
4. Set the station callsign (this becomes the EOO callsign — it's encoded on the first TX frame, so set it before transmitting): window.App.callsign.set('W1AAA') then window.sendReporterConfig() (pushes it to the server's reporterCallsign, which sets the RADE TX callsign). A: W1AAA, B: W1BBB.
5. Enter RADE: window.toggleFreeDV() (RADE is freedvModes[0], advertised first by the server; opening forces USB). Confirm window.freedvEnabled === true and window.freedvModeName === 'RADE'.

Stable handles / state:

• Indicators: #freedvSyncEl (SYNC/NO SYNC), #freedvSnrEl, #freedvCallsign (only present while a decoded callsign is showing — clears after 5 s)
• Functions (global): toggleFreeDV(), cycleFreeDVMode(), sendReporterConfig(), send(obj) (raw WS command), sendTxAudio(arrayBuffer) (raw 0x03 TX-audio frame)
• State (globals on window): freedvEnabled, freedvModeName, freedvSync, freedvSNR, radeRxCallsign (the 5 s flash)

TX: inject synthesized audio (the receiver-less mic substitute)

The headless browser can't capture a mic, so transmit by streaming synthesized 48 kHz Int16LE PCM as 0x03 frames. Frame layout: [0x03][0x00][seq_u16LE][reserved_u16LE][PCM_Int16LE…]. Run this in browser_evaluate on the transmitting tab, keeping that tab foreground for the whole burst (background tabs throttle setTimeout, stalling the 20 ms pacing and breaking the stream):

async () => {
  const RATE = 48000;
  function frame(seq, tSec) {
    const N = 960; const buf = new ArrayBuffer(6 + N*2); const dv = new DataView(buf);
    dv.setUint8(0,0x03); dv.setUint8(1,0x00); dv.setUint16(2,seq&0xFFFF,true); dv.setUint16(4,0,true);
    const f0 = 140 + 30*Math.sin(tSec*5.0);          // pitch with vibrato
    for (let i=0;i<N;i++){ const t=tSec+i/RATE;
      let v = 0.6*Math.sin(2*Math.PI*f0*t) + 0.3*Math.sin(2*Math.PI*(f0*2)*t)
            + 0.25*Math.sin(2*Math.PI*(f0*3.5)*t) + 0.15*Math.sin(2*Math.PI*(f0*6)*t);
      let s = 0.95*Math.max(-1,Math.min(1,v));        // NEAR FULL-SCALE — quiet audio won't sync
      dv.setInt16(6+i*2, s<0 ? s*32768 : s*32767, true);
    }
    return buf;
  }
  window.send({cmd:'enableMic', value:true});
  await new Promise(r=>setTimeout(r,300));
  window.send({cmd:'setPTT', value:true});
  for (let k=0;k<600;k++){ window.sendTxAudio(frame(k, k*0.020)); await new Promise(r=>setTimeout(r,20)); } // ~12 s
  window.send({cmd:'setPTT', value:false});           // PTT-off → server generates the EOO frame w/ callsign
  await new Promise(r=>setTimeout(r,300));
  window.send({cmd:'enableMic', value:false});
  return 'TX done';
}

Two things make or break this: the audio must be loud (~0.95 full-scale — a quiet signal lands at ~−5 dB SNR and never syncs), and the burst must be long (~12 s, raise to 15 s on retry) so the receiver acquires sync before the trailing EOO. A lone EOO with no preceding signal will not decode.

Round-trip sequence (with retry)

For each direction (A→B, then optionally B→A):

1. On the TX tab (foreground), run the injection block above.
2. Assert via the RX rig's log — grep for the decode:

   grep 'RADE: decoded callsign from EOO' .testrig/wfweb_1.log   # B is the RX side for A→B
   

   PASS when it shows decoded callsign from EOO: "W1AAA". (For B→A, grep .testrig/wfweb_0.log for "W1BBB".)
3. If no decode, retry the injection (sync is probabilistic). Bump the burst to ~15 s (k<750). Give up after 4 attempts and report the SNR you saw (window.freedvSNR on the RX tab) — a floor value (−5) means the signal isn't arriving; a higher value that still won't sync means marginal modem lock.
4. Optionally, to screenshot the 5 s browser flash: right after a successful TX, switch to the RX tab and poll window.radeRxCallsign tightly (every ~120 ms); the instant it's truthy, browser_take_screenshot. This is best-effort — the log is the real evidence.

Save screenshots as .playwright-mcp/wfweb-rade-A.png / ...-B.png (project-dir/.playwright-mcp/ only; /tmp is rejected).

Improving reliability (recommended before relying on this skill)

The tone/noise synthetic audio above is the weak link — it gives good SNR but marginal sync. Two more reliable approaches, in order of preference:

• Inject real speech. Fetch a short speech WAV (mono, any rate — resample to 48 kHz Int16 in JS), and stream its samples as the 0x03 payload instead of the synthesized tones. Real speech drives the RADE encoder to produce a properly-syncable modem signal, which is what RADE was trained on. This is the right long-term fix.
• Enable a fake mic device in the MCP (--use-fake-device-for-media-stream --use-fake-ui-for-media-stream on the chromium launch) so getUserMedia returns Chromium's fake audio and the real mic→RADE path works. This needs a .mcp.json change + Claude Code restart, so confirm with the user first.

Until one of those is in place, treat a PASS as "decoded on retry" and a no-decode-after-N as inconclusive (capability is proven; the synthetic-audio test is just flaky), not a regression.

Teardown and report

1. browser_close (both tabs), then ./scripts/testrig.sh down.
2. Report PASS/FAIL per direction with the decode log line(s) as evidence. PASS = the RX rig's log shows RADE: decoded callsign from EOO: "<the TX station's call>".

Pitfalls — read before debugging

• getUserMedia is denied headless (NotAllowedError) — there is no browser mic. You MUST inject 0x03 audio via sendTxAudio(); the normal mic/PTT UI path produces no TX audio. (Server confirms the route: a 0x03 frame in RADE mode is fed to the RADE encoder.)
• Audio level matters. ~0.95 full-scale syncs; quiet audio sits at ~−5 dB SNR on the RX side and never locks. If B shows freedvSNR === -5 throughout, your TX is too quiet (or not arriving).
• Burst length matters. RADE RX needs sustained signal to acquire sync before the EOO. ~12 s works ~half the time; 15 s is safer. A lone EOO (e.g. PTT-cycling with no injected audio) transmits the callsign frame but B never syncs to decode it — confirmed.
• Sync is probabilistic — retry. Even done right, expect ~40–60% success per attempt with synthetic audio. Loop up to ~4 times. A fresh bench is more reliable than one that's run many TX cycles.
• Assert on the server log, not the DOM. window.radeRxCallsign (and #freedvCallsign) is cleared after 5 s by radeCallsignClearTimer. The log line is permanent and race-free. Don't gate on freedvSync either — the callsign arrives in the EOO after sync is already lost (this is by design; see CLAUDE.md).
• Keep the TX tab foreground during the ~12–15 s injection. Switching away throttles setTimeout and stalls the 20 ms frame pacing.
• Callsign must be set before TX — it's baked into the EOO on the first TX frame (setTxCallsign ← reporterCallsign ← App.callsign).
• Both rigs USB + same freq. toggleFreeDV() sets USB; the bench defaults both to 14.074. If they diverge, B won't gate A's audio in.
• Don't run two RADE TXs at once. One TX at a time across the bench; let one direction's EOO decode before starting the other.
• Never transmit on a physically-connected rig — virtual-bench only.