ADAPTIVE FHSS
AI-DRIVEN FREQUENCY MANAGEMENT

Mathematical Derivation — CFAR Detection Threshold

The central question Adaptive FHSS must answer on every hop: is this channel clean, or is it jammed? The answer cannot be a fixed threshold because the noise floor itself varies with temperature, receiver gain, and nearby unrelated emissions. CFAR solves this by estimating the noise floor from the neighborhood of the channel under test and declaring the channel jammed only if it rises above that local reference by a margin chosen to achieve a target false-alarm probability. This section derives the margin.

Step 1 — Characterize the noise process

Thermal noise at the SDR receiver front-end is complex Gaussian with zero mean. After the FFT, each bin contains the magnitude-squared of a complex Gaussian sample — this follows the exponential distribution:

Noise sample (complex): n = n_I + j·n_Q  where n_I, n_Q ~ N(0, σ²/2)
Power sample:           P = |n|² = n_I² + n_Q²  ~ Exp(1/σ²)

Mean power:             E[P] = σ²
CDF:                    F(p) = 1 - exp(-p/σ²)
Survival function:      P(P > p) = exp(-p/σ²)

The survival function is what CFAR uses. If we set a threshold T above the estimated noise floor, the probability that pure noise crosses T is exp(-T/σ²). We want this to equal our target false-alarm rate Pfa.

Step 2 — Derive the threshold multiplier α

CFAR estimates σ² from the average of N neighborhood bins (excluding the cell under test and a guard band). Let Z = (1/N) Σ P_i be this average. The CFAR decision is:

Declare jammed  if   P_cell > α · Z
Declare clean   if   P_cell ≤ α · Z

where α is chosen so that P(false alarm | noise only) = Pfa.

For exponentially distributed noise with N reference cells:
  α = N · (Pfa^(-1/N) - 1)

At Pfa = 10⁻⁶ and N = 16 reference cells:
  α = 16 · (10⁶^(1/16) - 1) = 16 · (2.3714 - 1) = 21.94

In dB:  α_dB = 10·log₁₀(21.94) = 13.41 dB ≈ 15 dB (with 1.6 dB engineering margin)

Therefore the threshold of "noise_floor + 15 dB" used in the operational scan code below is derived from Pfa = 10⁻⁶ with N = 16 reference cells and a small margin for ADC quantization. Proof: ADAPTIVE_FHSS_CFAR_THRESHOLD.

Step 3 — Detection range from the Friis equation

Given the threshold, what is the minimum detectable jammer at a given range? We substitute into Friis:

Jammer power at drone antenna:
  P_rx = P_tx_dBm + G_tx_dBi + G_rx_dBi − L_path_dB

For a 20 dBm (100 mW) narrowband jammer at 500 m on 300 MHz:
  L_path = 32.45 + 20·log₁₀(300) + 20·log₁₀(0.5)
         = 32.45 + 49.54 + (−6.02) = 75.97 dB
  P_rx = 20 + 0 + 0 − 75.97 = −55.97 dBm  (omni → omni, line-of-sight)

Thermal noise floor (RTL-SDR, 2.4 MHz BW):
  kTB = −174 + 10·log₁₀(2.4e6) = −174 + 63.8 = −110.2 dBm
  + NF_rtl_sdr (4.5 dB) = −105.7 dBm

SNR of jammer above noise: −55.97 − (−105.7) = 49.7 dB
Threshold clears noise_floor + 15 dB by: 49.7 − 15 = 34.7 dB margin  ✓ DETECTED

Thus a 100 mW jammer at 500 m is detected with ~35 dB margin. The useful detection range scales with the square root of transmit power; a 1 W jammer is detectable at ~1,600 m, a 10 W jammer at ~5,000 m. Proof: ADAPTIVE_FHSS_DETECTION_RANGE_100MW.

Step 4 — Graceful degradation under progressive jamming

Adaptive FHSS maintains full throughput until the fraction of clean channels drops below a critical point. Define f_clean = clean channels / total channels. Throughput degrades as:

T(f_clean) = T_nominal × min(1, f_clean / f_critical)

where f_critical is the minimum fraction needed for the radio's required data rate.
For Silvus StreamCaster with QPSK at 10 MHz effective bandwidth (needs ~2% of 460 MHz):
  f_critical = 0.02

Degradation examples:
  f_clean = 100%:   T = T_nominal (full rate, 34 Mbps)
  f_clean = 50%:    T = T_nominal (still well above f_critical)
  f_clean = 10%:    T = T_nominal (460 channels = 5× needed)
  f_clean = 5%:     T = T_nominal × (5 / 2) = limited, ~17 Mbps effective
  f_clean = 2%:     T = T_nominal × 1 (exactly at critical)
  f_clean = 1%:     T = T_nominal × 0.5 = 17 Mbps max, 50% packet loss
  f_clean = 0.1%:   T ≈ 1.7 Mbps, telemetry only
  f_clean = 0%:     total communication loss

Worked Example 1 — Single Tactical Narrowband Jammer

Russian platoon-level narrowband jammer, 40 MHz instantaneous bandwidth, 100 W output, positioned 2 km from Fischer 26 at 300 m AGL.

Jammer parameters:    40 MHz BW, +50 dBm (100 W), range 2 km, 300 MHz center
Silvus spectrum:      140-600 MHz, 4,600 channels × 100 kHz each

Step 1: Compute jammer power density at Fischer 26
  Path loss @ 2 km, 300 MHz: L = 32.45 + 49.54 + 6.02 = 88.0 dB
  P_rx at drone = 50 + 0 + 0 − 88 = −38.0 dBm (total jammer energy seen)
  Spread over 40 MHz: PSD = −38 − 10·log₁₀(40e6/1e6) = −54 dBm/MHz

Step 2: Compare to noise floor in each 100 kHz Silvus channel
  Thermal noise per 100 kHz: kTB = −174 + 10·log₁₀(1e5) = −124 dBm
  + NF (5 dB) = −119 dBm
  Jammer-in-channel (100 kHz portion of 40 MHz):
    P_jammer_in_100kHz = −54 dBm/MHz − 10·log₁₀(10) = −64 dBm
  SNR_jammer_over_noise = −64 − (−119) = 55 dB  ← massive, will be blacklisted

Step 3: Count jammed channels
  Jammed range: 280-320 MHz covers 400 × 100 kHz channels = 400 channels
  Silvus band is 140-600 MHz (4,600 channels total)
  Jammed fraction: 400 / 4,600 = 8.7%
  Clean fraction: 91.3%

Step 4: Adaptation result
  Blacklist populated in one 5 s beacon cycle.
  Silvus converges on 4,200 clean channels.
  Data rate unaffected (f_clean = 91.3% >> f_critical = 2%).
  Operational impact: ZERO.

Thus the narrowband jammer is essentially irrelevant once adaptation has converged. Proof: ADAPTIVE_FHSS_NARROWBAND_IMPACT.

Worked Example 2 — Barrage Jammer (Krasukha-class)

Russian Krasukha-4 aerial EW station, ~70 kW across 2 GHz bandwidth, 10 km from Fischer 26.

Jammer parameters:    2000 MHz BW, 70 kW = +78.4 dBm total, range 10 km
Silvus band overlap:  Krasukha covers ~2-4 GHz — does NOT overlap Silvus 140-600 MHz

Step 1: Check band overlap
  Silvus operational band: 140-600 MHz
  Krasukha-4 band:         2000-4000 MHz
  Overlap: ZERO MHz

Step 2: Is there out-of-band leakage?
  Typical Krasukha PSD in sidelobe region: -60 dB below passband
  Leakage at 300 MHz sideband after 10 km path loss:
    L = 32.45 + 49.54 + 40.0 = 121.99 dB
    Leakage at receiver: far below thermal noise floor → UNDETECTABLE

Step 3: Adaptation result
  Krasukha cannot jam Silvus band at 10 km even at 70 kW.
  Clean fraction: ~100%.
  Operational impact: ZERO against Silvus at 300 MHz center.

Fischer 26E implications:
  AD9361 SDR covers 70 MHz - 6 GHz including the 2-4 GHz Krasukha band.
  In the 2-4 GHz portion: Krasukha IS effective (see fischer26e.html).
  Fischer 26E fastlock hops to the UNCOVERED bands (70-2000 MHz, 4000-6000 MHz)
  = 66% of spectrum unaffected. Proof: FISCHER26E_KRASUKHA_UNAFFECTED_SPECTRUM.

Implementation — SDR Spectrum Scan with CFAR

# adaptive_scan.py — RTL-SDR CFAR-based jammer detection
# Requires: pip install pyrtlsdr numpy
# Hardware: RTL-SDR Blog V4 (€25)

from rtlsdr import RtlSdr
import numpy as np

def cfar_detect(psd_db, n_ref=16, n_guard=2, threshold_db=15.0):
    """Cell-Averaging CFAR detector.

    For each cell, estimate noise from the N_REF cells outside a guard band.
    Declare jammed if cell exceeds estimate by THRESHOLD_DB.
    Threshold derived from Pfa = 1e-6, N = 16: alpha approx 15 dB.
    """
    n = len(psd_db)
    jammed = np.zeros(n, dtype=bool)
    for i in range(n_ref + n_guard, n - n_ref - n_guard):
        left  = psd_db[i - n_ref - n_guard : i - n_guard]
        right = psd_db[i + n_guard + 1 : i + n_guard + 1 + n_ref]
        noise_est = np.mean(np.concatenate([left, right]))
        if psd_db[i] > noise_est + threshold_db:
            jammed[i] = True
    return jammed


sdr = RtlSdr()
sdr.sample_rate = 2.4e6        # 2.4 MHz — RTL-SDR maximum stable
sdr.center_freq = 300e6        # 300 MHz mil-band center
sdr.gain = 20

samples = sdr.read_samples(256 * 1024)
psd = np.abs(np.fft.fftshift(np.fft.fft(samples, n=2048)))**2
psd_db = 10 * np.log10(psd + 1e-10)

jammed = cfar_detect(psd_db, n_ref=16, n_guard=2, threshold_db=15.0)
jammed_fraction = jammed.sum() / len(jammed) * 100

print(f"Scanned 2.4 MHz @ 300 MHz center in ~107 ms")
print(f"Jammed bins: {jammed.sum()} / {len(jammed)} ({jammed_fraction:.2f}%)")
print(f"Clean fraction: {100 - jammed_fraction:.2f}%")

sdr.close()

Implementation — Blacklist Adaptation and Mesh Convergence

# adaptive_mesh.py — Blacklist management and MANET propagation

from dataclasses import dataclass, field
from typing import Set
import time
import math


@dataclass
class ChannelBlacklist:
    """Per-node blacklist, merged with peers every beacon cycle.

    The exponential-decay age mechanism re-enables channels that were jammed
    but have since cleared (the jammer moved, was destroyed, or switched off).
    """
    jammed: dict = field(default_factory=dict)  # channel_idx -> last_detected_unix_ts
    beacon_interval_s: float = 5.0
    clear_threshold_s: float = 30.0  # re-enable channels unjammed for 30 s

    def detect(self, channel_idx: int):
        """Called when CFAR reports this channel jammed."""
        self.jammed[channel_idx] = time.time()

    def merge_peer(self, peer_blacklist: dict):
        """Merge a peer's blacklist into ours (union with later timestamp)."""
        for ch, ts in peer_blacklist.items():
            if ch not in self.jammed or ts > self.jammed[ch]:
                self.jammed[ch] = ts

    def expire_stale(self):
        """Remove channels that have been unseen for clear_threshold_s."""
        now = time.time()
        stale = [ch for ch, ts in self.jammed.items()
                 if now - ts > self.clear_threshold_s]
        for ch in stale:
            del self.jammed[ch]

    def active_channels(self, total: int) -> Set[int]:
        """Return the set of non-jammed channels for hopping."""
        return set(range(total)) - set(self.jammed.keys())


def convergence_time_s(n_nodes: int, beacon_interval_s: float = 5.0) -> float:
    """Time for mesh to converge on shared blacklist.

    With flooding-based beacon propagation, convergence is approximately
    log2(N) beacon cycles. For 16-node platoon: ~4 cycles x 5 s = 20 s worst
    case. Typical 2-3 s for 4-node squad mesh.
    Proof: MESH_CONVERGENCE_TIME_4NODES.
    """
    return math.ceil(math.log2(max(n_nodes, 2))) * beacon_interval_s


# Demo: 4-node mesh, narrowband jammer activates
bl = ChannelBlacklist()
for ch in range(2800, 3200):   # 400 channels jammed (Example 1)
    bl.detect(ch)

active = bl.active_channels(total=4600)
print(f"After Example 1 detection: {len(active)} / 4600 channels active")
print(f"Clean fraction: {len(active)/4600*100:.1f}%")
print(f"Mesh convergence (4 nodes, 5 s beacon): {convergence_time_s(4):.0f} s")

Comparison with Fixed-Frequency Systems

A fixed-frequency radio on a single channel is defeated by a single 10 W narrowband jammer costing €5,000. An adaptive-FHSS radio with 4,600 channels requires the adversary to cover the entire 460 MHz band. Required jammer power scales linearly with bandwidth:

Power ratio = P_FHSS_barrage / P_narrowband
            = (4,600 channels × 10 W/channel) / 10 W
            = 4,600×

Proof: FHSS_JAM_POWER_RATIO in provable_claims.py.

Why Adaptive FHSS Matters Operationally

Three operational consequences depend on this math being correct, and each produces a direct casualty outcome if the system fails.

First, the difference between 460 channels clean and 0 channels clean is the difference between "brigade communications continue with marginal latency" and "brigade communications have failed completely." A Fischer 26 at 300 m AGL provides MANET backbone for its entire sector; losing that link costs the brigade its drone intelligence, FPV strike coordination, and real-time artillery correction. Our CFAR threshold derivation (Step 2) sets the false-positive rate — too aggressive and legitimate transmissions get blacklisted, too permissive and jammers pollute the channel set. Pfa = 10⁻⁶ is the engineering compromise: at Silvus's 4,600 channels scanned every 10 ms, we expect one spurious blacklisting every ~22 hours of operation, which is acceptable.

Second, the 2-3 second mesh convergence time determines how long the link operates at reduced capacity after a jamming event starts. At 2 seconds, a mid-strike FPV loses connectivity during its terminal approach; the pilot must switch to onboard autonomy or abort. At 30 seconds, the FPV is almost certainly destroyed. This is why the beacon interval is aggressively short (5 s) — the math enforces the tradeoff between adaptation speed and blacklist thrash. Proof: MESH_CONVERGENCE_TIME_4NODES.

Third, the graceful-degradation curve from Step 4 tells commanders when to abandon Silvus and switch to Fischer 26E's SDR band. If f_clean drops below 2%, the link carries telemetry only — no video, no FPV strike, no detailed COP updates. At that point, tier-2 Fischer 26E's 70 MHz - 6 GHz fastlock hopping takes over the brigade uplink (see fischer26e.html). The decision cutover is automatic when f_clean × bandwidth drops below the link's minimum data rate; the math removes the commander from the loop.

Limitations

Adaptive FHSS does NOT defeat barrage jamming where the enemy floods the entire band simultaneously at sufficient power to clear the CFAR threshold everywhere. Against a 100 W barrage jammer at 500 m across 460 MHz, every channel would see −58 dBm of jamming power — well above the 15 dB threshold. The blacklist contains every channel. Defense against barrage jamming requires either (a) higher TX power to overpower the jammer (impractical on small drones), (b) directional antenna (CRPA, see crpa-antennas.html) to null the jammer spatially, or (c) frequency band change (Fischer 26E's 70 MHz - 6 GHz covers bands Krasukha-class cannot reach — 66% of spectrum remains usable).

Related Chapters

Sources

Mathematically verified estimates. CFAR threshold derivation (Pfa = 10⁻⁶, N = 16 cells → α ≈ 15 dB) validated in provable_claims.py under ADAPTIVE_FHSS_CFAR_THRESHOLD. The 4,600× power-ratio claim is direct multiplication, under FHSS_JAM_POWER_RATIO. Jammer detection range at 100 mW validated under ADAPTIVE_FHSS_DETECTION_RANGE_100MW. Narrowband-jammer clean fraction (91.3%) validated under ADAPTIVE_FHSS_NARROWBAND_IMPACT. Mesh convergence time validated under MESH_CONVERGENCE_TIME_4NODES.

Parameter sources. RTL-SDR Blog V4 frequency range and sample rate — manufacturer documentation at rtl-sdr.com. €25 price — 2025-2026 retail. Silvus StreamCaster 4,600 channels in 140-600 MHz — Silvus published specifications. CFAR threshold formula α = N·(Pfa^(-1/N) - 1) — Richards Fundamentals of Radar Signal Processing (McGraw-Hill 2005, Ch. 7). Krasukha-4 parameters — RUSI Watling & Reynolds 2023.

Operational estimates — not validated by FSG-A field testing. The 107 ms scan time is computed from SDR sample rate; not measured on real RTL-SDR hardware. The 2-3 second mesh convergence is estimated from Silvus beacon interval; not measured on a real 4-node mesh. The 15 dB threshold includes a 1.6 dB engineering margin above the strict CFAR derivation (13.4 dB) which FSG-A has not calibrated against real interference patterns. The graceful-degradation throughput model (Step 4) assumes ideal channel-bandwidth scaling, which real Silvus implementations may deviate from by 10-20%.

External standards and references. Richards, Fundamentals of Radar Signal Processing (McGraw-Hill 2005). ITU-R SM.2256 (spectrum monitoring). Silvus StreamCaster adaptive FHSS technical specifications. ExpressLRS documentation. RUSI Watling & Reynolds, "Electronic Warfare Lessons from Ukraine" (2023).