"""Reference receiver (sparse end, K = 1). Pipeline 1. decimate to the chip rate (anti-alias) 2. detect the repeated up-chirps (non-coherent FFT combining) -> bin b_up = f - tau 3. find the down-chirp -> bin b_dn = f + tau; separate CFO f and timing tau 4. refine at the exact frame alignment: fractional CFO from the phase advance between consecutive preamble symbols, sub-bin peaks with a Jacobsen estimator 5. derotate CFO, resample the *original* samples on the TX chip grid (sample-clock error eps is derived from the CFO: shared-crystal model) 6. dechirp + FFT every payload symbol; pilots give the bin offset, carrier phase and sub-chip timing; hard decisions on index (Gray) and QPSK """ from dataclasses import dataclass import numpy as np from dsp import resample_at, wrap, jacobsen from phy import (PhyParams, base_chirp_chips, inv_gray, qpsk_demap, bits_to_symbols, payload_layout, n_symbols_for_bits) @dataclass class Sync: T: int # integer frame start in chip-rate buffer tau0: float # fractional frame start (chips, chip-rate buffer) f_bins: float # CFO in FFT bins (bin = bw/M Hz) f_hz: float eps: float # sample-clock error implied by CFO metric: float # detection metric def excise(x, p, thresh_db=8.0, nfft=1024, dilate=2): """Notch strong narrowband interference before demodulation. A chirp's spectrum is flat across the signal band, so any spectral region standing well above the in-band median is something else: a carrier, an FM voice signal, a spur. Average the spectrum over the whole buffer (Welch, Hann, 50% overlap), mark bins more than ``thresh_db`` above the in-band median (plus ``dilate`` bins either side for window leakage), and zero those frequencies in one FFT of the buffer. Notching a fraction q of the band costs the signal roughly 20*log10(1-q) dB; an unexcised interferer costs it everything once the interference exceeds the processing gain. Returns (x_clean, notched_fraction_of_signal_band). """ x = np.asarray(x, np.complex128) x = x - x.mean() # DC is handled separately; don't notch it N = len(x) if N < 2 * nfft: return x, 0.0 hop = nfft // 2 win = np.hanning(nfft) nseg = (N - nfft) // hop + 1 idx = np.arange(nseg)[:, None] * hop + np.arange(nfft)[None, :] psd = np.mean(np.abs(np.fft.fft(x[idx] * win, axis=1)) ** 2, axis=0) f = np.fft.fftfreq(nfft, 1 / p.fs) inband = np.abs(f) < p.bw / 2 mask = psd > np.median(psd[inband]) * 10 ** (thresh_db / 10) if not mask.any(): return x, 0.0 mask = np.convolve(mask.astype(int), np.ones(2 * dilate + 1, int), "same") > 0 q = float(mask[inband].mean()) X = np.fft.fft(x) fb = np.fft.fftfreq(N, 1 / p.fs) kbin = np.round(fb / (p.fs / nfft)).astype(int) % nfft # full bin -> Welch bin X[mask[kbin]] = 0 return np.fft.ifft(X), q def decimate(x, p): if p.osr == 1: return np.asarray(x, complex) pos = np.arange(0, len(x), p.osr, dtype=np.float64) return resample_at(x, pos, cutoff=1.0 / p.osr) def _win_fft(r, start, M, ref): return np.fft.fft(r[start:start + M] * ref) P_DET = 2 # zero-padding factor of the detection FFT def preamble_metric(r, p, block=4096): """Detection metric for a preamble starting in each M-chip window of r. 2x zero-padded FFT: a tone between bins loses up to 3.9 dB in a plain M-point FFT, but at most ~0.9 dB on the half-bin grid. Consistency metric: at the bin that wins the combined spectrum of L consecutive windows, every one of them must show a peak; geometric mean of the per-window peak/mean ratios (a lone strong window, e.g. a pilot next to quiet windows, scores low). Returns (metric[k], winning bin B[k] on the half-bin grid). """ M, L = p.M, p.n_preamble - 1 cu = np.conj(base_chirp_chips(M)) nw = len(r) // M if nw < L: return np.zeros(0), np.zeros(0, int) W = r[:nw * M].reshape(nw, M) Eu = np.empty((nw, P_DET * M)) for a in range(0, nw, block): # bounded memory on long captures Eu[a:a + block] = np.abs(np.fft.fft(W[a:a + block] * cu, n=P_DET * M, axis=1)) ** 2 cs = np.vstack([np.zeros((1, P_DET * M)), np.cumsum(Eu, axis=0)]) S = cs[L:] - cs[:-L] # S[k] = sum of windows k..k+L-1 nk = S.shape[0] B = np.argmax(S, axis=1) ratio = Eu / Eu.mean(axis=1, keepdims=True) lg = np.zeros(nk) for i in range(L): lg += np.log(ratio[np.arange(nk) + i, B] + 1e-12) return np.exp(lg / L), B def detect_all(r, p, det_thresh=4.0): """All preamble candidates in a long chip-rate buffer, in time order. Returns window indices k (preamble starts near chip k*M), strongest first within each cluster: one candidate per preamble (non-maximum suppression over n_preamble windows). """ metric, _ = preamble_metric(r - r.mean(), p) cand = np.where(metric >= det_thresh)[0] keep = [] for k in cand[np.argsort(-metric[cand])]: if all(abs(k - j) > p.n_preamble for j in keep): keep.append(int(k)) return sorted(keep), metric def acquire(r, p, det_thresh=4.0): M, n_pre = p.M, p.n_preamble s1, s2 = p.sync_shifts r = r - r.mean() up = base_chirp_chips(M) cu = np.conj(up) nw = len(r) // M L = n_pre - 1 if nw < n_pre + 6: return None W = r[:nw * M].reshape(nw, M) P = P_DET metric, B = preamble_metric(r, p) k = int(np.argmax(metric)) if metric[k] < det_thresh: return None bu = B[k] / P # up-chirp bin = f - tau (mod M) # Align windows to the symbol boundaries implied by the up-chirps, assuming # f = 0: frame start T_m = (-bu mod M) + m*M. The true start is T_m + f, so # on these windows the sync up-chirps dechirp to exactly their shifts # (independent of f), and both full down-chirps dechirp to bin 2f, which # can be combined. Score every whole-symbol hypothesis m with all four. def pk(X, c, tol=1): return max(abs(X[(c + d) % len(X)]) ** 2 for d in range(-tol, tol + 1)) tau_g = (-bu) % M best = None for m in range(k - 3, k + 2): Tm = int(round(tau_g + m * M)) if Tm < 0 or Tm + int((n_pre + 4.25) * M) + M > len(r): continue Xs1 = np.fft.fft(r[Tm + n_pre * M:Tm + (n_pre + 1) * M] * cu) Xs2 = np.fft.fft(r[Tm + (n_pre + 1) * M:Tm + (n_pre + 2) * M] * cu) D = sum(np.abs(np.fft.fft(r[Tm + (n_pre + 2 + j) * M:Tm + (n_pre + 3 + j) * M] * up, n=P * M)) ** 2 for j in range(2)) bd = int(np.argmax(D)) E = D[bd] / P + pk(Xs1, s1) + pk(Xs2, s2) if best is None or E > best[0]: best = (E, Tm, bd / P) if best is None: return None _, Tm, bd = best f_c = wrap(bd, M) / 2.0 # |f| < M/4 T = int(round(Tm + f_c)) if T < 0 or T + int((n_pre + 4.25) * M) > len(r): return None # ---- fine estimation at aligned windows Xu = np.array([_win_fft(r, T + i * M, M, cu) for i in range(n_pre)]) b = int(np.argmax((np.abs(Xu) ** 2).sum(axis=0))) ph = np.angle(np.sum(Xu[1:, b] * np.conj(Xu[:-1, b]))) f_frac = ph / (2 * np.pi) rot = np.exp(-2j * np.pi * f_frac * np.arange(n_pre)) bu_r = wrap(b + jacobsen(rot @ Xu, b), M) Xd = np.array([_win_fft(r, T + (n_pre + 2 + j) * M, M, up) for j in range(2)]) bdi = int(np.argmax((np.abs(Xd) ** 2).sum(axis=0))) Yd = Xd[0] + Xd[1] * np.exp(-2j * np.pi * f_frac) bd_r = wrap(bdi + jacobsen(Yd, bdi), M) f_real = f_frac + np.round((bu_r + bd_r) / 2 - f_frac) tau_r = (bd_r - bu_r) / 2 f_hz = f_real * p.bw / M return Sync(T=T, tau0=float(T + tau_r), f_bins=float(f_real), f_hz=float(f_hz), eps=float(f_hz / p.fc), metric=float(metric[k])) def extract_frame(x, sync, p, n_chips): """Derotate CFO, drop DC, resample original samples onto the TX chip grid. Only the span of ``x`` the resampler touches is derotated. The DC estimate still uses the whole buffer. """ m = np.arange(n_chips) pos = p.osr * (sync.tau0 + m / (1.0 + sync.eps)) margin = 16 * p.osr + 2 # > resampler half-width (6 * osr) lo = max(0, int(np.floor(pos[0])) - margin) hi = min(len(x), int(np.ceil(pos[-1])) + margin) if hi <= lo: return np.zeros(n_chips, complex) n = np.arange(lo, hi) xd = (x[lo:hi] - x.mean()) * np.exp(-2j * np.pi * sync.f_hz * n / p.fs) return resample_at(xd, pos - lo, cutoff=1.0 / p.osr) def refine(x, sync, p, iters=3): """Iterative fine sync on the clock-corrected chip grid. In the raw RX grid the sample-clock error makes the timing offset drift across the preamble (~1 chip per 50k chips at 20 ppm), which biases the up/down-chirp estimates. Resampling with the current eps estimate makes the residual offset constant, so the up/down pair measures it without bias. eps follows the CFO under the shared-crystal model. """ M, n_pre = p.M, p.n_preamble up = base_chirp_chips(M) cu = np.conj(up) for _ in range(iters): z = extract_frame(x, sync, p, p.payload_start) Xu = np.array([np.fft.fft(z[i * M:(i + 1) * M] * cu) for i in range(n_pre)]) b = int(np.argmax((np.abs(Xu) ** 2).sum(axis=0))) ph = np.angle(np.sum(Xu[1:, b] * np.conj(Xu[:-1, b]))) f_frac = ph / (2 * np.pi) rot = np.exp(-2j * np.pi * f_frac * np.arange(n_pre)) bu = wrap(b + jacobsen(rot @ Xu, b), M) o = (n_pre + 2) * M Xd = np.array([np.fft.fft(z[o + j * M:o + (j + 1) * M] * up) for j in range(2)]) bdi = int(np.argmax((np.abs(Xd) ** 2).sum(axis=0))) bd = wrap(bdi + jacobsen(Xd[0] + Xd[1] * np.exp(-2j * np.pi * f_frac), bdi), M) f_res = f_frac + np.round((bu + bd) / 2 - f_frac) tau_res = (bd - bu) / 2 f_hz = sync.f_hz + f_res * p.bw / M sync = Sync(T=sync.T, tau0=sync.tau0 + tau_res, f_bins=f_hz * M / p.bw, f_hz=f_hz, eps=f_hz / p.fc, metric=sync.metric) return sync def _smooth_phase(slots, pil, ph, half=2): """Moving linear regression of unwrapped pilot phase, evaluated at slots. Each slot fits a line through the 2*half+2 pilots around it (fewer at the frame edges). Closed-form least squares from running sums, vectorized. """ ph = np.unwrap(ph) npil = len(pil) slots = np.asarray(slots) c = np.searchsorted(pil, slots) lo = np.maximum(0, np.minimum(c - half - 1, npil - 2 * half - 2)) hi = np.minimum(npil, lo + 2 * half + 2) xv = np.asarray(pil, np.float64) def csum(v): return np.concatenate([[0.0], np.cumsum(v)]) c1, cx, cy, cxx, cxy = (csum(np.ones(npil)), csum(xv), csum(ph), csum(xv * xv), csum(xv * ph)) n = c1[hi] - c1[lo] sx, sy = cx[hi] - cx[lo], cy[hi] - cy[lo] sxx, sxy = cxx[hi] - cxx[lo], cxy[hi] - cxy[lo] den = n * sxx - sx * sx ok = (n >= 2) & (den > 0) a = np.where(ok, (n * sxy - sx * sy) / np.where(ok, den, 1.0), 0.0) b0 = np.where(ok, (sy - a * sx) / np.where(n > 0, n, 1.0), ph[np.minimum(lo, npil - 1)]) return a * slots + b0 def _track_pilots(X, pil, M, win=2): """Locate each pilot peak within +-win bins of the expected offset. After refine() the residual bin offset is ~0 and drifts slowly, so an unconstrained argmax over all M bins only adds chances of locking onto a noise bin (a few % per pilot at 10 dB peak SNR, M=128), which then corrupts alignment and phase for every symbol around it. The expected offset follows the running median of accepted pilots. Returns (pilot peak bins, sub-bin offsets b_real, pilot complex values). """ offs = np.arange(-win, win + 1) ref = 0 hist, am_p, b_real, pv = [], [], [], [] for k in pil: cand = (ref + offs) % M a = int(cand[np.argmax(np.abs(X[k, cand]))]) br = wrap(a, M) + jacobsen(X[k], a) am_p.append(a) b_real.append(br) pv.append(X[k, a]) hist.append(br) ref = int(np.round(np.median(hist[-5:]))) return np.array(am_p), np.array(b_real), np.array(pv) def demodulate(z, p, n_data, tau_comp=False): M = p.M is_p, _ = payload_layout(n_data, p.pilot_every) S = len(is_p) cu = np.conj(base_chirp_chips(M)) W = z[p.payload_start:p.payload_start + S * M].reshape(S, M) X = np.fft.fft(W * cu, axis=1) am = np.argmax(np.abs(X), axis=1) pil = np.where(is_p)[0] slots = np.arange(S) am_p, b_real, pv = _track_pilots(X, pil, M) am[pil] = am_p b_i = np.interp(slots, pil, b_real) # bin offset per slot b_int = np.round(b_i) delta = b_i - b_int # sub-bin part (= -tau_res) phi = _smooth_phase(slots, pil, np.angle(pv)) idx_hat = (am - b_int.astype(int)) % M v = X[slots, am] * np.exp(-1j * phi) if tau_comp: v = v * np.exp(-2j * np.pi * idx_hat * delta / M) d = ~is_p idx_d, a_d = idx_hat[d], v[d] val = inv_gray(idx_d) bits_idx = ((val[:, None] >> np.arange(p.sf - 1, -1, -1)) & 1).astype(np.uint8) bi, bq = qpsk_demap(a_d) bits = np.concatenate([bits_idx, bi[:, None], bq[:, None]], axis=1).reshape(-1) info = dict(idx=idx_d, a=a_d, pilot_bin=b_real, pilot_phase=phi[pil], peak_snr=np.abs(X[slots, am]) ** 2) return bits, info # ------------------------------------------------------------------ soft demap def _lse(a, axis): m = np.max(a, axis=axis, keepdims=True) return np.squeeze(m, axis) + np.log(np.sum(np.exp(a - m), axis=axis)) def _logcosh2(x): """log(2 cosh x), stable.""" ax = np.abs(x) return ax + np.log1p(np.exp(-2 * ax)) def _logI0(x): small = x < 5 out = np.empty_like(x) out[small] = np.log(np.i0(x[small])) xl = x[~small] out[~small] = xl - 0.5 * np.log(2 * np.pi * xl) + np.log1p(1 / (8 * xl)) return out def _local_linear(xp, yp, xq, W, loo=False): """Local linear least-squares fit of (complex) pilot values yp at xp. Each query point uses the W pilots nearest to it in index (shifted inward at the frame edges). With ``loo`` the queries are the pilots themselves and each pilot is left out of its own fit (window W+1 minus itself), which gives an honest prediction error. Vectorized with running sums. """ xp = np.asarray(xp, np.float64) yp = np.asarray(yp) n = len(xp) Wn = min(W + (1 if loo else 0), n) c = np.arange(n) if loo else np.searchsorted(xp, xq) lo = np.clip(c - Wn // 2, 0, n - Wn) hi = lo + Wn def cs(v): return np.concatenate([[0], np.cumsum(v)]) c1, cx, cy, cxx, cxy = cs(np.ones(n)), cs(xp), cs(yp), cs(xp * xp), cs(xp * yp) N = c1[hi] - c1[lo] sx, sy = cx[hi] - cx[lo], cy[hi] - cy[lo] sxx, sxy = cxx[hi] - cxx[lo], cxy[hi] - cxy[lo] if loo: N, sx, sy = N - 1, sx - xp, sy - yp sxx, sxy = sxx - xp * xp, sxy - xp * yp xq = xp den = N * sxx - sx * sx ok = (N >= 2) & (den > 1e-9) a = np.where(ok, (N * sxy - sx * sy) / np.where(ok, den, 1.0), 0.0) b = (sy - a * sx) / np.maximum(N, 1) return a * np.asarray(xq, np.float64) + b TRACK_WINDOWS = (2, 3, 4, 6, 8, 12, 16, 24) def _fit_channel(xs, ys, query, windows): """Channel gain at ``query`` slots from samples ys at slots xs. 1. Residual frequency: the preamble's CFO estimate can be tens of Hz off when it lands near a fade (a Rayleigh channel's instantaneous frequency swings well past the Doppler limit there). Estimate the common rotation from consecutive samples at the most frequent spacing (weighted phase-increment estimator) and remove it. 2. Local linear fit of the derotated samples, window chosen by leave-one-out prediction error. 3. Put the rotation back. Returns (h at query, window). """ xs = np.asarray(xs, np.float64) n = len(xs) if n < 3: return np.full(len(query), np.mean(ys)), n dx = np.diff(xs) step = np.bincount(dx.astype(int)).argmax() pr = ys[1:] * np.conj(ys[:-1]) w = 0.0 if step == 0 else np.angle(np.sum(pr[dx == step])) / step yd = ys * np.exp(-1j * w * xs) best = None for W in windows: if W > n - 1: break err = np.mean(np.abs(yd - _local_linear(xs, yd, None, W, loo=True)) ** 2) if best is None or err < best[0]: best = (err, W) W = best[1] if best else n - 1 q = np.asarray(query, np.float64) return _local_linear(xs, yd, q, W) * np.exp(1j * w * q), W def _channel_track(pil, pv, slots): """Per-slot complex channel gain from the pilots (see _fit_channel).""" return _fit_channel(pil, pv, slots, TRACK_WINDOWS) def _freq_ramp(Y, is_p, p, min_ratio=4.0): """Linear frequency drift across a frame, from where each symbol's peak sits. The preamble fixes the frequency at the start of the frame; if the carrier then drifts (an oscillator warming up), the residual grows through the frame. Pilot *phase* can only follow it up to +-1/(2 * pilot spacing) (+-0.85 Hz at SF12, 62.5 kHz) before wrapping, but each symbol's peak *position* (sub-bin, Jacobsen) shows the frequency unambiguously to +-0.5 bin. Fit offset = c1 * t through the preamble (where the residual is zero), using pilots and data symbols whose peak clearly stands out, with two Huber reweightings. Returns c1 in bins per chip (shrunk by c1^2 / (c1^2 + sigma^2)) and the slot-centre times in chips. """ M = p.M S = Y.shape[0] t = p.payload_start + np.arange(S) * M + M / 2 - p.n_preamble * M / 2 A2 = np.abs(Y) ** 2 kp = np.where(is_p, 0, np.argmax(A2, axis=1)) top = A2[np.arange(S), kp] second = np.partition(A2, -2, axis=1)[:, -2] use = is_p | (top > min_ratio * second) off = np.array([jacobsen(Y[i], int(kp[i])) for i in range(S)]) w0 = top * use w = w0.copy() c1, sig = 0.0, np.inf for _ in range(3): if w.sum() <= 0: return 0.0, t c1 = float(np.sum(w * t * off) / np.sum(w * t * t)) r = off - c1 * t scale = 1.4826 * np.median(np.abs(r[use])) + 1e-6 w = w0 * np.minimum(1.0, 1.5 * scale / (np.abs(r) + 1e-12)) n_eff = max(int(use.sum()) - 1, 1) sig = float(np.sqrt(np.sum(w * r * r) / (n_eff * np.sum(w * t * t)))) return c1 * c1 * c1 / (c1 * c1 + sig * sig) if c1 else 0.0, t def demodulate_soft(z, p, n_data, coherent=True, clip=50.0, tracker="adaptive", h=None, freq_ramp=False): """Exact (log-sum-exp) bit LLRs over all M x 4 (index, QPSK) hypotheses. Model per data symbol s: X_k = h_s a delta(k-idx) + n_k, n_k ~ CN(0, sigma2), with h_s the complex channel gain (FFT units) estimated from the pilots. Hypothesis metric lambda(k,a) = (2/sigma2) Re(X_k conj(h_s) a*). The QPSK sum factors per axis, giving mu_k = lc(yr_k) + lc(yi_k) with y = sqrt(2)/sigma2 * X conj(h_s) and lc(x) = log 2cosh(x). ``coherent=False`` uses log I0(2|h_s||X_k|/sigma2) for the index (phase-free) and keeps the coherent QPSK terms. ``tracker``: "adaptive" (per-symbol complex gain, window chosen per frame) or "legacy" (sliding phase fit over 6 pilots, one amplitude per frame). ``h``: per-slot channel gains to use instead of tracking the pilots (from ``channel_from_decisions``). ``freq_ramp``: remove a linear frequency drift across the frame first (see _freq_ramp); used as a retry when a stage fails. Returns LLRs in modulator bit order: per symbol [index bits MSB..LSB, I, Q]. """ M, sf = p.M, p.sf is_p, _ = payload_layout(n_data, p.pilot_every) S = len(is_p) cu = np.conj(base_chirp_chips(M)) W = z[p.payload_start:p.payload_start + S * M].reshape(S, M) X = np.fft.fft(W * cu, axis=1) pil = np.where(is_p)[0] slots = np.arange(S) # pilots: bin offset (integer part used to align bins) and channel gain am_p, b_real, pv = _track_pilots(X, pil, M) b_int = np.round(np.interp(slots, pil, b_real)).astype(int) # align: Y[s, k] = X[s, (k + b_int[s]) mod M] cols = (np.arange(M)[None, :] + b_int[:, None]) % M Y = X[slots[:, None], cols] # noise power per bin E = np.abs(X) ** 2 pk = E.max(axis=1) sigma2 = float(np.mean((E.sum(axis=1) - pk) / (M - 1))) ramp = 0.0 if freq_ramp: ramp, tc = _freq_ramp(Y, is_p, p) rot = np.exp(-1j * np.pi * ramp * tc * tc / M) # phase of the drifting carrier Y = Y * rot[:, None] pv = pv * rot[pil] if h is not None: win = None elif tracker == "legacy": phi = _smooth_phase(slots, pil, np.angle(pv)) A = float(np.sqrt(max(np.mean(np.abs(pv) ** 2) - sigma2, 1e-12))) h, win = A * np.exp(1j * phi), 6 else: h, win = _channel_track(pil, pv, slots) hd = h[~is_p] Yd = Y[~is_p] * (np.sqrt(2) / sigma2 * np.conj(hd))[:, None] yr, yi = Yd.real, Yd.imag lr, li = _logcosh2(yr), _logcosh2(yi) if coherent: mu = lr + li else: mu = _logI0(2 * np.abs(hd)[:, None] / sigma2 * np.abs(Y[~is_p])) A = float(np.sqrt(np.mean(np.abs(h) ** 2))) val = inv_gray(np.arange(M)) llr = np.empty((len(Yd), sf + 2)) for j in range(sf): bit = (val >> (sf - 1 - j)) & 1 llr[:, j] = _lse(mu[:, bit == 0], 1) - _lse(mu[:, bit == 1], 1) # QPSK: index-marginalized, using the coherent per-bin terms llr[:, sf] = _lse(yr + li, 1) - _lse(-yr + li, 1) llr[:, sf + 1] = _lse(yi + lr, 1) - _lse(-yi + lr, 1) llr = np.clip(llr, -clip, clip) info = dict(sigma2=sigma2, A=A, peak_snr_db=10 * np.log10(A * A / sigma2), pilot_bin=b_real, pilot_phase=np.angle(h[pil]), yr=yr, yi=yi, track_window=win, Y=Y, is_pilot=is_p, pilot_val=pv, pilot_slots=pil, freq_ramp_hz_per_s=ramp * p.bw * p.bw / M) return llr.reshape(-1), info def _bit_llrs(mu, sf, clip=50.0): """Index-bit LLRs (S, sf) from per-bin log-likelihoods mu (S, M).""" M = mu.shape[1] val = inv_gray(np.arange(M)) out = np.empty((mu.shape[0], sf)) for j in range(sf): b0 = ((val >> (sf - 1 - j)) & 1) == 0 out[:, j] = _lse(mu[:, b0], 1) - _lse(mu[:, ~b0], 1) return np.clip(out, -clip, clip) def demodulate_nc(z, p, n_data, clip=50.0, amp_smooth=3): """Non-coherent demodulator: index bits only, no use of carrier phase. Pilots give the frequency (sub-bin peak position, interpolated per slot) and the amplitude (smoothed pilot power minus noise); each symbol is de-rotated by its own frequency before the FFT, so a residual offset of a fraction of a bin costs no scalloping loss. Per-bin metric for "the symbol is in bin k": mu_k = log I0(2 A |Y_k| / sigma2) (Rice vs Rayleigh likelihood ratio), whatever the phase does between or within symbols. Returns (llr (n_data * sf,), info); info['mu'] (data rows) feeds demap_extrinsic_nc for iterative decoding. """ M, sf = p.M, p.sf is_p, _ = payload_layout(n_data, p.pilot_every) S = len(is_p) cu = np.conj(base_chirp_chips(M)) D = z[p.payload_start:p.payload_start + S * M].reshape(S, M) * cu X = np.fft.fft(D, axis=1) pil = np.where(is_p)[0] slots = np.arange(S) _, b_real, pv = _track_pilots(X, pil, M) b = np.interp(slots, pil, b_real) Y = np.fft.fft(D * np.exp(-2j * np.pi * b[:, None] * np.arange(M)[None, :] / M), axis=1) E = np.abs(Y) ** 2 pk = E.max(axis=1) sigma2 = float(np.mean((E.sum(axis=1) - pk) / (M - 1))) a2 = np.maximum(E[pil, 0] - sigma2, 0.1 * sigma2) if amp_smooth > 1 and len(a2) >= amp_smooth: k = np.ones(amp_smooth) / amp_smooth a2 = np.convolve(np.pad(a2, amp_smooth // 2, mode="edge"), k, mode="valid") A = np.sqrt(np.interp(slots, pil, a2)) d = ~is_p mu = _logI0((2 * A[d] / sigma2)[:, None] * np.sqrt(E[d])) llr = _bit_llrs(mu, sf, clip) info = dict(sigma2=sigma2, A=float(np.sqrt(np.mean(A * A))), peak_snr_db=10 * np.log10(np.mean(A * A) / sigma2), mu=mu, Y=Y, is_pilot=is_p, pilot_bin=b_real, pilot_val=pv, pilot_slots=pil, freq_ramp_hz_per_s=0.0) return llr.reshape(-1), info def demap_extrinsic_nc(mu, sf, La, clip=50.0): """Non-coherent demapper with a-priori index-bit LLRs (S, sf); returns extrinsic LLRs (S, sf).""" M = mu.shape[1] val = inv_gray(np.arange(M)) bits = ((val[:, None] >> np.arange(sf - 1, -1, -1)[None, :]) & 1) pi = 0.5 * La @ (1.0 - 2.0 * bits).T return np.clip(_bit_llrs(mu + pi, sf, np.inf) - La, -clip, clip) def estimate_drift(info, p): """Residual sample-clock error from how the pilot peaks slide across a frame. The receiver's clock-error estimate comes from the CFO (eps = f / fc), which is wrong whenever part of the carrier offset has no matching clock error: a transverter LO, a dongle with separate tuner and ADC crystals. A leftover clock error makes the timing slip linearly across the frame, which moves each dechirped pilot peak linearly in frequency. Fit a line through the pilots' sub-bin peak positions, anchored at the preamble (where refine() zeroed the timing), weighted by pilot power. Returns (delta, sigma, span): the eps correction (eps_true = eps - delta), its standard error, and the frame span in chips it was measured over. """ pil, b, pv = info["pilot_slots"], info["pilot_bin"], info["pilot_val"] M = p.M m0 = p.n_preamble * M / 2 # preamble center if len(pil) < 2: return 0.0, np.inf, 0.0 m = np.concatenate([[m0], p.payload_start + pil * M + M / 2]) b = np.concatenate([[0.0], b]) w = np.abs(pv) ** 2 w = np.concatenate([[np.median(w)], w]) # anchor: one pilot's weight sw = np.sqrt(w) A = np.stack([np.ones_like(m), m - m0], axis=1) coef, *_ = np.linalg.lstsq(A * sw[:, None], b * sw, rcond=None) r = (b - A @ coef) * sw dof = max(len(m) - 2, 1) cov = np.linalg.pinv((A * w[:, None]).T @ A) * (r @ r) / dof # peak moves opposite to the clock error: delta = -slope return float(-coef[1]), float(np.sqrt(max(cov[1, 1], 0.0))), float(m[-1] - m0) DRIFT_MIN_CHIPS = 0.1 # skip corrections that move the frame end less than this # (frame._drift_correct also shrinks each estimate by d^2 / (d^2 + sigma^2), so # noise-level estimates barely move anything and confident ones apply in full) def apply_drift(sync, delta, p): """Sync with eps corrected by delta, keeping the preamble timing fixed.""" m0 = p.n_preamble * p.M / 2 return Sync(T=sync.T, tau0=sync.tau0 - m0 * delta, f_bins=sync.f_bins, f_hz=sync.f_hz, eps=sync.eps - delta, metric=sync.metric) def channel_from_decisions(Y, is_p, bits, conf, p): """Re-estimate the per-slot channel using decided data symbols as pilots. Y : (S, M) aligned dechirped spectra (demodulate_soft info['Y']) is_p : (S,) pilot mask bits : (n_data, sf+2) decided on-air bits per data symbol conf : (n_data,) bool, use this symbol (decision trusted) Each trusted symbol gives a channel sample Y[s, idx] * conj(a); with the pilots that is one sample per symbol instead of one per ``pilot_every``, which is what fast fading needs. Smoothing window chosen by leave-one-out, as for the pilots. """ idx, a = bits_to_symbols(np.asarray(bits, np.uint8).reshape(-1), p) ds = np.where(~is_p)[0] pil = np.where(is_p)[0] xs = np.concatenate([pil, ds[conf]]) ys = np.concatenate([Y[pil, 0], Y[ds[conf], idx[conf]] * np.conj(a[conf])]) o = np.argsort(xs) h, _ = _fit_channel(xs[o], ys[o], np.arange(len(is_p)), TRACK_WINDOWS + (32, 48)) return h def demap_extrinsic(yr, yi, sf, La, clip=50.0): """Coherent demapper with a-priori bit LLRs (for iterative demap/decode). yr, yi : (S, M) scaled bin metrics from demodulate_soft (info['yr'/'yi']) La : (S, sf+2) a-priori LLRs in modulator bit order (log P0/P1) Returns extrinsic LLRs (S, sf+2): posterior minus the bit's own prior. Prior per hypothesis = sum_j (La_j / 2) * (+1 if b_j = 0 else -1); the QPSK priors fold into the per-axis log-cosh terms, the index priors form a per-bin offset pi_k = 0.5 * La_idx @ sign(k)^T. """ M = yr.shape[1] val = inv_gray(np.arange(M)) bits = ((val[:, None] >> np.arange(sf - 1, -1, -1)[None, :]) & 1) # (M, sf) sgn = 1.0 - 2.0 * bits pi = 0.5 * La[:, :sf] @ sgn.T # (S, M) ur = yr + 0.5 * La[:, sf:sf + 1] ui = yi + 0.5 * La[:, sf + 1:sf + 2] lr, li = _logcosh2(ur), _logcosh2(ui) mu = pi + lr + li out = np.empty_like(La) for j in range(sf): b0 = bits[:, j] == 0 out[:, j] = _lse(mu[:, b0], 1) - _lse(mu[:, ~b0], 1) - La[:, j] out[:, sf] = _lse(pi + ur + li, 1) - _lse(pi - ur + li, 1) - La[:, sf] out[:, sf + 1] = _lse(pi + ui + lr, 1) - _lse(pi - ui + lr, 1) - La[:, sf + 1] return np.clip(out, -clip, clip) def receive_soft(x, p, n_data, det_thresh=4.0, coherent=True): """Sync + soft demap. Returns (llr or None, sync, info).""" r = decimate(x, p) sync = acquire(r, p, det_thresh) if sync is None: return None, None, None S = len(payload_layout(n_data, p.pilot_every)[0]) n_chips = p.payload_start + S * p.M if sync.T + n_chips + 8 > len(r): return None, sync, None sync = refine(x, sync, p) z = extract_frame(x, sync, p, n_chips) llr, info = demodulate_soft(z, p, n_data, coherent=coherent) return llr, sync, info def receive(x, p, n_bits, det_thresh=4.0): n_data = n_symbols_for_bits(n_bits, p) r = decimate(x, p) sync = acquire(r, p, det_thresh) if sync is None: return None, None, None S = len(payload_layout(n_data, p.pilot_every)[0]) n_chips = p.payload_start + S * p.M if sync.T + n_chips + 8 > len(r): return None, sync, None sync = refine(x, sync, p) z = extract_frame(x, sync, p, n_chips) bits, info = demodulate(z, p, n_data) return bits[:n_bits], sync, info