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.
98 lines
4.9 KiB
98 lines
4.9 KiB
#!/usr/bin/env python3 |
|
"""Turn a transmit recording into a simulated receiver capture. |
|
|
|
Models a Pluto-style transmitter and an RTL-SDR-style receiver as two radios |
|
with independent crystals: each crystal error scales that radio's LO *and* its |
|
sample clock. Then adds noise, a DC spike and 8-bit quantization. |
|
|
|
TX: tx_file.py output (SigMF, any rate), LO = core:frequency, crystal +tx-ppm |
|
RX: LO --rx-lo, rate --fs, crystal +rx-ppm, writes cu8 like rtl_sdr |
|
|
|
./tools/sim_capture.py hello cap --snr -10 --tx-ppm 12 --rx-ppm -30 |
|
./rx_file.py cap |
|
|
|
--snr is measured in the signal bandwidth (from the TX file's chirpmodem:bw). |
|
--lo-offset adds carrier offset with no clock error (a transverter LO). |
|
""" |
|
import os, sys |
|
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")) |
|
import argparse |
|
import numpy as np |
|
import iq_io |
|
from dsp import resample_at |
|
|
|
|
|
def main(): |
|
ap = argparse.ArgumentParser(description=__doc__, |
|
formatter_class=argparse.RawDescriptionHelpFormatter) |
|
ap.add_argument("tx", help="transmit recording (SigMF)") |
|
ap.add_argument("out", help="output capture base name") |
|
ap.add_argument("--fs", type=float, default=2.4e6, help="receiver sample rate") |
|
ap.add_argument("--rx-lo", type=float, help="receiver LO, Hz (default: signal - 250 kHz)") |
|
ap.add_argument("--snr", type=float, default=-5.0, help="SNR in the signal bandwidth, dB") |
|
ap.add_argument("--tx-ppm", type=float, default=10.0, help="transmitter crystal error") |
|
ap.add_argument("--rx-ppm", type=float, default=-35.0, help="receiver crystal error") |
|
ap.add_argument("--lo-offset", type=float, default=0.0, |
|
help="extra carrier offset with no clock error, Hz") |
|
ap.add_argument("--dc-db", type=float, default=0.0, |
|
help="DC spike power relative to total noise power, dB") |
|
ap.add_argument("--format", default="cu8", choices=["cu8", "ci8", "ci16_le", "cf32_le"]) |
|
ap.add_argument("--backoff-db", type=float, default=12.0, |
|
help="AGC: full scale above total RMS, dB") |
|
ap.add_argument("--lead", type=float, default=0.3, help="extra noise before, s") |
|
ap.add_argument("--seed", type=int, default=1) |
|
a = ap.parse_args() |
|
|
|
m = iq_io.read_sigmf_meta(a.tx) |
|
fs_tx, tx_lo, ext = m["fs"], m["fc"], m["ext"] |
|
bw = ext.get("bw", 125e3) |
|
sig_f = ext.get("signal_freq", tx_lo) |
|
rx_lo = a.rx_lo if a.rx_lo is not None else sig_f - 250e3 |
|
x = iq_io.read_raw(m["data_path"], m["fmt"]) |
|
anns = [an for an in m["meta"].get("annotations", []) |
|
if an.get("core:label", "").startswith("chirpmodem")] # frames only, not CW ID |
|
on = np.concatenate([x[an["core:sample_start"]:an["core:sample_start"] + an["core:sample_count"]] |
|
for an in anns]) if anns else x |
|
p_sig = float(np.mean(np.abs(on) ** 2)) |
|
|
|
ta, tb = a.tx_ppm * 1e-6, a.rx_ppm * 1e-6 |
|
# RX sample n is taken at t = n / (fs (1+tb)); TX sample k plays at k / (fs_tx (1+ta)) |
|
ratio = fs_tx * (1 + ta) / (a.fs * (1 + tb)) |
|
dfreq = (tx_lo * (1 + ta) + a.lo_offset - rx_lo * (1 + tb)) / (a.fs * (1 + tb)) |
|
n_lead = int(a.lead * a.fs) |
|
n_out = n_lead + int(len(x) / ratio) |
|
sigma2 = p_sig * a.fs / (bw * 10 ** (a.snr / 10)) |
|
dc = np.sqrt(sigma2 * 10 ** (a.dc_db / 10)) * np.exp(1j * 0.7) |
|
rms = np.sqrt(sigma2 + p_sig * len(on) / len(x) + abs(dc) ** 2) |
|
full = rms / np.sqrt(2) * 10 ** (a.backoff_db / 20) |
|
|
|
rng = np.random.default_rng(a.seed) |
|
meta_path, data_path = iq_io.sigmf_paths(a.out) |
|
open(data_path, "wb").close() |
|
cutoff = min(1.0, a.fs / fs_tx) |
|
clipped = 0 |
|
for s in range(0, n_out, 1 << 20): |
|
n = np.arange(s, min(n_out, s + (1 << 20))) |
|
y = resample_at(x, (n - n_lead) * ratio, cutoff=cutoff) |
|
y = y * np.exp(2j * np.pi * ((dfreq * n) % 1.0)) |
|
y = y + dc + np.sqrt(sigma2 / 2) * (rng.standard_normal(len(n)) + |
|
1j * rng.standard_normal(len(n))) |
|
y = y / full |
|
clipped += int(np.sum((np.abs(y.real) > 1) | (np.abs(y.imag) > 1))) |
|
iq_io.write_raw(data_path, y, a.format, append=True) |
|
|
|
truth = dict(sim_snr_db=a.snr, sim_tx_ppm=a.tx_ppm, sim_rx_ppm=a.rx_ppm, |
|
sim_lo_offset=a.lo_offset, |
|
sim_expected_offset_hz=(sig_f * (1 + ta) + a.lo_offset) / (1 + tb) - sig_f) |
|
iq_io.write_sigmf_meta(a.out, a.format, a.fs, rx_lo, |
|
description=f"simulated capture of {os.path.basename(a.tx)}", |
|
extra=truth) |
|
print(f"wrote {meta_path} + {data_path}: {n_out} samples, {n_out / a.fs:.2f} s at " |
|
f"{a.fs / 1e6:g} MS/s ({a.format}), RX LO {rx_lo / 1e6:.6f} MHz") |
|
print(f" signal at {sig_f / 1e6:.6f} MHz nominal, {truth['sim_expected_offset_hz']:+.0f} Hz " |
|
f"offset as seen by the receiver; SNR {a.snr:+.1f} dB in {bw / 1e3:g} kHz; " |
|
f"{clipped} clipped samples") |
|
|
|
|
|
if __name__ == "__main__": |
|
main()
|
|
|