#!/usr/bin/env python3 """Unattended long run: Pluto -> attenuator -> RTL-SDR, decoded live. Transmits one frame in a loop for --hours at a fixed TX gain while the streaming receiver (c/cm_rx if built, else stream_rx.py) decodes the RTL-SDR in real time. At the end it reports delivery, any frame whose body is wrong, the receiver's load, and how SNR and the frequency offset moved over the run. Every decoded frame goes to _soak.ods (odfpy) or .csv. Run it cabled through attenuators: nothing should radiate for hours. ./soak_test.py --hours 2 # SF12 62.5 kHz, -78 dB TX (~ -24 dB SNR) ./soak_test.py --hours 8 --tx-gain -76 --sf 12 --decoder python """ import argparse, os, re, shutil, signal, subprocess, sys, threading, time import numpy as np HERE = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, HERE) import iq_io from sweep_test import write_table def main(): ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("--src", default="KD2HSG") ap.add_argument("--sf", type=int, default=12) ap.add_argument("--bw", type=float, default=62.5e3) ap.add_argument("--freq", type=float, default=223.58e6) ap.add_argument("--hours", type=float, default=2.0) ap.add_argument("--tx-gain", type=float, default=-78.0, help="Pluto TX gain, dB") ap.add_argument("--rx-gain", type=float, default=49.6, help="RTL gain, dB") ap.add_argument("--rx-fs", type=float, default=1e6) ap.add_argument("--rx-if", type=float, default=250e3) ap.add_argument("--tx-if", type=float, default=100e3) ap.add_argument("--uri", default="ip:192.168.2.1") ap.add_argument("--rtl-device", default="0") ap.add_argument("--decoder", choices=["auto", "c", "python"], default="auto") ap.add_argument("--coherent", action="store_true") ap.add_argument("--noncoherent", action="store_true") ap.add_argument("--status", type=float, default=300.0, help="load report interval, s") ap.add_argument("--name", default="soak") a = ap.parse_args() if not shutil.which("rtl_sdr"): sys.exit("rtl_sdr not found on PATH") cm_rx = os.path.join(HERE, "c", "cm_rx") use_c = a.decoder == "c" or (a.decoder == "auto" and os.access(cm_rx, os.X_OK)) if a.decoder == "c" and not os.access(cm_rx, os.X_OK): sys.exit("c/cm_rx not built: (cd c && make)") msg = f"soak de {a.src}" rec, py = f"{a.name}_tx", sys.executable cmd = [py, os.path.join(HERE, "tx_file.py"), rec, "--src", a.src, "--msg", msg, "--sf", str(a.sf), "--bw", repr(a.bw), "--freq", repr(a.freq), "--if-offset", repr(a.tx_if), "--repeat", "1", "--gap", "0.5"] + \ (["--coherent"] if a.coherent else []) + (["--noncoherent"] if a.noncoherent else []) subprocess.run(cmd, check=True) m = iq_io.read_sigmf_meta(rec) loop_s = iq_io.recording_samples(rec) / m["fs"] seconds = a.hours * 3600 expect = seconds / loop_s rx_lo = a.freq - a.rx_if log_path = f"{a.name}_soak.log" pluto = subprocess.Popen([py, os.path.join(HERE, "tools", "pluto_tx.py"), rec, "--uri", a.uri, "--gain", repr(a.tx_gain), "--seconds", repr(seconds + 120)], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, env=dict(os.environ, PYTHONUNBUFFERED="1")) t_start = time.time() rtl = stop = None try: while True: line = pluto.stdout.readline() if not line: sys.exit(f"pluto_tx exited (code {pluto.wait()}) before transmitting") print(" pluto: " + line.rstrip(), flush=True) if "looping" in line: break time.sleep(1.0) # rtl_sdr computes -n x 2 bytes in 32 bits, so past 2^31 samples (35.8 min # at 1 MS/s) the count wraps and it stops early (an hour ended at 1452.5 s). # Longer runs stream without -n and are stopped by a timer instead. n_samp = int(seconds * a.rx_fs) use_n = 2 * n_samp < 2 ** 32 rtl = subprocess.Popen(["rtl_sdr", "-d", a.rtl_device, "-f", str(int(round(rx_lo))), "-s", str(int(a.rx_fs)), "-g", repr(a.rx_gain)] + (["-n", str(n_samp)] if use_n else []) + ["-"], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL) if not use_n: stop = threading.Timer(seconds, rtl.terminate) stop.daemon = True stop.start() if use_c: dec = [cm_rx, "-", "--fs", repr(a.rx_fs), "--lo", repr(rx_lo), "--freq", repr(a.freq), "--sf", str(a.sf), "--bw", repr(a.bw), "--status", repr(a.status), "-v"] else: dec = [py, os.path.join(HERE, "stream_rx.py"), "-", "--format", "cu8", "--fs", repr(a.rx_fs), "--lo", repr(rx_lo), "--freq", repr(a.freq), "--sf", str(a.sf), "--bw", repr(a.bw), "--status", repr(a.status), "-v"] print(f"$ rtl_sdr ... | {' '.join(os.path.basename(c) if i == 0 else c for i, c in enumerate(dec))}" f"\n{a.hours:g} h, ~{expect:.0f} frames expected; log in {log_path}", flush=True) with open(log_path, "w") as log: d = subprocess.Popen(dec, stdin=rtl.stdout, stdout=subprocess.PIPE, text=True, env=dict(os.environ, PYTHONUNBUFFERED="1")) rtl.stdout.close() for line in d.stdout: log.write(line) log.flush() if not line.lstrip().startswith("SNR"): print(line.rstrip(), flush=True) d.wait() rtl.wait() except KeyboardInterrupt: print("\ninterrupted") finally: if stop is not None: stop.cancel() if rtl is not None and rtl.poll() is None: rtl.terminate() if pluto.poll() is None: pluto.send_signal(signal.SIGINT) try: pluto.communicate(timeout=10) except subprocess.TimeoutExpired: pluto.kill() print("Pluto stopped") summarize(log_path, a.src, msg, seconds, expect, a.name) print(f"wall time {(time.time() - t_start) / 3600:.2f} h") def summarize(log_path, src, msg, seconds, expect, name): lines = open(log_path).read().splitlines() if os.path.exists(log_path) else [] rows, wrong, fails = [], 0, 0 head = re.compile(r"\[\s*([\d.]+) s\] (\S+?)(?: -> \S+)?: (.*)$") snr = re.compile(r"SNR ([+-][\d.]+) dB, offset ([+-][\d.]+) Hz") for i, ln in enumerate(lines): if "preamble found" in ln: fails += 1 continue h = head.search(ln) if not h or i + 1 >= len(lines): continue s = snr.search(lines[i + 1]) if not s: continue ok = h.group(2) == src.upper() and h.group(3) == repr(msg) wrong += not ok rows.append(dict(t_s=float(h.group(1)), snr_db=float(s.group(1)), offset_hz=float(s.group(2)), body_ok=ok, flags=lines[i + 1].split(";", 1)[1].strip() if ";" in lines[i + 1] else "")) n = len(rows) print(f"\n{n} frames decoded of ~{expect:.0f} ({n / expect:.1%}); {fails} failed after sync; " f"{wrong} with a wrong source or body" + (" <-- investigate" if wrong else "")) load = [ln for ln in lines if "load" in ln] if load: print("last load report: " + load[-1].strip()) if n: t = np.array([r["t_s"] for r in rows]) for lo_t in np.arange(0, seconds, 3600): sel = [r for r in rows if lo_t <= r["t_s"] < lo_t + 3600] if sel: print(f" hour {int(lo_t // 3600) + 1}: {len(sel)} frames, SNR median " f"{np.median([r['snr_db'] for r in sel]):+.1f} dB, offset " f"{min(r['offset_hz'] for r in sel):+.1f} to {max(r['offset_hz'] for r in sel):+.1f} Hz") print(f"results: {write_table(rows, name + '_soak')}") if __name__ == "__main__": main()