rflink — file transfer between two radios
rflink.py moves a file from one SDR to another over a frequency you choose.
It is a complete, if deliberately plain, radio: framing, whitening, sync,
carrier and timing recovery, CRC and reassembly, in one file with no
dependency beyond NumPy. It exists to make the parts of a link visible — you
can read the whole modem in an afternoon, then break it on purpose and watch
what fails.
It transmits and receives with a HackRF (One or Pro, or one of each)
through hackrf_transfer, and with a CaribouLite HAT through that
project’s tx_test and SoapySDR. It will also receive with an RTL-SDR,
which costs about a fortieth as much and cannot transmit at all.
Nothing in the waveform depends on which radio you have, so the two ends need
not match: a CaribouLite on a Pi can send to a HackRF on a laptop, and the
only flag that changes is --radio. See Using a
CaribouLite for what that radio needs first.
Quick start
List what is attached:
$ ./rflink.py devices
hackrf 0: 000000000000000087c867dc2d0e405f HackRF One
hackrf 1: 0000000000000000977c64de2d3f4a13 HackRF Pro
caribou S1G: CaribouLite S1G[eb9c2540] [389.5-510 MHz and 779-1020 MHz]
caribou HiF: CaribouLite HiF[eb9c2541] [1-6000 MHz]
Check the modem without transmitting anything — this runs the waveform through a simulated channel with noise, a carrier offset, and a clock error:
$ ./rflink.py selftest
[st] 20000 B, 40 frames x 1, SNR 12.0 dB, CFO 18000 Hz, clock 20.0 ppm
[st] 2 Msps, 100 kbaud, +/-50 kHz dev, IF +300 kHz, 512 B/frame
[st] demodulated 1.80 s of signal in 0.26 s (7.0x realtime)
[st] PASS: 20000 bytes, name='payload.bin', sha256 matches
With two radios on one host, loopback transmits on one and receives on the
other. Two HackRFs, or a HackRF and a CaribouLite — but not one CaribouLite,
whose two radios cannot run in opposite directions at once:
$ ./rflink.py loopback notes.pdf -o ./inbox --freq 915M --tx-serial one --rx-serial pro
[ ] tx 2d0e405f (HackRF One) -> rx 2d3f4a13 (HackRF Pro)
[tx] notes.pdf: 262191 bytes -> 513 frames x 1, 22.56 s on the air
[ ] 2 Msps, 100 kbaud, +/-50 kHz dev, IF +300 kHz, 512 B/frame
[rx] locked: 513 data frames (256.5 KiB), no FEC
[rx] 513/513 frames
[rx] OK sha256 verified -- 262144 bytes -> ./inbox/notes.pdf
[rx] peak 20/127 (-16.1 dBFS), 0.00% clipped, 561 sync hits, 2 failed CRC
Over a link that drops things, add parity with --fec and the receiver
rebuilds what it never heard:
$ ./rflink.py send notes.pdf --freq 915M --fec 20
[tx] notes.pdf: 262198 bytes -> 639 frames x 1 (513 data + 126 parity,
generations of 212+42, survives 20% loss), 28.56 s on the air
...
[rx] OK sha256 verified -- 262144 bytes -> ./inbox/notes.pdf
[rx] Reed-Solomon rebuilt 15 lost frame(s)
Across two machines, start the receiver first — it exits as soon as the file is complete:
host-b$ ./rflink.py recv -o ./inbox --freq 905M
host-a$ ./rflink.py send notes.pdf --freq 905M --passes 2
--tx-serial and --rx-serial take a full serial, a serial suffix, or a
board name — one and pro are enough when you have one of each.
A board name will not match a radio that is already open. hackrf_info
reads the model out of the device, so it can only report one for a radio it
can claim; anything another process is using lists its serial and nothing
else, and devices shows it as in use elsewhere. Selecting by the last
eight characters of the serial always works and is worth preferring in
scripts:
$ ./rflink.py devices
hackrf 0: 000000000000000087c867dc2d0e405f in use elsewhere (select it by serial: ...)
hackrf 1: 0000000000000000977c64de2d3f4a13 HackRF Pro
$ ./rflink.py send notes.pdf --tx-serial 2d0e405f --freq 915M
This also means the radio --tx-serial/--rx-serial defaults to — the first
one listed — is whichever hackrf_info enumerated first, not whichever is
free. With two HackRFs, say which you mean.
On an amateur allocation, give the tool your call sign and it will identify the station at the start, at the end, and every ten minutes in between:
$ ./rflink.py send notes.pdf --freq 915M --callsign AD7KM
$ export RFLINK_CALLSIGN=AD7KM # or set it once
The ID rides in the same modulation as the data, so any receiver that can hear the file can read the ID:
[rx] station ID: DE AD7KM
Setting the gains
This is the only part that reliably needs attention, and the failure is not
the one you expect. Too much gain is worse than too little. A GFSK burst
has a constant envelope; once the front end clips, the envelope is no longer
constant and the discriminator produces nonsense even though the signal looks
enormous. On the bench here, --rx-lna 40 --rx-vga 40 gave a 31 dB SNR
capture that decoded zero frames, while backing the VGA off by 14 dB
decoded all of them.
The receiver prints the number that matters:
[rx] peak 20/127 (-16.1 dBFS), 0.00% clipped, 561 sync hits, 0 failed CRC
Aim for a peak somewhere between about 15 and 100 of 127. Below ~12 you are
fighting the 8-bit quantiser; at 127 you are clipping. sync hits versus
failed CRC tells you which half of the problem you have: hits with no
frames means the signal is arriving but the bits are wrong, so fix the level;
no hits at all means nothing is arriving, so check the frequency, the
antennas, and that both ends agree on the waveform parameters.
The defaults (--tx-gain 30 --rx-lna 32 --rx-vga 24, both amplifiers off)
land mid-scale for two radios on a bench a short distance apart.
Antennas matter less than you would expect over a benchtop. The link above was measured on antennas cut for 978 MHz, used at 915 MHz — about 6% off resonance, which is a real mismatch and completely immaterial when the two radios are a few feet apart. Over any distance worth the name, cut the antenna for the band you are using.
How the link works
| Stage | Choice |
|---|---|
| Modulation | Gaussian 2-FSK, modulation index 1, BT 1.0 |
| Detection | FM discriminator, boxcar matched filter, non-coherent |
| Default rate | 2 Msps, 20 samples/symbol → 100 kbaud, ±50 kHz deviation |
| Placement | Shifted +300 kHz from the tuned centre, off the LO spur |
| Preamble | 64 alternating symbols |
| Sync | 63-chip m-sequence (x⁶+x⁵+x²+x+1), aperiodic sidelobes ≤ 0.11 |
| Whitening | PN9, x⁹+x⁵+1 seeded to all ones — the CC1101 scheme |
| Frame | seq, total, length, data-frame count, k, m, 512 B payload, CRC-32 |
| FEC | Cauchy Reed-Solomon over GF(256), erasure-only, off by default |
| Guard | 16 trailing symbols so the amplitude ramp misses the data |
Throughput is about 11.6 kB/s of file at the default settings.
Three details are worth knowing, because each one was a bug first.
The signal does not sit at the tuned centre. A HackRF One leaks its local
oscillator into the middle of its own passband. Putting the FSK at a +300 kHz
baseband offset and mixing it back down in software moves the data off that
spur at both ends. --if-offset 0 turns this off, and on a HackRF One you can
watch the error rate climb when you do.
Each frame stands alone. There is no reverse channel and no shared clock. A frame carries its own preamble and sync word, so timing and carrier offset are recovered 23 times a second from scratch. The carrier offset falls out for free: on an FM discriminator it is a DC term, and since the sync word is balanced and the payload is whitened, the mean of the frame is the offset.
Clock error is recovered by retrying, not by tracking. Nothing re-syncs the symbol clock inside a frame, so a 4,399-symbol frame drifts. Rather than build a timing loop, the receiver re-slices a failed frame at a few trial clock rates (0, ±100, ±200, ±300, ±400, ±500 ppm) and keeps whichever passes CRC. Two HackRFs are normally within 20 ppm and never leave the first entry; the ladder costs nothing until something goes wrong, and buys ±550 ppm (measured: intact at ±550, failing by ±600).
Reliability
A frame either passes CRC-32 or is discarded. That makes the channel the receiver sees an erasure channel — it always knows exactly which frames it is missing — and an erasure channel is a much easier thing to code against than an error channel, worth twice the correction for the same parity.
--fec PCT adds Reed-Solomon parity frames. The code is the Cauchy form over
GF(256): the generator is [I ; C] with C a Cauchy matrix, every square
submatrix of which is invertible, so any k of the k+m frames in a
generation rebuild it — it does not matter which ones arrive. Frames are
grouped into generations of at most 255, since that is as far as GF(256)
reaches; a 256 KiB file at --fec 20 becomes three generations of 212 data
plus 42 parity.
PCT counts parity against the data, so the loss a transmission survives
is PCT/(100+PCT) — --fec 20 tolerates 17%, --fec 50 tolerates 33%. The
tool prints the real figure rather than making you do the arithmetic, and it
holds exactly: at --fec 100 the link recovers from losing 49% of the
frames and fails at 51%.
The receiver needs no flag. Every frame carries the generation layout in
its header, so the receiver discovers the scheme from whatever frame it hears
first. --fec is purely a transmitter decision.
--passes N still exists and sends the whole file N times. It is almost
always the worse deal: two passes costs 100% overhead to survive 50% loss,
where --fec 100 costs the same and survives the same, and --fec 20 costs
20% to survive 17%.
Measured against the built-in channel simulator: the link is clean down to
about 12 dB in-band SNR, and tolerates ±72 kHz of carrier offset (79 ppm at
915 MHz, failing by ±85 kHz) and ±550 ppm of sample-clock error. Below ~10 dB
SNR an uncoded 4,256-bit frame falls apart quickly, and that is where --fec
earns its airtime.
You can watch it work without a radio — --drop blanks whole frames where
they sit in the waveform, the way a burst of interference does:
$ ./rflink.py selftest --bytes 262144 --fec 20 --drop 15
[st] 262144 B, 639 frames x 1 (513 data + 126 parity, ... survives 20% loss)
[st] SNR 12.0 dB, CFO 18000 Hz, clock 20.0 ppm, blanking 95/639 frames (15%)
[st] Reed-Solomon rebuilt 75 lost frame(s)
[st] PASS: 262144 bytes, sha256 matches
Using a CaribouLite
The CaribouLite is a Raspberry Pi HAT carrying one AT86RF215 transceiver, which SoapySDR presents as two one-channel radios:
| Radio | --cb-channel |
tx_test -c |
Tuning |
|---|---|---|---|
| S1G | s1g |
0 | 389.5–510 MHz and 779–1020 MHz |
| HiF | hif |
1 | 2385–2495 MHz native, the rest via an RFFC5072 mixer |
--cb-channel auto, the default, picks S1G wherever it reaches, because it is
direct conversion and brings no mixer LO with it. At 915 MHz that is the one
you want.
$ ./rflink.py send notes.pdf --radio caribou --freq 915M --callsign AD7KM
$ ./rflink.py recv -o ./inbox --radio caribou --freq 915M
--radio auto prefers a HackRF and falls back to a CaribouLite, so on a Pi
that has only the HAT you can leave the flag off entirely.
What the board needs first
Transmitting needs the unmerged transmission_fix work — a stock
CaribouLite receives perfectly and radiates nothing at all. Build and install
it as ../cariboulite/txfix/README.md
describes, including install-persistent.sh, which is what makes it survive a
reboot. rflink.py finds tx_test on $PATH, at
~/cariboulite-txfix/release/tx_test, or wherever --cb-tx-test or
$RFLINK_TX_TEST points.
Receiving needs the SoapySDR Python bindings (python3-soapysdr). Install
python3-scipy as well: without it the demodulator falls back to NumPy
convolution and runs at 0.5x realtime on a Pi 4 instead of 0.7x, and neither
is fast enough for 2 Msps — see Keeping up on a
Pi below.
The transmit path is spectrally inverted — on one channel
Measured here against a HackRF Pro at 915 MHz, with a tone 300 kHz above the carrier:
| Path | Where a +300 kHz tone lands | Mirrored? |
|---|---|---|
| S1G transmit | −300 kHz | yes |
| HiF transmit | +300 kHz | no |
| S1G receive | +300 kHz | no |
| HiF receive | +300 kHz | no |
Both receive rows were then confirmed the better way, by decoding a file off the air with the sha256 matching — a mirrored receiver decodes nothing at all, so a clean transfer settles the sign where a spectrum plot of a weak tone does not. (It nearly fooled me: at a gain low enough to leave the tone in the quantisation noise, the wanted sideband and its image read within 3 dB of each other, which looks exactly like an inversion.)
So rflink.py conjugates the waveform before handing it to tx_test on S1G
and not on HiF, and says which it did. You do not have to think about it, but
it is worth knowing why the table is not uniform: the HiF path runs the modem
at 2495 MHz and mixes against a 3410 MHz LO, so the emission is the difference
and comes out mirrored a second time, which cancels the first.
This matters because getting it wrong does not look like a sign error. The sync word still correlates, so the receiver reports a healthy stream of sync hits and then fails every single CRC:
[rx] no frames recovered
[rx] peak 110/127 (-1.2 dBFS), 0.00% clipped, 16 sync hits, 16 failed CRC
When a transmission is accepted but never radiated
This is the failure to know about, because every exit status is zero and
tx_test reports success. The symptom is in the clock:
[tx] WARNING: 8.7 s of waveform was accepted in 4.3 s (2.0x real time), 133
blocks. The radio cannot have clocked it out that fast, so it was
buffered and discarded: nothing, or almost nothing, reached the air.
[tx] Recover with: sudo systemctl restart cariboulite-fpga.service
A transmitter that is working clocks samples out at the sample rate, so a
10 s waveform takes 10 s. A broken one swallows the whole stream into a
buffer that never reaches the radio and returns quickly. Confirmed with a
spectrum capture: in that state a 10 s tone produces no burst at all,
while after the service restart the same command puts 9.8 s of energy on the
air at a peak of 37.8/127. rflink.py times every transmission and says so.
Do not read tx_test’s own Is synchronized to incoming I/Q line as the
test. It is printed only every few seconds, and its first report is issued
before the stream starts and always reads 0 — so any transmission of a few
seconds shows a single 0 and proves nothing. An earlier version of this tool
treated that as failure and cried wolf on perfectly good transmissions.
The transmit path is the noisy one — size your frames for it
The CaribouLite receives beautifully and transmits adequately, and the difference is large enough to plan around. Both directions below are the same 8 KiB file, the same 32-byte frames, the same bench, a few metres apart:
| Direction | Frames | Failed CRC |
|---|---|---|
| HackRF transmits → CaribouLite receives | 448 of 448 | 0 of 451 |
| CaribouLite transmits → HackRF receives | complete, 27 rebuilt by FEC | 38 of 388 |
So the receiver is not the limit and neither is the modem: with the CaribouLite transmitting, something in its transmit chain puts a floor under the bit error rate. Measuring it directly — decoding every sync hit without the CRC gate and comparing against the frames that were actually sent — puts it at about 5 × 10⁻⁴, a median of 2 bit errors in a 4256-bit frame, spread evenly through the frame rather than drifting or arriving in bursts. Raising the transmit gain, lowering it, moving the signal nearer the carrier and changing the amplitude all left it where it was.
Two bit errors in 4256 sounds like nothing, and for a CRC it is fatal: the frame is 99.95% correct and still discarded. That is the whole story of the default configuration failing while the link is plainly working —
[rx] incomplete: 16/65 data frames, missing 49
[rx] peak 34/127 (-11.4 dBFS), 0.00% clipped, 66 sync hits, 50 failed CRC
— every frame found, three in four thrown away. The cure is shorter frames, because the chance of a clean frame falls exponentially with its length. At 512 bytes a frame is 4256 bits and about a quarter survive; at 32 bytes it is 416 bits and about nine in ten do. Add parity and the file completes:
$ ./rflink.py send notes.pdf --radio caribou --freq 915M \
--frame-bytes 32 --fec 60
$ ./rflink.py recv -o ./inbox --freq 915M --frame-bytes 32 # the other end
[rx] OK sha256 verified -- 8192 bytes -> ./inbox/notes.pdf
[rx] Reed-Solomon rebuilt 27 lost frame(s)
--frame-bytes has to match at both ends; --fec does not, because the
receiver reads the layout out of the frames. Transmitting to a CaribouLite
needs none of this — the defaults are fine in that direction.
One board cannot be both ends
loopback wants two radios, and a single CaribouLite is not two for this
purpose: its radios share one SMI bus, which carries one direction at a time.
Measured — transmitting on S1G while receiving on HiF delivers zero
samples, not merely fewer. rflink.py refuses the combination and says why.
A CaribouLite and a HackRF on the same host do work, and loopback will pick
that pairing on its own, transmitting on the CaribouLite.
Keeping up on a Pi
The demodulator is the bottleneck, not the radio. On a Pi 4B with SciPy
installed it runs at about 0.7x realtime at 2 Msps, so a live recv falls
behind while a transmission is in progress and catches up afterwards. For a
transfer of a few seconds that is invisible. For a long listen it is not: the
receiver would otherwise grow its backlog at about 1 MB/s until something
ran out of memory, so the queue is bounded at 256 MB and the tool warns
instead:
[rx] warning: the demodulator is behind the radio and 1 MB of signal has been
dropped -- lower --sample-rate (a Pi manages about 1.4 Msps), or capture
with --capture and run `demod` afterwards
Halving the sample rate fixes it, and costs nothing in throughput if you halve
--sps with it — the symbol rate is rate/sps, so 1 Msps with --sps 10 is
the same 100 kbaud at 1.3x realtime. The CaribouLite clocks only 0.4, 0.5,
0.667, 0.8, 1, 1.333, 2 and 4 Msps; anything else is rejected rather than
silently rounded.
Below 2 Msps the default IF offset scales with the sample rate, to 15% of it,
because a fixed 300 kHz would push the upper FSK sideband into the band edge:
at 1 Msps that costs 12 frames in 40 that the link keeps at 150 kHz. Both
ends compute the same default from the same sample rate, so there is nothing
to coordinate — but if you set --if-offset by hand, set it on both.
Receiving with an RTL-SDR
The rtl subcommand receives with a DVB-T dongle. It is the same
demodulator — the dongle just hands it samples — so there is nothing to keep
in step between the two tools:
$ ./rflink.py rtl -o ./inbox --freq 915M
[rx] listening on 915.000 MHz -- 2.4 Msps, 100 kbaud, +/-50 kHz dev, ...
Found Elonics E4000 tuner
Tuned to 915000000 Hz. Tuner gain set to automatic.
[rx] locked: 513 data frames (256.5 KiB), +126 parity
[rx] OK sha256 verified -- 262144 bytes -> ./inbox/notes.pdf
[rx] peak 127/127 (+0.0 dBFS), 31.06% clipped, 520 sync hits, 1 failed CRC
Two things make this work despite the dongle being a different radio entirely.
Only the symbol rate has to match, not the sample rate. The transmitter runs at 2 Msps with 20 samples per symbol; the dongle defaults to 2.4 Msps with 24. Both come out at 100 kbaud, which is the only number the two ends share. An RTL2832U will not lock to 2 Msps reliably but is perfectly happy at 2.4, 1.6, or 1.2 — all of which divide 100 kbaud into a whole number of samples, and all of which are tested:
$ ./rflink.py rtl -o ./inbox --sample-rate 1.2M --sps 12 # lighter on USB
The dongle’s crystal error does not need correcting. A cheap dongle can
be tens of ppm off, which at 915 MHz is tens of kHz. The link already
recovers carrier offset per frame and already tries a ladder of symbol-clock
rates, so it absorbs this for free — a 50 ppm dongle (45 kHz at 915 MHz) is
well inside what was measured. --ppm is there if you have calibrated yours
and want the margin back.
What the dongle gives up: it cannot transmit, and it has a worse noise figure
and a worse front end than a HackRF. Its tuning range depends on which tuner
yours has, which you discover by plugging it in — an R820T2 covers
24–1766 MHz, an E4000 reaches 2184 MHz but starts at 53 MHz and has a hole
from 1095 to 1258 MHz. rtl knows all three limits and says which one you
have run into:
$ ./rflink.py devices
hackrf 0: 000000000000000087c867dc2d0e405f HackRF One
rtl 0: Realtek, RTL2838UHIDIR, SN: 00000001 [Elonics E4000, gain -1.0-42.0 dB] (receive only)
$ ./rflink.py rtl -o ./inbox --freq 1200M
[rtl] note: 1200.000 MHz falls in the E4000's L-band gap (1095-1258 MHz); an R820T2 covers it
Gain defaults to the dongle’s own AGC (--gain 0); pass a figure in dB to
pin it, choosing from the list devices prints.
Measured, on a Realtek RTL2838 with an Elonics E4000 tuner, receiving a
HackRF One at 915 MHz: 256 KiB byte-identical at 2.4 Msps, and 32 KiB
byte-identical at 1.2 Msps, both on the dongle’s own AGC with nothing
adjusted. With a resonant 915 MHz antenna the AGC runs the converter all the
way to full scale — 31% of samples clipped in the run above — and it still
decodes, so --gain (automatic) is a reasonable default to leave alone.
Punching fifteen frame-length holes through a captured reception cost
thirteen data frames at --fec 30, and Reed-Solomon rebuilt all thirteen.
Capture with rtl_sdr for that test, not rtl --capture: the receiver stops
once it has every data frame, so its own recording ends before the parity
frames go out.
The dongle is less sensitive than a HackRF at the weak end, but with a
resonant antenna not by much: it decoded cleanly at --tx-gain 10 and heard
nothing at 8, where a HackRF receiver was clean at 8 and still recovering
70/129 frames at 6. Two to four dB. With the stock telescopic whip the same
dongle was deaf at --tx-gain 22, so check the antenna before blaming the
radio.
A capture from rtl_sdr can also be decoded offline, but tell demod about
the format — the RTL2832U emits unsigned bytes centred on 127.5, where a
HackRF emits signed ones:
$ rtl_sdr -f 915000000 -s 2400000 -g 0 air.cu8
$ ./rflink.py demod air.cu8 -o ./inbox --format u8 --sample-rate 2.4M --sps 24
Sample rate
The default is 2 Msps because it keeps USB and CPU load low and works on a bench. Great Scott Gadgets recommend against sampling below 8 MHz: the MAX2837 baseband filter bottoms out at 1.75 MHz, so at 2 Msps a signal 2 MHz away from where you are tuned aliases into the middle of your capture with only about 33 dB of attenuation. In a quiet lab that does not matter. Near anything else transmitting in the band it might, and the cure is to oversample so the analogue filter sits well inside Nyquist:
$ ./rflink.py loopback notes.pdf -o ./inbox --sample-rate 8M --sps 80
That keeps the same 100 kbaud on the air, at four times the USB bandwidth. The receiver low-pass filters and then decimates back down before demodulating, so the CPU cost grows much less than fourfold: measured here, 6.6x realtime at 2 Msps against 2.7x at 8 Msps. Both ends must use the same settings.
Everything else
modulate writes the waveform to an IQ file without touching a radio, and
demod recovers a file from a capture. Both are useful for looking at the
signal in Inspectrum or URH, or for replaying a capture after changing the
receiver. modulate writes int8 by default, or the int16 that tx_test
expects, already conjugated, with --radio caribou:
$ ./rflink.py modulate notes.pdf -o wave.iq
$ ./rflink.py recv -o ./inbox --capture air.iq --timeout 60
$ ./rflink.py demod air.iq -o ./inbox
Both ends must agree on --sample-rate, --sps, --deviation,
--if-offset, --bt, and --frame-bytes. Mismatched settings show up as
sync hits with no decoded frames.
Legality
Receiving is passive and, across most of the spectrum, unrestricted in the US. Transmitting is not.
The default of 915 MHz, amplifier off, sits in 902–928 MHz: the US ISM band, where FCC Part 15.247 permits unlicensed operation inside its power and bandwidth limits. That band is also the amateur 33 cm allocation, so a licensed amateur has a second basis for operating there and more headroom. 70 cm (420–450 MHz, which contains the 433.92 MHz everyone reaches for) is amateur-only in the US — fine with a licence, a federal offence without one. Other countries allocate differently.
Two things follow for anyone operating this under Part 97:
- Identify. 47 CFR 97.119 wants your call sign at the end of each
communication and at least every ten minutes during one.
--callsigndoes that; without it the tool transmits unidentified, which is exactly what the rule prohibits. - Do not encrypt. 47 CFR 97.113(a)(4) prohibits “messages encoded for the purpose of obscuring their meaning”. The PN9 whitening here is not encryption — it is a fixed, published scrambler with no key, applied so the radio sees DC-free data, and anyone with this source can undo it. Sending an encrypted file over the link is a different question, and the answer on amateur allocations is no.
The transmitter refuses some bands
send and loopback will not transmit inside a safety-of-life allocation:
| Band | What lives there |
|---|---|
| 108–137 MHz | Aeronautical navigation and ATC voice (VOR, ILS, tower) |
| 242.5–243.5 MHz | Military distress and SAR beacons |
| 406.0–406.1 MHz | COSPAS-SARSAT emergency locator beacons |
| 960–1215 MHz | DME/TACAN, and ADS-B on 978 MHz (UAT) and 1090 MHz |
| 1559–1610 MHz | GPS L1, Galileo E1, GLONASS L1 |
None of these overlaps a US amateur allocation, so the guard never stands
between you and a band you are licensed for. It exists because 978 MHz is a
plausible typo away from 915 MHz, especially with a 978 MHz antenna screwed
on, and because a software bug should not be able to put a carrier into the
ADS-B channel. Receiving on those frequencies is untouched. --force-band
overrides, for a cable or a screen room.
References
- Great Scott Gadgets, HackRF documentation — https://hackrf.readthedocs.io/en/latest/
- Great Scott Gadgets, Sampling Rate and Baseband Filters — https://hackrf.readthedocs.io/en/latest/sampling_rate.html
hackrf_transfer(1)man page — https://dyn.manpages.debian.org/testing/hackrf/hackrf_transfer.1.en.html- Texas Instruments, DN509: Data Whitening and Random TX Mode (SWRA322), the PN9 generator — https://www.ti.com/lit/pdf/swra322
- FCC, 47 CFR § 15.247, operation in the 902–928 MHz band — https://www.ecfr.gov/current/title-47/chapter-I/subchapter-A/part-15/subpart-C/subject-group-ECFR0d9f8a0e3d81b76/section-15.247
- FCC, 47 CFR § 97.119, station identification — https://www.law.cornell.edu/cfr/text/47/97.119
- FCC, 47 CFR § 97.113, prohibited transmissions — https://www.law.cornell.edu/cfr/text/47/97.113
- NTIA, Compendium of Frequency Band Allocations, 960–1164 MHz — https://www.ntia.gov/files/ntia/publications/compendium/0960.00-1164.00_01MAR14.pdf
- CaribouLabs, CaribouLite SDR — https://github.com/cariboulabs/cariboulite
- CaribouLite issue #189, the transmitter never locking to the I/Q stream — https://github.com/cariboulabs/cariboulite/issues/189
- CaribouLite PR #197, Transmission of arbitrary waveforms, closed unmerged — https://github.com/cariboulabs/cariboulite/pull/197
- Microchip, AT86RF215 data sheet (DS70005359), the I/Q radio interface — https://ww1.microchip.com/downloads/en/DeviceDoc/AT86RF215-Data-Sheet-DS70005359D.pdf
- Pothosware, SoapySDR — https://github.com/pothosware/SoapySDR/wiki
- Building the CaribouLite transmit fix — ../cariboulite/txfix/README.md
- Exercising the CaribouLite’s two radios — ../cariboulite/README.md
- Course notes on SDR and radio protocols — radio.md