cariboulite — exercising a dual-radio SDR HAT
The CaribouLite is a software-defined radio that mounts as a Raspberry Pi HAT
and carries two independent receivers. cariboulite_demo.py drives both of
them through SoapySDR: it enumerates them, prints what each claims it can do,
captures IQ off each, and analyses the spectrum. spur_check.py and
both_at_once.py answer two questions the demo raises.
Everything here is receive-only. The transmitter is never keyed.
The hard part of this board is not the code, it is getting the kernel to talk
to it at all — see Enabling the hardware below, and
setup/.
Quick start
Two tools live here: cariboulite_demo.py exercises both radios on receive,
and cariboulite_tx_demo.py transmits on 70 cm (licence required — see
Transmitting on 70 cm).
$ ./cariboulite_demo.py --list
SoapySDR 0.8.1-5+b2 / API 0.8.0
found 2 radio(s): HiF, S1G
HiF CaribouLite HiF[eb9c2541]
S1G CaribouLite S1G[eb9c2540]
==============================================================================
S1G
==============================================================================
hardware: Cariboulite Rev2.8
fpga_revision: 1
product_name: CaribouLite RPI Hat
channels: 1 RX, 1 TX
antennas: TX/RX Sub1GHz
RX tuning: 389.5000 MHz - 510.0000 MHz | 779.0000 MHz - 1.0200 GHz
sample rates: 0.4, 0.5, 0.6667, 0.8, 1, 1.333, 2, 4 Msps
RX gain: 0 - 69 dB (elements: Modem AGC)
formats: CS16, CS8, CF32, CF64 (CS16 native per plugin source)
Then the real thing — three captures across both radios:
$ ./cariboulite_demo.py
...
==============================================================================
SUMMARY
==============================================================================
test frequency result detail
S1G radio (AT86RF215 sub-GHz) 433.9199 MHz PASS -51.6 dBFS, peak +76.9 dB, 2.00 Msps
HiF radio (2.4 GHz native) 2.4370 GHz PASS -56.3 dBFS, peak +23.0 dB, 2.00 Msps
HiF radio (mixer path) 1.0900 GHz PASS -45.6 dBFS, peak +31.9 dB, 2.00 Msps
3/3 passed
Both radios exercised successfully.
Exit status is 0 only if every case passes, so it works as a bench check.
--s1g-freq, --hif-freq, --hif-mixer-freq, --rate, --gain, --agc,
and --nsamples retarget it.
The two radios
| Radio | Front end | RX tuning |
|---|---|---|
| S1G | AT86RF215 sub-GHz | 389.5–510 MHz and 779–1020 MHz |
| HiF | AT86RF215 2.4 GHz + RFFC5072 mixer | 1 MHz – 6 GHz (mixer LO 85–4200 MHz) |
S1G has a hole between 510 and 779 MHz. It is not one continuous range, and asking for 600 MHz fails rather than tuning somewhere nearby. The demo validates against both windows and skips with a message instead.
The mixer only exists on the FULL board. The ISM variant has the same
AT86RF215 but no RFFC5072, so its second radio reaches only the native
2385–2495 MHz. The EEPROM tells you which you have: product_id 0x0001 is
system_type_cariboulite_full, 0x0002 is the ISM version.
$ tr -d '\0' < /proc/device-tree/hat/product
CaribouLite RPI Hat
This is why the demo tests the HiF radio twice: once at 2.437 GHz, inside the native window, and once at 1090 MHz, which is outside it and therefore can only be reached through the mixer. Passing the first proves the radio works; passing the second proves the mixer path does, which is the only thing distinguishing a FULL board from an ISM one.
Reading the output
tuned: 433.9199 MHz (requested 433.9200 MHz, error -0.1 kHz)
config: 2 Msps, gain 39 dB manual, antenna 'TX/RX Sub1GHz'
stream MTU: 131072 samples
drained 131072 samples in 0.112 s (queue drain, NOT an RF rate)
sustained rate: 2.000 Msps over 1.0 s (configured 2, 100.0%)
RMS level: -51.6 dBFS
peak |IQ|: 0.0038 (1.0 == clipping)
DC/LO spur: 29.8 dB above median (zero-IF LO leakage; expected)
strongest peak: 433.6074 MHz (-0.312 MHz from centre, DC notch excluded)
peak prominence: 76.9 dB above median
Three of those lines exist because the obvious version of them was wrong.
drained ... NOT an RF rate. The plugin runs a reader thread that fills a
circular buffer, so the first block you ask for mostly comes out of a queue
that is already full. Timing it reports tens of Msps — the first draft of
this tool cheerfully claimed 31.30 Msps on a radio configured for 2. The
sustained rate line is the real measurement: drain the backlog, then read
continuously for a wall-clock interval.
DC/LO spur is reported separately from strongest peak. The AT86RF215
is a zero-IF (direct conversion) receiver, so local-oscillator leakage lands
exactly at whatever you tuned to, 26–30 dB above the noise floor. Report the
largest bin naively and every test triumphantly discovers a strong carrier
that is really the radio hearing itself. The demo masks a window around the
centre (±25 kHz by default) and searches outside it.
peak prominence is measured against the median, not the mean, so a
single strong carrier does not drag up its own reference.
Is that peak real?
The 76.9 dB spike above is genuine — there is a transmitter near 433.607 MHz on this bench. Distinguishing a real signal from an artifact takes one idea: retune and see what moves.
- A real signal stays at a fixed absolute frequency.
- An LO/DC artifact stays at a fixed offset from centre — it follows your tuning.
- A digital artifact stays at a fixed fraction of the sample rate — it moves when you change the rate.
- A local comb line also stays at a fixed absolute frequency, because it really is being emitted — by your own host. This Pi and HAT produce one on every multiple of 500 kHz across 70 cm. It passes both tests above; what gives it away is landing on a suspiciously round grid, and disappearing from nothing when you unplug the antenna. See the transmit section.
spur_check.py does the first test, sweeping the centre frequency:
$ ./spur_check.py S1G 434.52e6 435.12e6
### tuned centre peak absolute peak offset prominence
### 434.5200 MHz 434.5200 MHz +0.0000 MHz 26.5 dB
### 435.1199 MHz 435.1199 MHz +0.0000 MHz 26.4 dB
Offset pinned at zero across different centres: that is LO leakage, and it is
why the demo masks the centre. For the third test, change --rate and watch
the absolute frequency instead — the 433.607 MHz carrier reads identically at
1, 2, and 4 Msps, which no digital artifact would do.
Both radios at once
They do run simultaneously, but not at full rate. both_at_once.py opens
both, drains both backlogs, then reads them round-robin for five seconds:
$ ./both_at_once.py 2e6
### rate=2 Msps each, activate: S1G=0 HiF=0
### S1G: 5013504 samples / 5.01 s = 1.000 Msps ( 50% of configured), 0 ovf
### HiF: 5013504 samples / 5.01 s = 1.000 Msps ( 50% of configured), 0 ovf
### aggregate: 2.000 Msps across both radios
Measured on a Pi 4B, zero overflows throughout:
| Configured each | Delivered each | Aggregate |
|---|---|---|
| 1 Msps | 0.667 Msps (67%) | 1.333 Msps |
| 2 Msps | 1.000 Msps (50%) | 2.000 Msps |
| 4 Msps | 2.000 Msps (50%) | 4.000 Msps |
At 2 and 4 Msps each radio gets exactly half what it asked for. The 1 Msps row does not follow that rule, and both of its figures (0.667 and 1.333) are themselves supported sample rates, which suggests the pair is being re-clocked rather than simply time-shared. Treat the halving as an observation, not a documented specification, and re-measure before designing around it.
Transmitting on 70 cm
cariboulite_tx_demo.py sends an identified, deliberately narrow, low-power
transmission on the 70 cm amateur band. It keys a real transmitter. You
need an amateur licence to run it as-is; --dry-run builds and measures the
waveform, runs the band-plan check, and transmits nothing.
$ ./cariboulite_tx_demo.py --callsign AD7KM --dry-run # safe, no RF
$ ./cariboulite_tx_demo.py --callsign AD7KM # keys the radio
$ ./cariboulite_tx_demo.py --callsign AD7KM --freq 445.9e6 --tx-gain 10
It sends a CW station identification, a short 2-FSK data burst, then the CW
identification again — 47 CFR
97.119(a) requires ID at the
end of each communication and at least every ten minutes within one. Without
--callsign it refuses to transmit at all, and it refuses a payload that
would run more than nine minutes between IDs.
What it refuses
The band check covers the whole occupied span including the LO leakage
carrier, not just the centre frequency. It is a hard refusal (overridable
only with --force-band, which prints a warning) for:
| Segment | Why |
|---|---|
| outside 420–450 MHz | not the 70 cm band |
| 435.00–438.00 | satellite only, internationally |
| 432.00–432.07 | EME |
| 432.07–432.10 | weak-signal CW |
| 432.10–432.30 | mixed-mode/weak-signal, incl. the 432.10 calling frequency |
| 432.30–432.40 | propagation beacons |
| 432.40–433.00 | mixed-mode and weak-signal work |
and a printed warning for the repeater, ATV, auxiliary-link, and local-option segments, plus a note that 420–430 MHz is unavailable north of Line A.
$ ./cariboulite_tx_demo.py --callsign AD7KM --dry-run --freq 436e6
REFUSING: 435 MHz-438 MHz is satellite only (internationally) -- not for terrestrial use
aborting: see the band-plan refusal above (--force-band overrides)
Default emission is 445.500 MHz, in the 445–447 shared block that explicitly includes simplex. That block is local option — check with your frequency coordinator rather than trusting the table in the script.
Knobs
| Flag | Default | Notes |
|---|---|---|
--callsign |
none | mandatory; no transmission without it |
--freq |
445.500e6 | intended emission frequency |
--tx-gain |
0 | 0 ≈ −14 dBm, 31 ≈ +13 dBm (see below) |
--rate |
400e3 | DAC rate; the signal inside is far narrower |
--tone |
10e3 | baseband offset, keeps the signal off the LO spur |
--baud / --deviation |
1000 / 1000 | FSK burst, ≈3.4 kHz occupied |
--listen |
6.0 | seconds of listen-before-transmit; 0 to skip |
--dry-run |
off | build and measure, transmit nothing |
--force-band |
off | override a band-plan refusal |
Three things to know before you trust a transmission
writeStream() does not back-pressure. It swallowed a 4.62 s waveform in
0.02 s and returned success for every sample; tearing the stream down then
means most of the transmission never reached the air. The demo paces writes
against the wall clock, waits out the buffered tail, and reports elapsed time
against waveform length so you can check:
transmitted : 4057600 samples in 10.34 s (waveform 10.14 s)
If those two numbers diverge, samples were dropped and it says so.
The gain comment in the plugin is wrong. Soapy TX gain maps to
cariboulite_radio_set_tx_power(gain - 18), which clamps S1G to
[−14, +14] dBm. So gain 0 is ≈ −14 dBm (40 µW), not the −18 dBm the comment
claims, and gain 31 is ≈ +13 dBm (20 mW).
The board cannot hear itself. Measured three ways:
| TX | RX | TX gain | Samples received |
|---|---|---|---|
| S1G | HiF | 0 | none |
| HiF | S1G | 0 | 188 416 (≈2% of rate), no tone detected |
| HiF | S1G | 10 / 20 / 31 | none |
Two receive streams run concurrently without trouble, so this is not an SMI bandwidth limit — transmitting blanks the receive path. Confirming that your signal actually radiated needs a separate receiver.
Verified against an external receiver: it does not radiate
Confirmed with a HackRF Pro on a separate machine, because this board cannot hear itself. Nothing was detected, at −14 dBm or at full +13 dBm:
| Method | Result |
|---|---|
| baseline vs transmit capture | 2.3 dB at the expected bin (3.1 dB with no transmission) |
| difference spectrum across 2 MHz | no rise attributable to the keying |
| on/off keying within one capture | +0.46 dB at the emission bin, uncorrelated with the key |
Comparing separate captures is unreliable here — the local noise floor moved 10 dB between two runs minutes apart. Keying on and off inside a single continuous capture controls for that, and showed nothing.
To rule out “the machines are just too far apart”, the link was driven in reverse: HackRF transmitting keyed CW, CaribouLite listening. That gave a +16.4 dB lift at 20.9 sigma, with visible dips at the CW inter-character gaps. The path works. The receiver works. The same path in the other direction, from a transmitter the API reports as +13 dBm, gave nothing.
So the I/Q transmit path is not radiating. activateStream returns 0,
writeStream consumes every sample, gain reads back, elapsed time matches
the waveform — none of which is evidence of RF.
The RF front end is fine; only the I/Q path fails
setupStream takes a CW=1 argument, which makes the driver use its
cw_output branch: that overrides the modem’s DAC with constant I/Q and
emits a bare carrier, with no SMI streaming at all. Keyed on and off in Morse
(which doubles as station ID) and watched on the HackRF:
key-down mean -59.30 dB, key-up mean -70.19 dB
LIFT +10.89 dB, correlation with key state r = +0.693
So the synthesiser, PA, antenna switch, and antenna all work. Four candidate fixes were each rebuilt and re-measured with the same three-burst protocol, and all four measured as noise:
| Change | Result |
|---|---|
uncomment the cmd_tx transition at cariboulite_radio.c:1223 |
+0.49 dB, 0.5 sigma |
also force .tx_control_with_iq_if = false |
+0.34 dB, 0.4 sigma |
force-reprogram the FPGA from firmware/top.bin (cariboulite_util -F 1) |
+0.21 dB, 0.3 sigma |
| pristine upstream code on the freshly programmed FPGA | +0.21 dB, 0.3 sigma |
The commented-out line at cariboulite_radio.c:1223 looks exactly like the
bug — the CW branch ends with that same call live — but restoring it changes
nothing measurable, so it is a symptom of unfinished work, not the cause.
The root cause, from upstream
In the I/Q branch the modem’s DAC is fed from its LVDS I/Q interface, which
the FPGA must drive from SMI. The FPGA sources are in the vendor repo, under
firmware/, and the transmit path is implemented there: lvds_tx.v exists,
smi_ctrl.v exposes TX FIFO ports, and top.v instantiates lvds_tx against
them. The shipped top.bin was rebuilt as recently as commit 1b34c56. So the
datapath is not missing.
It is broken in a documented way. Upstream
issue #189 —
“AT86RF215 input IQ sync not reached on LVDS interface during TX” — reports
that the modem’s IQIFC2.SYNC bit never becomes 1 while transmitting:
Status 'Is synchronized to incoming I/Q': 0
The modem never locks onto the I/Q stream the FPGA sends it, so its DAC is
never fed. The modem’s internal loopback does reach sync, which is exactly
why CW=1 — which bypasses the LVDS stream and overrides the DAC with
constants — radiates while streaming does not. Open since February 2024, and
confirmed still broken by another user on 2 November 2025.
A fix exists, and was never merged
The reporter traced it (“The bug was in the fpga code. Now it’s syncing”)
and opened PR #197, “Transmission of arbitrary waveforms”
— 34 commits across the FPGA, the kernel driver, and the library, centred on a
new firmware/lvds_clock_sync.v, plus rewrites of lvds_tx.v, smi_ctrl.v,
and top.v, a +292-line change to driver/smi_stream_dev.c, and a tx_test
tool (the I/Q transmit test upstream never had). It was closed unmerged, with
no review comments, on 5 August 2025.
The work lives on outside the project, on the transmission_fix branch of
matteoserva/cariboulite,
48 commits ahead of upstream main and still maintained as of November 2026.
It cross-builds from an x86-64 host (cmake, gcc-aarch64-linux-gnu, yosys,
nextpnr-ice40, icepack) and produces top.bin, flash_fpga, tx_test, and
the kernel module. It deletes the prebuilt bitstream, so you must rebuild
it, and reflash after every power cycle.
The branch was since built and run on this board, and it works: the sync bit
reaches 1 and an external receiver sees +62.3 dB where the stock code managed
+0.21 dB. Amplitude is carried linearly; the only broken control is -g,
and that is a hardcoded zero in tx_test.c rather than anything in the
firmware. Recipe, patches, persistence, and the measured limits are in
txfix/.
So: stock CaribouLite does not transmit modulated I/Q, and upstream has not
taken the fix. The band-plan, identification, occupied-bandwidth, and pacing
logic in this script is correct either way and worth keeping. For a transmit
exercise that radiates on stock software, use the HackRF; the stock board’s
usable transmit capability is a keyed unmodulated carrier via CW=1.
Listen-before-transmit, and why it is harder than it looks
--listen captures twice from two tunings 100 kHz apart at a fixed sample
rate and keeps only peaks whose absolute frequency does not move. That
rejects LO leakage (which follows the tuning) and clock-tied spurs near Fs/4
(which follow the rate).
It does not reject your own hardware. This Pi and HAT radiate a comb on every multiple of 500 kHz right across the band — fixed absolute frequencies, so they pass the retune test — and the script flags anything landing on that grid rather than calling the channel busy:
5 fixed-frequency peak(s):
445.509 MHz 34 dB above noise (on the 500 kHz grid: probably this host's own comb)
446.009 MHz 16 dB above noise (on the 500 kHz grid: probably this host's own comb)
445.526 MHz 16 dB above noise <-- near your emission
444.999 MHz 15 dB above noise (on the 500 kHz grid: probably this host's own comb)
The comb was confirmed by sampling windows 12 MHz apart: lines at 420.999, 433.005, 444.999, and 457.008 MHz, the same pattern repeating. If you cannot explain a peak, disconnect the antenna — anything that survives was not arriving through it.
Six SoapySDR traps on this plugin
Each of these cost real debugging time.
1. Each radio is a separate SoapySDR device. Not channel 0 and channel 1 of one device. Upstream: “to support for two channels, each CaribouLite detected will be identified as two boards for the SoapyAPI”. Each device exposes exactly one RX channel, at index 0.
2. Never pass a plain Python dict to SoapySDR.Device(). The SWIG binding
drops the dict’s values on that path. The plugin’s find filter then sees
{'channel': '', 'serial': '', ...}, matches nothing, and you get
SoapySDR::Device::make() no match — or IndexError: map::at, thrown by the
constructor, which does args.at("device_id"), args.at("label"), and
args.at("channel") and hits std::out_of_range. What makes this genuinely
confusing is that Device.enumerate() accepts a dict perfectly well. Two
forms work:
devs = SoapySDR.Device.enumerate(dict(driver="Cariboulite"))
sdr = SoapySDR.Device(devs[0]) # the Kwargs object
sdr = SoapySDR.Device("driver=Cariboulite,channel=HiF") # markup string
3. readStream() returning 0 is not an error. Zero means nothing was
queued within timeoutUs. Retry it. Treating it as a failure produces the
nonsense message readStream error 0 (UNKNOWN).
4. Two API surprises. There is no listChannels() — use
getNumChannels(direction). And getNativeStreamFormat() cannot be called
from Python at all: SWIG wrapped its double &fullScale out-parameter
without an output typemap, so it demands a double& no caller can construct.
The plugin’s source says CS16 is native; CS8 and CF64 show up in
getStreamFormats() only because Soapy’s converter registry adds them.
5. listSampleRates() advertises rates the board will not use. It offers
0.4, 0.5, 0.667, 0.8, 1.0, 1.333, 2, and 4 Msps, but every request below
4e6/3 is clamped up to 4e6/3:
| Requested | Reported | Measured |
|---|---|---|
| 0.4 / 0.5 / 0.8 / 1.0 Msps | 1.3333 Msps | 1.333 Msps |
| 1.3333 / 2 / 4 Msps | as asked | as asked |
getSampleRate() reports the clamp honestly, so read it back. Build an FFT
frequency axis from the rate you requested and every absolute frequency you
derive is wrong by up to 3.3x. This is also what explains the odd 1 Msps row
in the dual-radio table above: it was running at 1.333 Msps all along.
6. writeStream() does not apply back-pressure. It accepts far more than
the radio can have sent and returns success. See the transmit section above.
Enabling the hardware
Upstream’s installation.md recommends Raspberry Pi OS bullseye and warns
that its kernel module will not build on bookworm’s 6.1. On a 6.18 kernel
five separate things need fixing. setup/ does all of it:
$ ./setup/00-fetch-and-patch.sh # clone upstream, patch, test-build
$ sudo ./setup/01-enable.sh # packages, DKMS, udev, config.txt
$ sudo reboot
$ ./setup/02-build.sh # library + Soapy plugin + libiir
Set CARIBOULITE_SRC to control where upstream is checked out; it defaults
to ~/cariboulite-src/cariboulite.
What each step is working around:
The kernel module does not compile. smi_stream_dev is CaribouLite’s own
driver — it replaces the in-tree bcm2835_smi_dev to add streaming. Three
breakages on 6.18, all ordinary API churn:
| Problem | Changed in |
|---|---|
vmalloc/vfree not declared — no longer included transitively |
— |
class_create() lost its owner first argument |
6.4 |
platform_driver.remove became void-returning |
6.11 |
setup/patch_smi.py fixes all three behind LINUX_VERSION_CODE guards, so
the result still builds on older kernels. It is idempotent and asserts that
each replacement matches exactly once, so it fails loudly rather than quietly
mangling the file.
Two drivers want the same device. smi_stream_dev and the in-tree
bcm2835_smi_dev both match device-tree compatible brcm,bcm2835-smi-dev,
and only one can bind. The in-tree one is blacklisted.
The module must survive kernel upgrades. It is installed through DKMS as
smi-stream-dev/1.0; otherwise upstream expects you to re-run install.sh
by hand after every kernel update, and the symptom of forgetting is a radio
that has silently vanished. DKMS autoinstall needs the matching
linux-headers-rpi-v8 present at upgrade time.
config.txt needs two lines, dtoverlay=spi1-3cs (SPI1 with three chip
selects, for the modem, FPGA, and mixer) and dtparam=i2c_vc=on (i2c-0, where
the EEPROM lives). Notably the SMI overlay needs no entry: the HAT EEPROM
carries its own device-tree overlay that the firmware applies at boot, which
is why /dev/smi exists before you have configured anything. The original
file is saved as /boot/firmware/config.txt.pre-cariboulite.
libiir.so.1 is built but never installed. Upstream does
add_subdirectory(src/iir EXCLUDE_FROM_ALL), which compiles the library and
links the plugin against it but discards its install rules. make install
therefore succeeds and leaves libSoapyCariboulite.so with a DT_NEEDED it
cannot resolve, so SoapySDRUtil --find fails at dlopen(). Step 2 installs
it to /usr/local/lib, not /usr/lib/aarch64-linux-gnu, so it can never
collide with Debian’s libiir1 package — and uses the locally built copy
deliberately, since the plugin was compiled against the submodule’s headers
and iir1 is C++, where a version skew is an ABI question.
Two pieces of upstream advice are simply out of date. SoapySDR no longer needs building from source: the instructions say apt has only 0.7 with “API compatibility issues”, which was true on bullseye, and trixie ships 0.8.1. And the Pi 5 is still unsupported — the project says so, and the SMI peripheral it depends on is the reason.
A note on the udev rules
Upstream’s 40-cariboulite.rules contains:
SUBSYSTEM=="mem", KERNEL=="mem|kmem|port", GROUP="kmem", MODE="0666"
That makes /dev/mem world-writable, which gives any local user read/write
access to all physical memory — root, by another route, on a machine where
the whole point is that students have shell accounts. setup/01-enable.sh
does not install it. The library calls rpi_init(0), which is the
/dev/gpiomem branch; /dev/mem is only the access=1 fallback it never
takes. The rule that is installed covers /dev/smi alone:
KERNEL=="smi", SUBSYSTEM=="smi-stream-dev", GROUP="gpio", MODE="0660"
Raspberry Pi OS already ships group-based 0660 rules for gpiomem,
spidev, and i2c-dev, so membership in gpio, spi, and i2c is all a
user needs. Nothing here requires root.
Bench configuration
Measured figures on this page come from: Raspberry Pi 4 Model B Rev 1.5,
Debian 13 (trixie), kernel 6.18.50+rpt-rpi-v8, CaribouLite FULL
(product_id 0x0001, FPGA revision 1), SoapySDR 0.8.1, upstream cariboulite
at commit b98ee08 (2025-07-24), antennas on both ports.
References
- CaribouLabs, CaribouLite source and documentation — https://github.com/cariboulabs/cariboulite
- CaribouLabs, CaribouLite on Crowd Supply — https://crowdsupply.com/cariboulabs/cariboulite
- Microchip, AT86RF215 device family datasheet — https://ww1.microchip.com/downloads/en/DeviceDoc/AT86RF215-Data-Sheet-DS70005356B.pdf
- Qorvo, RFFC5071A/RFFC5072A wideband synthesiser/mixer — https://www.qorvo.com/products/p/RFFC5072A
- Pothosware, SoapySDR wiki — https://github.com/pothosware/SoapySDR/wiki
- rtl-sdr.com, CaribouLite: a 30–6000 MHz 13-bit SDR HAT — https://www.rtl-sdr.com/cariboulite-a-30-6000-mhz-13-bit-4mhz-sdr-hat-for-the-raspberry-pi/
- Raspberry Pi, Device Trees, overlays and parameters — https://www.raspberrypi.com/documentation/computers/configuration.html#device-trees-overlays-and-parameters
- Linux kernel commit 1aaba11da9aa,
class_create()drops its owner argument — https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=1aaba11da9aa - ARRL, US band plan (70 cm, 420–450 MHz) — https://arrl.org/band-plan
- 47 CFR 97.119, station identification — https://www.law.cornell.edu/cfr/text/47/97.119
- 47 CFR 97.303, frequency sharing requirements (Line A) — https://www.law.cornell.edu/cfr/text/47/97.303
- Course notes on SDR and radio protocols — radio.md
- The companion link-layer tool — rflink