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

#!/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)