#!/usr/bin/env python3 """End-to-end frame simulation: preamble + header + MAC + payload. Every trial builds a full frame (licensed profile, source callsign, random body), passes it through the impairment channel, and runs the two-stage receiver. Failures are split by where they happened: no-sync preamble not detected, or locked to the wrong position hdr-fail header did not decode (or decoded to an unsupported mode) pay-fail header fine, payload LDPC/CRC failed ok payload and MAC delivered intact Channel options (on top of the default impairments): --fading rayleigh|rician --fd HZ --k-db DB flat fading, Doppler fd --itf fm:25 --itf cw:-40 --sir DB [DB ...] interferers at kHz offsets, swept over SIR (all equal) --adc-bits 8 quantize like an RTL-SDR --lo-offset HZ transverter-style LO error --no-excise receiver without excision --tracker legacy v0.4 pilot tracker, for comparison --noncoherent index-only payload (mode 1) The "x RT" column is processing speed: frame airtime divided by the mean time receive_frame took per trial, on one core (>1 = faster than real time). Usage: ./sim_frame.py --sf 7 --snr -13 -12 -11 -10 --trials 60 ./sim_frame.py --sf 12 --snr -25 -24 -23 --trials 15 --bytes 24 ./sim_frame.py --sf 7 --snr -12 -11 -10 --trials 400 --jobs 4 ./sim_frame.py --sf 7 --snr 0 --itf fm:25 --sir -10 -15 -20 --trials 200 ./sim_frame.py --sf 7 --snr -10 -5 0 5 10 --fading rayleigh --trials 400 ./sim_frame.py --sf 7 --snr -5 --itf fm:25 --sir -30 -40 -50 --adc-bits 8 """ import parallel # before numpy: one BLAS thread per worker import argparse, time from functools import partial import numpy as np from phy import PhyParams, payload_layout from channel import ChannelConfig, Interferer, apply_channel from frame import build_frame, receive_frame, LICENSED def impaired_cfg(rng, p, snr_db, clean=False, chan=None): if clean: cfg = ChannelConfig(snr_db=snr_db, delay_chips=rng.uniform(0, p.M), phase=rng.uniform(0, 2 * np.pi)) else: cfg = ChannelConfig( snr_db=snr_db, ppm=rng.uniform(-50, 50), delay_chips=rng.uniform(0, p.M), phase=rng.uniform(0, 2 * np.pi), dc=0.3 * (rng.standard_normal() + 1j * rng.standard_normal()), iq_gain_db=0.5, iq_phase_deg=3.0) if chan: cfg.fading = chan.get("fading", "none") cfg.fd_hz = chan.get("fd_hz", 0.0) cfg.k_db = chan.get("k_db", 6.0) cfg.interferers = [Interferer(kind=k, offset_hz=f, sir_db=chan["sir_db"]) for k, f in chan.get("itf", [])] cfg.adc_bits = chan.get("adc_bits", 0) cfg.lo_offset_hz = chan.get("lo_offset_hz", 0.0) d = chan.get("drift_hz_per_s", 0.0) if d: # only draw when used: other runs stay identical cfg.drift_hz_per_s = d * (1 if rng.random() < 0.5 else -1) return cfg STAGES = ("no_sync", "header_fail", "payload_fail", "ok") def _trial(rng, p, snr_db, n_bytes, iterative, clean, chan=None, excise=True, tracker="adaptive", coherent=True): body = rng.bytes(n_bytes) iq, meta = build_frame(p, body, profile=LICENSED, src="W1AW", coherent=coherent) y, truth = apply_channel(iq, p, impaired_cfg(rng, p, snr_db, clean, chan), rng) t0 = time.perf_counter() res = receive_frame(y, p, iterative=iterative, excise=excise, tracker=tracker) dt = time.perf_counter() - t0 stage = res.stage if stage != "ok" and res.sync is not None and \ abs(res.sync.tau0 - truth["frame_start_rx"] / p.osr) > 0.5: stage = "no_sync" # failed because it locked to the wrong place if stage == "ok" and (res.mac.body != body or res.mac.src != "W1AW"): stage = "payload_fail" # would be an undetected error return STAGES.index(stage), dt, len(iq) / p.fs def run_point(p, snr_db, trials, n_bytes, seed, iterative=True, clean=False, jobs=1, chan=None, excise=True, tracker="adaptive", coherent=True): fn = partial(_trial, p=p, snr_db=snr_db, n_bytes=n_bytes, iterative=iterative, clean=clean, chan=chan, excise=excise, tracker=tracker, coherent=coherent) res = parallel.run_trials(fn, trials, seed, jobs) r = np.bincount([x[0] for x in res], minlength=len(STAGES)) out = {k: v / trials for k, v in zip(STAGES, r)} dts = np.array([x[1] for x in res]) out["rt"] = float(np.mean([x[2] for x in res]) / dts.mean()) # x real time, mean out["rt_worst"] = float(res[0][2] / dts.max()) return out if __name__ == "__main__": ap = argparse.ArgumentParser() ap.add_argument("--sf", type=int, nargs="+", default=[7]) ap.add_argument("--snr", type=float, nargs="+", default=[-13, -12, -11, -10]) ap.add_argument("--trials", type=int, default=50) ap.add_argument("--bytes", type=int, default=24, help="MAC body bytes") ap.add_argument("--osr", type=int, default=2) ap.add_argument("--bw", type=float, default=125e3, help="chirp bandwidth, Hz") ap.add_argument("--preamble", type=int, default=8, help="preamble up-chirps") ap.add_argument("--seed", type=int, default=0) ap.add_argument("--clean", action="store_true", help="AWGN + delay + phase only") ap.add_argument("--no-id", action="store_true", help="disable iterative demapping") ap.add_argument("--jobs", type=int, default=parallel.default_jobs(), help="worker processes (default: all cores)") ap.add_argument("--fading", choices=["none", "rayleigh", "rician"], default="none") ap.add_argument("--fd", type=float, default=0.0, help="max Doppler, Hz (0 = block)") ap.add_argument("--k-db", type=float, default=6.0, help="Rician K factor, dB") ap.add_argument("--itf", action="append", default=[], help="interferer KIND:OFFSET_KHZ, KIND = cw or fm (repeatable)") ap.add_argument("--sir", type=float, nargs="+", default=[0.0], help="signal-to-interference ratio(s), dB, per interferer") ap.add_argument("--lo-offset", type=float, default=0.0, help="carrier offset (Hz) with no matching clock error, e.g. a transverter LO") ap.add_argument("--drift", type=float, default=0.0, help="carrier drift, Hz/s, random sign per trial (oscillator warming up)") ap.add_argument("--adc-bits", type=int, default=0, help="quantize I/Q to this many bits (RTL-SDR: 8); 0 = off") ap.add_argument("--no-excise", action="store_true", help="disable narrowband interference excision") ap.add_argument("--noncoherent", action="store_true", help="index-only payload (mode 1): no QPSK bits, no carrier phase needed") ap.add_argument("--tracker", choices=["adaptive", "legacy"], default="adaptive", help="pilot channel tracker (legacy = v0.4 phase-only fit)") a = ap.parse_args() itf = [] for spec in a.itf: kind, off = spec.split(":") itf.append((kind, float(off) * 1e3)) sirs = a.sir if itf else [None] desc = [] if a.fading != "none": desc.append(f"{a.fading} fading, fd {a.fd:g} Hz" + (f", K {a.k_db:g} dB" if a.fading == "rician" else "")) if itf: desc.append("interferers " + ", ".join(f"{k} at {f / 1e3:+g} kHz" for k, f in itf)) if desc: print("channel: " + "; ".join(desc)) if a.lo_offset: print(f"front end: {a.lo_offset:+g} Hz LO offset without clock error " f"(receiver would infer {a.lo_offset / 223.58e6 * 1e6:+.1f} ppm)") if a.drift: print(f"front end: carrier drifting {a.drift:g} Hz/s (random sign)") if a.adc_bits: desc_adc = f"{a.adc_bits}-bit ADC, AGC 12 dB back-off" print("front end: " + desc_adc) if a.no_excise: print("receiver: interference excision off") if a.noncoherent: print("payload: non-coherent (index only)") if a.tracker != "adaptive": print(f"receiver: {a.tracker} channel tracker") for sf in a.sf: p = PhyParams(sf=sf, bw=a.bw, osr=a.osr, n_preamble=a.preamble) _, meta = build_frame(p, b"\0" * a.bytes, src="W1AW", coherent=not a.noncoherent) slots = len(payload_layout(meta["n_hdr"] + meta["n_pay"], p.pilot_every)[0]) air = (p.payload_start + slots * p.M) / p.bw print(f"SF{sf}: {a.bytes} B body + 7 B MAC, header {meta['n_hdr']} sym, " f"payload {meta['n_pay']} sym, ~{air:.2f} s on air at {p.bw / 1e3:.0f} kHz") print(f"{'SNR':>6} " + (f"{'SIR':>6} " if itf else "") + f"{'no-sync':>8} {'hdr-fail':>9} {'pay-fail':>9} {'ok':>6} {'x RT':>6} {'worst':>6}") for snr in a.snr: for sir in sirs: chan = dict(fading=a.fading, fd_hz=a.fd, k_db=a.k_db, itf=itf, sir_db=sir, adc_bits=a.adc_bits, lo_offset_hz=a.lo_offset, drift_hz_per_s=a.drift) t0 = time.time() r = run_point(p, snr, a.trials, a.bytes, a.seed, not a.no_id, a.clean, a.jobs, chan, not a.no_excise, a.tracker, not a.noncoherent) print(f"{snr:>6.1f} " + (f"{sir:>6.1f} " if itf else "") + f"{r['no_sync']:>8.3f} {r['header_fail']:>9.3f} " f"{r['payload_fail']:>9.3f} {r['ok']:>6.3f} {r['rt']:>6.1f} " f"{r['rt_worst']:>6.1f} " f"({time.time() - t0:.1f}s)", flush=True)