Cursusoverzicht 🎓

1. Radio basics — golven, spectrum, modulatie, dB ⏱ 25 min beginner
2. Wat is SDR? — architectuur, IQ, Nyquist ⏱ 25 min beginnergevorderd
3. Hardware — RTL-SDR, HackRF, antennes ⏱ 20 min
4. Software & tools — FFT, waterfall, GNU Radio ⏱ 30 min
5. Signalen decoderen — ADS-B, POCSAG, satellieten ⏱ 40 min
6. Data-analyse — van IQ tot inzicht ⏱ 30 min gevorderd
7. Wetgeving — wat mag (niet) in NL ⏱ 15 min
8. Demo's & eindopdracht ⏱ 25 min

🔬 Elke les sluit af met een lab-opdracht · ✋-slides zijn zelftoetsen · lesnummers hierboven zijn klikbaar

Wat kun je na deze cursus? 🎯

• 🧠 Begrijpen hoe radio werkt: golven, modulatie, spectrum, decibel
• 👀 Herkennen van signalen in een waterfall — en op het gehoor
• 🛠️ Zelf ontvangen: van €35-dongle naar vliegtuigen, satellieten en sensoren
• 📊 Analyseren van radiodata met Python en dashboards
• ⚖️ Weten wat mag — en waar de grens ligt

Beginner? Focus op de groene onderwerpen. Gevorderd? De rode geven verdieping. Elke les eindigt met een 🔬 lab en onderweg zijn er ✋ zelftoetsen.

Elektromagnetische golven

• Radio = elektromagnetische straling, net als licht — alleen een veel lagere frequentie
• Een golf heeft drie eigenschappen die je kunt variëren:
  • Amplitude — hoe sterk
  • Frequentie — hoe snel hij trilt (Hz)
  • Fase — waar in de cyclus hij zit
• Golflengte λ = c / f  →  100 MHz ≈ 3 meter

Radio ≈ geluid, maar dan sneller 🔊→📡

Vrijwel alles wat je intuïtief van geluid weet, vertaalt 1-op-1 naar radio:

Het radiospectrum

💡 Lagere frequentie = verder bereik & buigt om obstakels; hogere frequentie = meer bandbreedte, maar zichtlijn nodig.

Modulatie: informatie op een golf zetten

• AM — amplitude varieert (omroep, luchtvaart)
• FM — frequentie varieert (omroep, marifoon, PMR)
• Digitaal — FSK/PSK/QAM: bits als frequentie-, fase- of amplitudesprongen

Decibel: de taal van radio

• Signaalsterktes variëren enorm → logaritmische schaal
• +3 dB = ×2 vermogen, +10 dB = ×10 vermogen
• dBm = dB t.o.v. 1 milliwatt
  • WiFi-router: ~+20 dBm (100 mW)
  • Ontvangen GPS-signaal: ~−130 dBm (0.0000000000001 mW!)
• SNR (signaal-ruisverhouding): hoe ver je signaal boven de ruisvloer uitsteekt — dát bepaalt of je kunt decoderen

🎛️ Speel: signaal vs. ruis

Schuif de signaalsterkte omlaag en zie wanneer decoderen onmogelijk wordt. Elke modulatie heeft een eigen minimum-SNR — daarom hoor je FM nog prima waar digitale TV al lang is weggevallen.

✋ Even checken #1

De NOAA-weersatelliet zendt op 137 MHz. Hoe lang is één golf — en hoe groot wordt je antenne?

• λ = c / f = 300 / 137 ≈ 2,2 meter
• Een λ/4-antennepoot is dus ≈ 55 cm — daarom is zo'n V-dipool best groot
• En ADS-B op 1090 MHz? λ ≈ 27 cm → antennetje van ~7 cm. Hogere frequentie = kleinere antenne

🔬 Lab 1 — Luisteren zonder hardware

1. Tune naar 198 kHz (AM): BBC Radio 4 op de lange golf
2. Zoek tussen 3.6–3.8 MHz een Nederlands amateurgesprek — zet de modus op LSB
3. Vind rond 14.0–14.1 MHz een morse-signaal (modus CW)
4. Kijk per signaal naar de waterfall: hoe fel = hoeveel SNR?

✅ Klaar als je drie modulaties hebt gehoord: AM, SSB en CW — en het verschil kunt beschrijven.

Bonus: tune naar 4625 kHz… hoor jij The Buzzer? 👻

Klassieke radio

Elke functie = een eigen stuk hardware:

• Nieuw protocol of andere band? → nieuwe hardware, soldeerbout erbij
• Eén apparaat = één functie

…en nu als SDR

Digitaliseer zo vroeg mogelijk — de rest wordt software:

Eén apparaat → duizend radio's. Nieuw protocol? Update de software, niet de soldeerbout.

Waarom is SDR zo'n gamechanger?

SDR democratiseerde radio-onderzoek: hobbyisten doen nu dingen die vroeger alleen labs konden.

IQ-sampling gevorderd

• De SDR mengt het antennesignaal naar laag-frequent en bemonstert twee kanalen: I (in-phase) en Q (quadrature, 90° verschoven)
• Samen vormen ze een complex getal I + jQ per sample
• Hiermee ken je amplitude én fase → élke modulatie is in software te demoduleren
• Negatieve frequenties worden onderscheidbaar → bandbreedte = samplerate

Digitale modulatie in het echt

Plot de IQ-samples op symboolmomenten → constellatiediagram. Elke "wolk" = één symbool; hoe meer punten, hoe meer bits per symbool (en hoe gevoeliger voor ruis):

• WiFi/5G gebruiken adaptief t/m 1024-QAM — alleen bij hoge SNR
• In GQRX/SDR++ of GNU Radio zie je deze plots live van echte signalen

🎛️ Draai aan de ruis

QPSK live: elk puntje is een ontvangen symbool. Wordt een punt rood, dan belandde hij in het verkeerde kwadrant = bitfout. Dít is waarom je modem terugschakelt bij slecht signaal.

Nyquist & samplerate gevorderd

• Nyquist: om een signaal te reconstrueren moet je ≥ 2× de hoogste frequentie samplen
• Met complexe IQ-samples: bandbreedte = samplerate
  • RTL-SDR @ 2.4 MS/s → 2.4 MHz spectrum in beeld
  • HackRF @ 20 MS/s → 20 MHz spectrum
• Te weinig samplerate → aliasing: signalen "vouwen" terug en verschijnen op de verkeerde plek
• Praktijk: 8-bit samples @ 2.4 MS/s = ~4.8 MB/s aan data. IQ-opnames worden snel groot!

🎛️ Zie aliasing gebeuren

Blauw = het echte signaal (10 cycli) · stippen = jouw samples · oranje = wat jouw SDR ervan reconstrueert. Zak onder 2× de signaalfrequentie en er verschijnt een spook-signaal op de verkeerde frequentie.

✋ Even checken #2

Je RTL-SDR staat afgestemd op 100 MHz met samplerate 2.4 MS/s.

• Welk stuk spectrum zie je in je waterfall? 98.8 – 101.2 MHz (bandbreedte = samplerate)
• Er zendt iets op 101.5 MHz. Zie je dat? Nee — valt buiten de band. Hertunen dus!
• Een uur IQ opnemen kost ~17 GB (4.8 MB/s × 3600 s) — daarom neem je kort en gericht op

🔬 Lab 2 — Voorspel het spook

1. Zet de samplerate-slider op 18 — voorspel éérst op papier de spookfrequentie (f − fs), check daarna
2. Herhaal voor 16 en 24 samples. Wanneer klopt je formule, wanneer "vouwt" hij?
3. Python-bonus: sample een 440 Hz-toon op 600 Hz en luister:

   import numpy as np, sounddevice as sd
   t = np.arange(0, 2, 1/600)                 # fs = 600 Hz
   sd.play(np.sin(2*np.pi*440*t), 600)        # hoor je 160 Hz?

✅ Klaar als je de spookfrequentie 2× goed voorspelt vóór je de slider beweegt.

RTL-SDR: de €35 wonderdongle

• Ooit: DVB-T tv-stick. Hack (2012): chip levert ruwe IQ-samples!
• RTL-SDR Blog V3/V4: de facto standaard
• Bereik: 500 kHz – 1.7 GHz
• Samplerate: tot 2.4 MS/s stabiel, 8-bit
• Alleen ontvangen (RX)
• V3+: TCXO (stabiele klok), bias-tee, direct sampling voor HF

Foto: Joeceads, CC BY-SA 4.0, Wikimedia Commons

Wat kun je ermee?

• FM/DAB+ · ADS-B vliegtuigen · weersatellieten
• Pagers, sensors, meteoballonnen, marifoon
• ISS en amateursatellieten

Koop bij voorkeur een origineel (rtl-sdr.com) — kloons hebben vaak drift en opwarmproblemen.

HackRF One: ook zenden gevorderd

• Bereik: 1 MHz – 6 GHz
• Tot 20 MS/s, 8-bit
• Half-duplex TX én RX (~€300)
• Open hardware (Great Scott Gadgets)
• Portapack-addon: standalone gebruik

Foto: Gareth Halfacree, CC BY 2.0, Wikimedia Commons

Alternatieven

• Airspy 12-bit · SDRplay 14-bit · PlutoSDR full-duplex · USRP pro

Antennes: de helft van je succes

• Een slechte antenne met dure SDR < goede antenne met goedkope SDR
• Vuistregel: antenne resoneert bij λ/4 of λ/2 van je doelfrequentie

Type	Goed voor	Opmerking
Telescoop-dipool	Alles (breedband)	Zit bij RTL-SDR kit
Discone	Scannen 25 MHz–1.3 GHz	Breedband, geen gain
Colineair / GP	ADS-B 1090 MHz	Veel gain op één band
V-dipool / QFH	Weersat. 137 MHz	Omhoog gericht, circulair (QFH)
Longwire / mini-whip	HF kortegolf	Lang draad buiten

Tips: buiten > binnen, hoog > laag, korte goede coax > lange slechte. LNA dicht bij de antenne helpt bij satellieten.

QFH-antenne voor 137 MHz weersatellieten — Karsten Lehmann, CC BY-SA 4.0

🔬 Lab 3 — Dongle aan de praat

1. Installeer SDR++ · Windows: USB-driver via Zadig · Linux: sudo apt install rtl-sdr
2. Test: rtl_test -t — geen "lost samples"? Dan ben je goed
3. Tune naar je sterkste lokale FM-zender — geluid? 🎉
4. Antenne-experiment: vergelijk de signaalsterkte midden in de kamer vs. bij het raam — hoeveel dB scheelt het?

✅ Klaar als FM speelt én je het raam-effect in dB kunt benoemen (meestal 6–15 dB!).

Geen dongle? Doe het lab met een WebSDR en sla stap 1–2 over.

Eerst even: wat doet een FFT?

• De SDR levert alleen samples in de tijd — een eindeloze rij getallen
• De FFT (Fast Fourier Transform) werkt als een prisma: hij splitst het signaal in de frequenties waaruit het bestaat
• 1 FFT = 1 momentopname van het spectrum = 1 regel van de waterfall
• Duizenden FFT's onder elkaar plakken = de waterfall die je zo ziet

Je eerste waterfall 🌊

• SDR++ / SDRSharp / GQRX: dé startpunten — tunen, luisteren, kijken
• X-as = frequentie, Y-as = tijd, kleur = signaalsterkte (dB)
• Je ziet signalen voordat je ze hoort: elke modulatie heeft een eigen "vingerafdruk"

▲ live gesimuleerde waterfall: smalle FM-draaggolf · breedband FM · pager-bursts · frequency hopper

Een echte 2.4 MHz opname

Gegenereerd uit IQ-samples met NumPy — exact dezelfde FFT-pipeline als SDR++ gebruikt.

Hoe klinkt het spectrum? 🎧

Elke modulatie heeft ook een eigen geluid — na een tijdje herken je ze op het gehoor (allemaal hier gesynthetiseerd met NumPy):

Meer echte voorbeelden: sigidwiki.com heeft opnames van honderden signaalsoorten.

🎛️ Draai zelf aan de knop

Sleep de schuif over de band: vind de morse-baken, de FM-muziekzender en de pager. Net naast de zender? Dan hoor je hem vervormd door de ruis — precies zoals in het echt.

Het tool-landschap

GNU Radio: DSP als blokkendoos

• Open-source framework: bouw je radio als flowgraph van blokken
• GNU Radio Companion (GRC): visuele editor → genereert Python
• Elk blok bewerkt een stroom samples: filter, mixer, demodulator, decoder…

GNU Radio in de praktijk gevorderd

• GRC genereert Python — je kunt alles ook scripten:

from gnuradio import gr, blocks, analog, filter, audio
import osmosdr

class FMRadio(gr.top_block):
    def __init__(self, freq=100.7e6):
        gr.top_block.__init__(self)
        src = osmosdr.source()                     # RTL-SDR bron
        src.set_sample_rate(2.4e6)
        src.set_center_freq(freq)
        lpf = filter.fir_filter_ccf(10,            # decimatie 2.4M -> 240k
              filter.firdes.low_pass(1, 2.4e6, 100e3, 10e3))
        demod = analog.wfm_rcv(quad_rate=240e3, audio_decimation=5)
        snd = audio.sink(48000)
        self.connect(src, lpf, demod, snd)

FMRadio().run()

• Eigen blokken schrijven in Python of C++ (performance)
• Ook zonder hardware: File Source met opgenomen IQ-data

🔬 Lab 4 — Waterfall-safari + flowgraph

1. Scan met SDR++ de band 430–440 MHz en screenshot 3 verschillende signaalvormen in de waterfall
2. Zoek ze op bij sigidwiki.com — wat denk je dat het zijn?
3. Bouw in GNU Radio Companion de 5-bloks FM-ontvanger van deze les na en laat hem spélen

✅ Klaar als je flowgraph geluid geeft én je 2 van de 3 signalen hebt geïdentificeerd.

Vast? De flowgraph staat als Python-voorbeeld in de cursus-repo (zie slotslide).

ADS-B: vliegtuigen volgen ✈️

# decoder starten + webkaart
dump1090 --interactive
# of modern:
readsb --device-type rtlsdr \
       --net --write-json /run/readsb

Zo ziet jouw ontvangst eruit 🛩️

Links: vliegtuigen die jouw antenne hoort (ring = 100/200 km). Rechts: de ruwe Mode-S berichten zoals dump1090 ze decodeert — elk vliegtuig zendt er ~2 per seconde.

POCSAG: pagers leven nog 📟

• Pager-protocol uit 1982, nog volop in gebruik (ziekenhuizen, brandweer)
• In NL: P2000 op 169.65 MHz — alarmeringen van hulpdiensten (FLEX-protocol)
• FSK, 512/1200/2400 baud — triviaal te decoderen:

# POCSAG decoderen met rtl_fm + multimon-ng
rtl_fm -f 169.65M -s 22050 | \
  multimon-ng -t raw -a POCSAG512 -a POCSAG1200 -a FLEX -

Weersatellieten: beelden uit de ruimte 🛰️

🚀 Gevorderd: GOES/EUMETSAT geostationair met schotel + LNA, ISS SSTV-events, amateursatellieten (FM-repeaters in de ruimte).

Hoe werkt zo'n pass? 🛰️

De satelliet vliegt in ~100 minuten rond de aarde; jij hoort hem alleen als hij boven jouw horizon komt (groene boog). De elevatiecurve rechts bepaalt je plan: hoe hoger de piek, hoe beter het beeld.

Echt ontvangen: NOAA 19 🛰️

NOAA 19, 18 juni 2021, APT op 137.100 MHz — public domain (NOAA), via Wikimedia Commons

• Links: zichtbaar licht, rechts: infrarood
• De verticale streeppatronen = sync-pulsen, zo lijnt de decoder elke beeldlijn uit
• Dit ontvang je al met een RTL-SDR + zelfgebouwde V-dipool van ~€5 aan draad

🎧 Zo klinkt APT tijdens een pass:

rtl_433: het IoT om je heen

• 433/868 MHz ISM-band: weerstations, deurbellen, TPMS (bandenspanning), afstandsbedieningen, energiemeters…
• rtl_433 kent 250+ apparaatprotocollen out of the box:

rtl_433 -f 433.92M -F json | jq .
{
  "time": "2025-11-06 19:04:12",
  "model": "Nexus-TH",
  "id": 42,
  "temperature_C": 18.4,
  "humidity": 61
}

• Output naar JSON/MQTT → direct in Home Assistant of eigen database
• Leuke oefening: welke apparaten in jouw huis zenden stiekem van alles uit?

Onbekend signaal? Reverse engineering gevorderd

1. Vind het signaal in de waterfall; noteer frequentie en bandbreedte
2. Neem op als IQ-bestand (SDR++ record / rtl_sdr)
3. Inspecteer in inspectrum/URH: modulatie? symboolrate? preamble?
4. Demoduleer naar bits (URH doet FSK/ASK/PSK semi-automatisch)
5. Analyseer bitpatronen: sync-words, lengtes, counters, checksums (CRC-reveng!)
6. Decodeer: schrijf een parser, of check of rtl_433 het al kent

💡 Veel 433 MHz-apparaten gebruiken simpele OOK + vaste codes — daarom zijn replay-attacks op oude autosleutels mogelijk (en daarom hebben moderne rolling codes).

✋ Even checken #3 — jij bent de detective

In je waterfall op 433.92 MHz zie je elke ~30 seconden een korte, smalle burst. Wat is het — en hoe kom je erachter?

• Korte periodieke bursts in de ISM-band → vrijwel zeker een sensor (weerstation, deurbel, TPMS…)
• Stap 1: rtl_433 -f 433.92M — grote kans dat één van de 250 decoders hem al kent
• Stap 2 (niets?): IQ opnemen → URH/inspectrum → het reverse-engineering-stappenplan van net

🔬 Lab 5 — Kies je missie

• ✈️ Missie A — vliegtuigen: dump1090 --interactive → hoeveel vliegtuigen zie je, en wat is je verste ontvangst (km)?
• 🌡️ Missie B — sensoren: rtl_433 → identificeer 3 apparaten in je omgeving (van wie is dat weerstation?)
• 📟 Missie C — pagers: rtl_fm -f 169.65M -s 22050 | multimon-ng -t raw -a FLEX - → tel de alarmeringen in 10 minuten (alleen kijken, niet delen!)

✅ Klaar als jouw missie echte, gedecodeerde data oplevert.

Bonus: plan op n2yo.com een NOAA-pass van ≥ 60° elevatie voor morgen — en zet je wekker. 🛰️

De SDR data-pipeline

• SigMF: standaard om IQ-opnames + metadata (freq, rate, tijd) te delen
• Scheiding opname ↔ analyse: je kunt een signaal eindeloos opnieuw bekijken

IQ-data in Python gevorderd

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

fs = 2.4e6                      # samplerate
raw = np.fromfile("opname.cs8", dtype=np.int8)       # RTL-SDR: 8-bit
iq  = (raw[0::2] + 1j*raw[1::2]) / 127.5 - (1+1j)    # -> complex

# Spectrogram (waterfall)
f, t, Sxx = signal.spectrogram(iq, fs=fs, nperseg=4096,
                               return_onesided=False)
plt.pcolormesh(np.fft.fftshift(f), t,
               10*np.log10(np.fft.fftshift(Sxx, axes=1)).T)
plt.xlabel("Frequentie-offset (Hz)"); plt.ylabel("Tijd (s)")

# FM-demodulatie in 1 regel: fase-verschil tussen samples
audio = np.angle(iq[1:] * np.conj(iq[:-1]))

NumPy + SciPy = je eigen SDR-lab. Aanrader: PySDR (pysdr.org), gratis online boek.

Van IQ naar audio — in beeld

Die ene regel np.angle(iq[1:] * conj(iq[:-1])) doet dit:

Berichten-data analyseren

• Decoders leveren gestructureerde data (JSON) → klassieke data-analyse:

import pandas as pd

df = pd.read_json("adsb_log.jsonl", lines=True)

df["hour"] = df.time.dt.hour
df.groupby("hour").flight.nunique().plot(kind="bar")   # drukte per uur

# verste ontvangst per richting -> antennediagram van je eigen setup
df.groupby(df.bearing.round(-1)).distance_km.max().plot(kind="polar")

…en dit komt eruit 📊

Je antennebereik-plot verraadt precies welk gebouw in de weg staat — en de buurt-sensoren loggen 24/7 gratis mee.

Dashboards & langetermijn-monitoring

• Raspberry Pi + RTL-SDR = 24/7 ontvangststation (< 5 W)
• Pipeline: rtl_433 → MQTT → InfluxDB → Grafana
• ADS-B: readsb → tar1090 (live kaart) + graphs1090 (statistieken)
• Meedoen met gedistribueerde netwerken:
  • ADSBexchange / FR24 / airplanes.live (vliegtuigen)
  • SatNOGS — open netwerk van satellietgrondstations
  • WebSDR / KiwiSDR — jouw ontvanger online delen

Van hobby naar citizen science: jouw antenne wordt onderdeel van een wereldwijd meetnetwerk.

Breedband discone + weerstation op het dak — mr_t_77, CC BY-SA 2.0, Wikimedia Commons

Machine learning op RF gevorderd

• Automatische modulatieherkenning: CNN's op IQ-data of spectrogrammen (RadioML-datasets)
• RF fingerprinting: zenders herkennen aan minieme hardware-imperfecties
• Anomaliedetectie: afwijkende signalen in het spectrum spotten (spectrum monitoring)
• Spectrogram = plaatje → alle computer vision-technieken zijn toepasbaar
• Tooling: GNU Radio + PyTorch, torchsig, DeepSig datasets

Onderzoeksveld in opkomst — laagdrempelig om zelf mee te experimenteren omdat je je eigen trainingsdata kunt opnemen.

🔬 Lab 6 — Van JSON naar inzicht

import pandas as pd
df = pd.read_json("assets/sample_rtl433.jsonl", lines=True)

# 1. hoeveel berichten per sensor?
print(df.model.value_counts())

# 2. temperatuurverloop per sensor
df.pivot_table(index="time", columns="model",
               values="temperature_C").plot()

# 3. jouw beurt: wanneer was de koudste 5-minuten? welke sensor
#    hangt binnen? en wie heeft een zwakke batterij?

✅ Klaar als je plot 3 lijnen toont en je vraag 3 kunt beantwoorden met code.

Ontvangen: wat mag?

• Luisteren is in principe vrij — een ontvanger hebben en gebruiken mag
• MAAR (Telecommunicatiewet + Wetboek van Strafrecht):
  • Niet-openbare communicatie die je opvangt mag je niet delen of misbruiken
  • Afluisteren van bijv. telefonie is strafbaar
• Praktisch: omroep, luchtvaart, amateurs, satellieten, ISM-sensoren, ADS-B → prima
• P2000/pagers: ontvangen gedoogd, inhoud met persoonsgegevens publiceren → risico (AVG)

Zenden: alleen met vergunning of in vrije banden

• Zenden zonder toestemming is verboden — handhaving door RDI (Rijksinspectie Digitale Infrastructuur), boetes kunnen fors zijn
• Ook "even testen" met een HackRF op FM of GPS-frequenties: illegaal én gevaarlijk (interferentie met luchtvaart/hulpdiensten!)
• Legaal zenden kan via:
  • Vergunningsvrije banden (ISM: 433/868 MHz, WiFi) — binnen vermogens- en duty-cycle-limieten, met conforme apparatuur
  • Amateurradio-licentie (N of F): examen bij RDI → roepnaam → experimenteren op amateurbanden is juist de bedoeling

Ethiek: with great power…

• SDR geeft je toegang tot veel — gebruik het verantwoord:
• ✅ Doen: eigen apparaten onderzoeken, open signalen decoderen, leren, publiceren over techniek
• ❌ Niet doen: jammen, replay-attacks op andermans spullen, persoonsgegevens verspreiden, GPS spoofen
• Responsible disclosure: zwakke plek in een product gevonden? Meld bij fabrikant / NCSC

🔬 Lab 7 — Mag dit? (casussen)

• 1️⃣ Je leest met rtl_433 het weerstation van de buren uit. Mag — vrij ontvangbaar, geen persoonsgegevens. Netjes: vertel het ze, leuk gesprek!
• 2️⃣ Je zet P2000-meldingen mét adressen op social media. Mag niet — persoonsgegevens verspreiden (AVG + Tw).
• 3️⃣ Je test je HackRF "heel even" op 433.92 MHz met 1 mW. Mag niet — ISM vereist conforme apparatuur; gebruik een dummy load of kabel.
• 4️⃣ Met je N-licentie roep je CQ op 145.500 MHz. Mag — daar is de licentie voor. Vergeet je roepnaam niet!

✅ Klaar als je bij elke casus het wetsartikel-gevoel kunt uitleggen: ontvangen vrij · delen beperkt · zenden gereguleerd.

Demoplan

1. Waterfall-safari — SDR++ open, spectrum verkennen: FM, DAB+, 433 MHz (5 min)
2. Vliegtuigen live — dump1090/tar1090-kaart met vliegtuigen boven ons (5 min)
3. Sensoren sniffen — rtl_433 live: wat zendt er hier in de zaal? (5 min)
4. P2000 meekijken — multimon-ng/PDW alarmeringen (3 min)
5. GNU Radio — FM-ontvanger live bouwen in GRC (7 min)

Backup-plan: IQ-opnames van thuis meenemen — demo's werken dan ook zonder ontvangst in de zaal (File Source in plaats van RTL-SDR Source).

🏁 Eindopdracht — jouw eigen station

1. Kies je doel — ADS-B, weersatelliet, buurt-sensoren of iets geks (radiosondes!)
2. Bouw/plaats je antenne — en documenteer je keuze met de λ/4-regel
3. Log minimaal 48 uur — JSON/SQLite, zoals in les 6
4. Maak één grafiek + één verhaal — wat verraste je?
5. Presenteer — 5 minuten, inclusief wat er mis ging (dat is het leerzaamst)

🏆 Beoordeel jezelf: werkt het 48 uur stabiel? Kun je elke ontwerpkeuze uitleggen? Dan ben je officieel SDR-hobbyist.

🪜 Jouw leerpad: 5 experimenten

1. Dag 1 — FM-radio ontvangen in SDR++ (direct succes, leert tunen + waterfall lezen)
2. Week 1 — vliegtuigen volgen met dump1090 (leert antennes + CLI-tools)
3. Week 2 — rtl_433: sensoren in je straat ontdekken (leert ISM-band + JSON-data)
4. Maand 1 — eigen weersatellietfoto: V-dipool + SatDump (leert passes plannen + antennebouw)
5. Maand 2+ — GNU Radio flowgraph + IQ-analyse in Python (…en misschien je N-licentie?)

Beginnen? Boodschappenlijst 🛒

Leren

• pysdr.org — gratis boek: SDR + DSP met Python
• rtl-sdr.com — blog met eindeloos veel projecten
• sigidwiki.com — "wat is dit voor signaal?" encyclopedie
• greatscottgadgets.com/sdr — gratis videocursus (Michael Ossmann)
• r/RTLSDR, VERON/VRZA-afdelingen, hackerspaces

📋 Spiekbrief — maak een foto! 📸