You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
131 lines
6.1 KiB
131 lines
6.1 KiB
#!/usr/bin/env python3 |
|
"""Pluto -> RTL-SDR loopback test: make a recording, transmit it in the |
|
background, capture with rtl_sdr at the same time, then decode. |
|
|
|
Every frequency comes from --freq and the two IF offsets, so the |
|
transmitter, the capture and the decoder can't disagree: |
|
|
|
Pluto LO = freq - tx_if (signal sits tx_if above it) |
|
RTL LO = freq - rx_if (signal sits rx_if above it, clear of DC) |
|
|
|
./ota_test.py # SF9, 62.5 kHz, 223.580 MHz |
|
./ota_test.py --sf 12 --seconds 20 --rx-gain 25 |
|
./ota_test.py --sf 7 --msg "hello" --repeat 10 --cw-id |
|
|
|
The Pluto is always stopped on exit, including Ctrl-C and errors. |
|
Files: <name>_tx.sigmf-meta/-data (transmitted) and <name>.cu8 (capture). |
|
""" |
|
import argparse, os, shutil, signal, subprocess, sys, time |
|
|
|
HERE = os.path.dirname(os.path.abspath(__file__)) |
|
|
|
|
|
def show(cmd): |
|
print("$ " + " ".join(cmd), flush=True) |
|
|
|
|
|
def main(): |
|
ap = argparse.ArgumentParser(description=__doc__, |
|
formatter_class=argparse.RawDescriptionHelpFormatter) |
|
ap.add_argument("--src", default="KD2HSG", help="your callsign") |
|
ap.add_argument("--msg", default=None, help="message (default 'test de <src>')") |
|
ap.add_argument("--sf", type=int, default=9) |
|
ap.add_argument("--bw", type=float, default=62.5e3) |
|
ap.add_argument("--freq", type=float, default=223.58e6, help="signal center, Hz") |
|
ap.add_argument("--repeat", type=int, default=5, help="frames per recording") |
|
ap.add_argument("--gap", type=float, default=0.5, help="seconds between frames") |
|
ap.add_argument("--cw-id", action="store_true", help="CW ID after the frames") |
|
ap.add_argument("--coherent", action="store_true", |
|
help="coherent payload (index + QPSK); default only at SF 7-9 above 62.5 kHz") |
|
ap.add_argument("--noncoherent", action="store_true", |
|
help="index-only payload; default at SF >= 10 and at <= 62.5 kHz") |
|
ap.add_argument("--tx-fs", type=float, default=1e6) |
|
ap.add_argument("--tx-if", type=float, default=100e3, help="signal offset above Pluto LO") |
|
ap.add_argument("--tx-gain", type=float, default=-30.0, help="Pluto TX gain, dB") |
|
ap.add_argument("--uri", default="ip:192.168.2.1", help="Pluto URI") |
|
ap.add_argument("--rx-fs", type=float, default=2.4e6) |
|
ap.add_argument("--rx-if", type=float, default=250e3, help="signal offset above RTL LO") |
|
ap.add_argument("--rx-gain", type=float, default=30.0, help="RTL-SDR tuner gain, dB") |
|
ap.add_argument("--rtl-device", default="0", help="rtl_sdr -d index or serial") |
|
ap.add_argument("--seconds", type=float, default=12.0, help="capture length") |
|
ap.add_argument("--name", default="ota", help="file name prefix") |
|
a = ap.parse_args() |
|
|
|
if not shutil.which("rtl_sdr"): |
|
sys.exit("rtl_sdr not found on PATH") |
|
msg = a.msg or f"test de {a.src}" |
|
tx_rec, cap = f"{a.name}_tx", f"{a.name}.cu8" |
|
rx_lo = a.freq - a.rx_if |
|
py = sys.executable |
|
|
|
# 1. transmit recording |
|
cmd = [py, os.path.join(HERE, "tx_file.py"), tx_rec, "--src", a.src, "--msg", msg, |
|
"--sf", str(a.sf), "--bw", repr(a.bw), "--fs", repr(a.tx_fs), |
|
"--freq", repr(a.freq), "--if-offset", repr(a.tx_if), |
|
"--repeat", str(a.repeat), "--gap", repr(a.gap)] + (["--cw-id"] if a.cw_id else []) \ |
|
+ (["--noncoherent"] if a.noncoherent else []) \ |
|
+ (["--coherent"] if a.coherent else []) |
|
show(cmd) |
|
subprocess.run(cmd, check=True) |
|
sys.path.insert(0, HERE) |
|
import iq_io |
|
n = iq_io.recording_samples(tx_rec) |
|
if n > iq_io.PLUTO_MAX_SAMPLES and a.repeat > 1: # Pluto TX buffer limit |
|
rep = max(1, int(a.repeat * iq_io.PLUTO_MAX_SAMPLES / n)) |
|
print(f"recording too large for the Pluto's buffer ({n / 1e6:.1f} M samples); " |
|
f"remaking with {rep} frame(s)", flush=True) |
|
cmd[cmd.index("--repeat") + 1] = str(rep) |
|
show(cmd) |
|
subprocess.run(cmd, check=True) |
|
if iq_io.recording_samples(tx_rec) > iq_io.PLUTO_MAX_SAMPLES: |
|
sys.exit("even one frame exceeds the Pluto's buffer; lower --tx-fs") |
|
|
|
# 2. Pluto in the background; wait until it reports it is transmitting |
|
cmd = [py, os.path.join(HERE, "tools", "pluto_tx.py"), tx_rec, "--uri", a.uri, |
|
"--gain", repr(a.tx_gain), "--seconds", repr(a.seconds + 60)] |
|
show(cmd) |
|
pluto = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, |
|
env=dict(os.environ, PYTHONUNBUFFERED="1")) |
|
try: |
|
t0 = time.time() |
|
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 |
|
if time.time() - t0 > 30: |
|
sys.exit("pluto_tx didn't start within 30 s") |
|
time.sleep(1.0) # let the buffer start playing |
|
|
|
# 3. capture while it transmits |
|
cmd = ["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(int(a.seconds * a.rx_fs)), cap] |
|
show(cmd) |
|
r = subprocess.run(cmd) |
|
if r.returncode != 0: |
|
sys.exit(f"rtl_sdr failed (code {r.returncode})") |
|
finally: |
|
# 4. always stop the transmitter |
|
if pluto.poll() is None: |
|
pluto.send_signal(signal.SIGINT) |
|
try: |
|
out, _ = pluto.communicate(timeout=10) |
|
except subprocess.TimeoutExpired: |
|
pluto.kill() |
|
out, _ = pluto.communicate() |
|
for line in (out or "").splitlines(): |
|
print(" pluto: " + line) |
|
|
|
# 5. decode |
|
cmd = [py, os.path.join(HERE, "rx_file.py"), cap, "--format", "cu8", |
|
"--fs", repr(a.rx_fs), "--lo", repr(rx_lo), "--freq", repr(a.freq), |
|
"--sf", str(a.sf), "--bw", repr(a.bw), "-v"] |
|
show(cmd) |
|
sys.exit(subprocess.run(cmd).returncode) |
|
|
|
|
|
if __name__ == "__main__": |
|
main()
|
|
|