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.
100 lines
4.6 KiB
100 lines
4.6 KiB
#!/usr/bin/env python3 |
|
"""Packet error rate: uncoded (CRC only) vs soft-decision QC-LDPC. |
|
|
|
Each trial sends one packet of --bytes random payload through the full |
|
impairment channel. "uncoded" = payload + CRC on hard decisions; |
|
"ldpc" = CRC + shortened rate-1/2 QC-LDPC, interleaved, exact soft demap. |
|
"ldpc+ID" = same received samples, iterative demapping and decoding (BICM-ID). |
|
|
|
Usage: |
|
./sim_fec.py --sf 7 --snr -12 -10 -8 --trials 50 |
|
./sim_fec.py --sf 12 --snr -24 -22 -20 --trials 15 --bytes 16 |
|
./sim_fec.py --sf 7 --snr -12 -11 -10 --trials 400 --jobs 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, modulate |
|
from channel import ChannelConfig, apply_channel |
|
from rx import receive, receive_soft, demap_extrinsic |
|
from fec import PayloadCodec, crc16, crc32, bytes_to_bits, bits_to_bytes |
|
|
|
|
|
def impaired_cfg(rng, p, snr_db): |
|
return 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) |
|
|
|
|
|
def _trial(rng, p, snr_db, n_bytes, coherent): |
|
"""One packet each way -> (ok uncoded, ok ldpc, ok ldpc+ID, ldpc iters, ID outer).""" |
|
codec = PayloadCodec(n_bytes, p.bits_per_symbol) |
|
crc_f = crc16 if codec.crc_bits == 16 else crc32 |
|
data = rng.bytes(n_bytes) |
|
ok_u = ok_c = ok_i = 0 |
|
iters = outer = np.nan |
|
|
|
# uncoded reference: payload + CRC, hard decisions |
|
ub = bytes_to_bits(data + crc_f(data).to_bytes(codec.crc_bits // 8, "big")) |
|
y, _ = apply_channel(modulate(ub, p), p, impaired_cfg(rng, p, snr_db), rng) |
|
out, _, _ = receive(y, p, len(ub)) |
|
if out is not None: |
|
d = bits_to_bytes(out[:8 * n_bytes]) |
|
c = int.from_bytes(bits_to_bytes(out[8 * n_bytes:len(ub)]), "big") |
|
ok_u = int(c == crc_f(d) and d == data) |
|
|
|
# coded: one channel realization, decoded two ways |
|
cb = codec.encode(data) |
|
y, _ = apply_channel(modulate(cb, p), p, impaired_cfg(rng, p, snr_db), rng) |
|
llr, _, info = receive_soft(y, p, codec.n_sym, coherent=coherent) |
|
if llr is not None: |
|
d, inf = codec.decode(llr) |
|
ok_c, iters = int(d == data), inf["iters"] |
|
yr, yi, bps = info["yr"], info["yi"], p.bits_per_symbol |
|
S = yr.shape[0] |
|
d, inf = codec.decode_iterative( |
|
lambda La: demap_extrinsic(yr, yi, p.sf, La.reshape(S, bps)).reshape(-1)) |
|
ok_i, outer = int(d == data), inf["outer"] |
|
return ok_u, ok_c, ok_i, iters, outer |
|
|
|
|
|
def run_point(p, snr_db, trials, n_bytes, seed, coherent=True, jobs=1): |
|
fn = partial(_trial, p=p, snr_db=snr_db, n_bytes=n_bytes, coherent=coherent) |
|
r = np.array(parallel.run_trials(fn, trials, seed, jobs), dtype=float) |
|
ok = r[:, :3].mean(axis=0) |
|
return (1 - ok[0], 1 - ok[1], 1 - ok[2], |
|
np.nanmean(r[:, 3]) if np.any(~np.isnan(r[:, 3])) else np.nan, |
|
np.nanmean(r[:, 4]) if np.any(~np.isnan(r[:, 4])) else np.nan) |
|
|
|
|
|
if __name__ == "__main__": |
|
ap = argparse.ArgumentParser() |
|
ap.add_argument("--sf", type=int, nargs="+", default=[7]) |
|
ap.add_argument("--snr", type=float, nargs="+", default=[-12, -10, -8]) |
|
ap.add_argument("--trials", type=int, default=50) |
|
ap.add_argument("--bytes", type=int, default=32) |
|
ap.add_argument("--osr", type=int, default=2) |
|
ap.add_argument("--seed", type=int, default=0) |
|
ap.add_argument("--noncoherent", action="store_true", |
|
help="phase-free index metric in the soft demapper") |
|
ap.add_argument("--jobs", type=int, default=parallel.default_jobs(), |
|
help="worker processes (default: all cores)") |
|
a = ap.parse_args() |
|
for sf in a.sf: |
|
p = PhyParams(sf=sf, osr=a.osr) |
|
c = PayloadCodec(a.bytes, p.bits_per_symbol) |
|
u_sym = -(-(8 * a.bytes + c.crc_bits) // p.bits_per_symbol) |
|
print(f"SF{sf} {a.bytes} B payload CRC-{c.crc_bits} Z={c.Z} " |
|
f"coded: {c.n_sym} sym ({c.rate * p.raw_bitrate / 1e3:.2f} kbps net) " |
|
f"uncoded: {u_sym} sym ({8 * a.bytes / (u_sym * p.M / p.bw) / 1e3:.2f} kbps net)") |
|
print(f"{'SNR':>6} {'PER uncoded':>12} {'PER ldpc':>9} {'PER ldpc+ID':>12} {'iters':>6} {'outer':>6}") |
|
for snr in a.snr: |
|
t0 = time.time() |
|
pu, pc, pi_, it, ot = run_point(p, snr, a.trials, a.bytes, a.seed, not a.noncoherent, a.jobs) |
|
print(f"{snr:>6.1f} {pu:>12.3f} {pc:>9.3f} {pi_:>12.3f} {it:>6.1f} {ot:>6.1f}" |
|
f" ({time.time() - t0:.1f}s)", flush=True)
|
|
|