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.
 
 
 
 
 

88 lines
4.4 KiB

#!/usr/bin/env python3
"""Write format-v1 test vectors (vectors/*.json + *.cf32) for other
implementations.
Each vector gives a frame's inputs (PHY parameters, profile, callsigns, body)
and every intermediate an implementation can be checked against, exactly:
the packed MAC frame, the header word, the on-air bits of header and payload
(modulator order, after interleaving and whitening), and each data symbol's
(index, QPSK bits). The waveform at osr = 2 is in <name>.cf32 (interleaved
float32 I/Q, little-endian) and is to be matched to a tolerance (~1e-5),
since sin/cos differ in the last bits between math libraries.
./tools/make_vectors.py # -> vectors/
"""
import os, sys, json, hashlib
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, ".."))
import numpy as np
from phy import PhyParams, bits_to_symbols, inv_gray, bits_per_symbol
from frame import (build_frame, header_codec, Header, MacFrame, LICENSED, UNLICENSED,
MODE_COHERENT, MODE_NONCOHERENT)
from fec import SegmentedCodec
CASES = [
dict(name="sf7_coherent_hello", sf=7, bw=125e3, coherent=True, profile=LICENSED,
src="KD2HSG", dst=None, body=b"hello"),
dict(name="sf9_noncoherent_cq", sf=9, bw=62.5e3, coherent=False, profile=LICENSED,
src="KD2HSG", dst="W1AW", body=b"CQ CQ de KD2HSG"),
dict(name="sf12_coherent_40B", sf=12, bw=62.5e3, coherent=True, profile=LICENSED,
src="KD2HSG", dst=None, body=bytes(range(40))),
dict(name="sf9_coherent_segmented_1200B", sf=9, bw=125e3, coherent=True, profile=LICENSED,
src="KD2HSG", dst=None, body=bytes((i * 7 + 3) % 251 for i in range(1200))),
dict(name="sf8_unlicensed_encrypted", sf=8, bw=250e3, coherent=True, profile=UNLICENSED,
src=None, dst=None, body=bytes.fromhex("8f1e2d3c4b5a69788796a5b4c3d2e1f0"),
encrypted=True),
]
def bitstr(b):
return "".join("1" if v else "0" for v in np.asarray(b, np.uint8))
def main():
out = os.path.join(HERE, "..", "vectors")
os.makedirs(out, exist_ok=True)
index = []
for c in CASES:
p = PhyParams(sf=c["sf"], bw=c["bw"], osr=2)
enc = c.get("encrypted", False)
iq, meta = build_frame(p, c["body"], profile=c["profile"], src=c["src"], dst=c["dst"],
encrypted=enc, coherent=c["coherent"])
mac = MacFrame(body=c["body"], src=c["src"], dst=c["dst"]).pack()
hdr = Header(length=len(mac), profile=c["profile"], encrypted=enc,
mode=MODE_COHERENT if c["coherent"] else MODE_NONCOHERENT).pack()
hc = header_codec(p)
pc = SegmentedCodec(len(mac), bits_per_symbol(p, c["coherent"]))
hbits, pbits = hc.encode(hdr), pc.encode(mac)
hi, ha = bits_to_symbols(hbits, p, coherent=False)
pi, pa = bits_to_symbols(pbits, p, coherent=c["coherent"])
q = lambda a: ((a.real < 0).astype(int) * 2 + (a.imag < 0).astype(int)).tolist()
wav = np.empty(2 * len(iq), np.float32)
wav[0::2], wav[1::2] = iq.real, iq.imag
wav.tofile(os.path.join(out, c["name"] + ".cf32"))
v = dict(
name=c["name"], format_version=1,
params=dict(sf=p.sf, bw=p.bw, osr=p.osr, n_preamble=p.n_preamble,
sync_word=p.sync_word, pilot_every=p.pilot_every,
coherent=c["coherent"]),
profile=c["profile"], src=c["src"], dst=c["dst"], encrypted=enc,
body_hex=c["body"].hex(), mac_frame_hex=mac.hex(), header_hex=hdr.hex(),
n_hdr_sym=hc.n_sym, n_pay_sym=pc.n_sym,
segments=[s.n_bytes for s in pc.segs],
header_bits=bitstr(hbits), payload_bits=bitstr(pbits),
header_symbols=[[int(i), int(b)] for i, b in zip(hi, q(ha))],
payload_symbols=[[int(i), int(b)] for i, b in zip(pi, q(pa))],
waveform=dict(file=c["name"] + ".cf32", n_samples=len(iq),
rms=float(np.sqrt(np.mean(np.abs(iq) ** 2))),
sha256_float32=hashlib.sha256(wav.tobytes()).hexdigest()))
with open(os.path.join(out, c["name"] + ".json"), "w") as f:
json.dump(v, f, indent=1)
index.append(c["name"])
print(f"{c['name']}: {hc.n_sym} + {pc.n_sym} symbols, {len(iq)} samples")
with open(os.path.join(out, "index.json"), "w") as f:
json.dump(index, f, indent=1)
if __name__ == "__main__":
main()