# Radiosondes At the end you have a page on your home network that shows each weather balloon your station hears. It updates the height, position and readings once a second. Sharing with the SondeHub map is one optional step. Spurious Emissions · Rev A · checked 2026-10-26 · https://spurious-emissions.net/guides/receive-radiosondes/ Some links are affiliate links: if you buy through them, I may earn a commission at no extra cost to you. As an Amazon Associate I earn from qualifying purchases. ## 1. What this guide builds A receiver for the small radios that weather balloons carry, called radiosondes (sondes in this guide). One antenna feeds one USB radio. A small computer finds each sonde, decodes it, and shows it on a page in your browser. Twice a day, weather services launch balloons from hundreds of sites. Each sonde sends its pressure, temperature, humidity and GPS position once a second, near 400 to 406 MHz. The free program radiosonde_auto_rx (auto_rx in this guide) scans the band, finds a sonde, decodes it and keeps a log of each flight. | Signal | Frequency | Antenna | Radio | Decoder | Computer | |---|---|---|---|---|---| | Radiosonde telemetry, for example the Vaisala RS41 | 400 to 406 MHz | Discone, after two splitters | Nooelec NESDR SMArt v5 | radiosonde_auto_rx | `pi` | The computer has the name `pi` in this guide. On my station it also runs my ship and aircraft-message receivers. ``` roof cable entry computer "pi" (Docker) ---- ----------- ---------------------- discone -- coax -- FM filter -- splitter 1 |-- leg A -- (ACARS radio) `-- leg B -- splitter 2 |-- output 1 -- NESDR SMArt v5 -- radiosonde_auto_rx --+-- web page `-- output 2 -- (VDL2 radio) | (http://pi:5000/) `-- SondeHub (optional) Lowest cost: quarter-wave antenna, outdoors -- coax -- RTL radio -- radiosonde_auto_rx ``` You can start with less. One RTL radio and an outdoor antenna made of wire do this job alone. Section 2 lists that path and says what it gives up. ## 2. What you need Prices are US dollars, as listed by the named seller on 2026-10-07. They change. "See listing" means the price is on the linked page. A part marked ◆ is what I use. "An example" or "a similar one" is a link to a part like mine, not the one I have. A blank box is for your pencil. Two terms first. An SDR (software-defined radio) is a radio that sends raw samples to a computer, and a program does the rest. An RTL radio is a low-cost SDR in the shape of a USB stick, built on the RTL2832U chip. Some people call it a dongle. ### Antenna and radio-frequency parts | ☐ | Part | Job | Connector | Price | |---|---|---|---|---| | ☐ | ◆ [Diamond D-130J discone](https://www.amazon.com/dp/B00AR09A6I?tag=spuriousemiss-20), 25 to 1300 MHz receive, 1.7 m | One wide antenna for several radios | SO-239 (the D-130NJ has N type) | See listing, Amazon | | ☐ | ◆ [RTL-SDR Blog FM band-stop filter](https://www.amazon.com/dp/B01LE9LRPM?tag=spuriousemiss-20), 88 to 108 MHz, over 50 dB | First part after the discone cable | SMA | See listing, Amazon | | ☐ | ◆ [Mini-Circuits ZX10-2-12-S+](https://www.minicircuits.com/WebStore/dashboard.html?model=ZX10-2-12-S%2B) 2-way splitter, 2 to 1200 MHz, 2 of them | Feeds three radios from one antenna | SMA | $42.20 each, Mini-Circuits | | ☐ | ◆ 50 ohm coax with a PL-259 plug ([an example](https://www.amazon.com/dp/B08F762YN1?tag=spuriousemiss-20)), and an SMA plug or adapter at the radio end ([an example](https://www.amazon.com/dp/B00CVQOOAI?tag=spuriousemiss-20)) | Discone to cable entry | PL-259 to SMA | See seller | | ☐ | ◆ Short SMA plug-to-plug jumpers ([a similar one](https://www.amazon.com/dp/B0BFPWJ3J9?tag=spuriousemiss-20)) | Filter to splitters to radio | SMA | See seller | | ☐ | Grounding block ([an example](https://www.amazon.com/dp/B06XDX5PNN?tag=spuriousemiss-20)) and bonding wire | Section 4, "Ground the cable" | To suit the coax | See seller | If this is your only radio on the discone, you need no splitter. Do not buy an amplifier at the start. Section 4 says why. ### Radio | ☐ | Part | Job | Price | Note | |---|---|---|---|---| | ☐ | ◆ [Nooelec NESDR SMArt v5](https://www.amazon.com/dp/B01HA642SW?tag=spuriousemiss-20) (R820T2 tuner, female SMA) | Radiosondes | See listing | It has a temperature-stable clock (TCXO). The maker sells it without an antenna | The auto_rx documents say a radio with a TCXO is mandatory. A TCXO (temperature-compensated crystal oscillator) keeps the radio on frequency as it warms up. The decoders are sensitive to a frequency error. The documents name the RTL-SDR Blog radios and the Nooelec SMArt as good choices. ### Computer | ☐ | Part | Job | Price | Note | |---|---|---|---|---| | ☐ | ◆ [Raspberry Pi 5](https://www.amazon.com/dp/B0CK2FCG1K?tag=spuriousemiss-20), 8 GB | `pi` | $175 list (4 GB: $110) | The auto_rx documents ask for a Raspberry Pi 3 or newer[^pi-load] | | ☐ | [Raspberry Pi 27 W USB-C power supply](https://www.amazon.com/dp/B0D3MFLNC1?tag=spuriousemiss-20) | Power for `pi` | See seller | With a weaker supply the Pi limits its USB sockets to 600 mA in total | | ☐ | microSD card, 32 GB or more ([an example](https://www.amazon.com/dp/B07FCMBLV6?tag=spuriousemiss-20)) | Storage for `pi` | See seller | | | ☐ | ◆ Powered USB hub with its own power supply (mine: [Rosonway RSH-A10](https://www.amazon.com/dp/B081DYD25S?tag=spuriousemiss-20)) | The radios | See seller | Optional for one radio. The auto_rx documents warn that several RTL radios on the Pi's own sockets can make the USB bus unstable | Any other Linux computer that runs Docker also works. ### The lowest-cost path | ☐ | Part | Job | Price | |---|---|---|---| | ☐ | One RTL radio with a TCXO (the NESDR SMArt v5 above) | Radiosondes | See listing | | ☐ | A quarter-wave ground plane (section 4), a 70 cm amateur antenna that you own, or a small whip from a radio kit, outdoors | Antenna for 400 to 406 MHz | Wire and one coax socket | | ☐ | Coax to suit the antenna, SMA at the radio end | Antenna to radio | See seller | | ☐ | A small Linux computer that you own, or the Raspberry Pi above | `pi` | See above | What this path gives up: - **Other bands.** A quarter-wave antenna works near one frequency. A discone works from 25 to 1300 MHz, so one antenna serves several radios. - **Not much else, if the antenna is outdoors.** My two splitters cost my sonde radio about 7 dB. A direct antenna does not have that loss. - **Everything, if the antenna is indoors.** My small indoor whip heard nothing during a full flight (section 14). Put the antenna outside. ## 3. Before you start **Skills.** You connect coax and adapters. You type commands on a Linux computer over SSH. You edit a text file. This guide gives every command. **Time.** I did not time the build. After the build you wait for a launch. Section 8 says when. **Accounts.** None. SondeHub needs no account. Sharing in section 9 uses a station name that you choose. **Values to choose first.** Write these down. The steps use them as placeholders. | Placeholder | Meaning | Example form | |---|---|---| | `` `` | Antenna position, decimal degrees. A position near your general area is enough | `xx.xxx` | | `` | Antenna height above sea level, meters | `45` | | `` | The serial number that you write to the RTL radio | `SDR00404` | | `` | The frequency of the sondes from your nearest launch site, MHz (section 8) | `40x.x` | | `` | Your callsign, or a station name with no personal detail. It is public if you share (section 9) | `my-station` | | `` | A short description of your antenna, in free text | `discone` | **The law.** I am not a lawyer. This is what I read, for the United States. Other countries differ. This station only receives. It never transmits. A radiosonde sends weather data, and the National Weather Service publishes the soundings. SondeHub publishes what its receivers upload under a Creative Commons license (CC BY-SA 2.0). auto_rx does not decode an encrypted sonde, and this guide does not try. ## 4. The antenna and the radio-frequency chain Build the chain in this order, antenna first. ``` discone -- coax -- FM band-stop filter -- splitter 1 -- leg B -- splitter 2 -- output 1 -- RTL radio Discone, this radio only: discone -- coax -- FM band-stop filter -- RTL radio One narrow antenna: quarter-wave antenna -- coax -- RTL radio ``` ### Put the antenna outside > **Warning.** An antenna or a mast that touches a power line can kill you. Keep the antenna, the mast and the cable away from every power line. 1. Mount the antenna outside, as high as you safely can. 2. Give it a clear view of the sky, most of all toward your nearest launch site. 3. Keep the coax short and of good quality. This matters more than any part on the list. A sonde climbs to more than 30 km, so it is in view from far away. A sonde low on the horizon is still weak, and a roof, a hill or a tree can block it. ### A wide antenna: the discone A discone is a wide-band antenna made of a disc of rods above a cone of rods. It has little or no gain, but it receives a very wide range of frequencies. Mine is sold as covering 25 to 1300 MHz. The same antenna feeds my aircraft-message radios ([ACARS and VDL2](/guides/receive-acars-vdl2/)). The cost of a wide antenna is that it receives everything. FM broadcast stations at 88 to 108 MHz arrive at full strength. So the FM filter is not optional on a discone. ### A cheaper antenna: a quarter-wave ground plane A quarter-wave ground plane is one vertical rod above four rods that slope down. The auto_rx documents say a basic quarter-wave antenna is usually good enough. They also say a 70 cm amateur-band antenna will probably work. 1. Calculate the rod length: 71.25 divided by the frequency in MHz gives meters. For 403 MHz, the result is 0.177 m (17.7 cm). 2. Cut five rods or stiff wires of that length. 3. Solder one rod to the center pin of a coax socket. This rod points up. 4. Attach four rods to the body of the socket. Bend them down about 45 degrees. 5. Mount the antenna outside with the long rod vertical. I did not build this antenna. It is the standard design, and 403 MHz is near the middle of the band. ### Ground the cable An outdoor antenna cable needs a path to ground where it enters the building. In the US the rule is National Electrical Code Article 810. Bond the grounding block to the building's own grounding electrode system. If you add a ground rod, bond it to that system with 6 AWG copper or heavier. Never use a rod that stands alone: a surge then goes through your equipment. I read a published summary of the rule, not the code text.[^nec] Use a licensed electrician if you are not sure. ### The FM broadcast filter 1. Connect the coax from the discone to the input of the FM band-stop filter. 2. Connect the output of the filter to the splitter, or to the radio. A low-cost radio has a small range between its own noise and its overload point. A strong FM signal can fill that range. The radio then loses weak signals on other bands. The filter cuts 88 to 108 MHz by more than 50 dB. Below 1 GHz it costs under 0.5 dB elsewhere. ### One antenna, several radios > **Caution.** A radio that puts DC on the cable can feed it into the other legs of the splitter. Keep the bias tee off on every radio behind a splitter. In auto_rx the setting is `bias = False`, which is the default. Do not change it. 1. Connect the output of the filter to the input of splitter 1. 2. Connect leg B of splitter 1 to the input of splitter 2. 3. Connect output 1 of splitter 2 to the RTL radio for sondes. 4. Connect the other outputs to your other radios. Each splitter costs about 3.5 dB on my station. So my sonde radio sees about 7 dB less than the antenna gives. With this radio alone on the discone, leave the splitters out. ### No amplifier, at first I do not use an amplifier. On my aircraft-message radios, a generic 20 dB amplifier cut my decoded messages by half. The strong signals reached the overload point, and the weak ones were lost. The auto_rx documents recommend a different part for the best results: a preamplifier with a band-pass filter, at the antenna. They also say good results are possible without one. I did not try one. If you add one, compare the SNR (signal-to-noise ratio) of the same launch site on several days, before and after. ## 5. The computer These steps are for a Raspberry Pi. On another Debian or Ubuntu computer, start at step 3. 1. Write Raspberry Pi OS Lite (64-bit) to the card with Raspberry Pi Imager. In the Imager settings, set the host name to `pi`, turn SSH on, and add your public key. 2. Start the Pi on wired Ethernet. Log in with SSH. 3. Update the system. ```bash sudo apt update && sudo apt full-upgrade -y && sudo reboot ``` 4. Install Docker with the sdr-enthusiasts script. Docker runs each program in a container: a closed box that holds the program and all it needs. The script also stops the kernel's TV drivers from taking the RTL radios. ```bash bash <(curl -s https://raw.githubusercontent.com/sdr-enthusiasts/docker-install/main/docker-install.sh) sudo reboot ``` 5. Check Docker and the driver block. ```bash docker compose version cat /etc/modprobe.d/exclusions-rtl2832.conf # expect 9 "blacklist" lines lsmod | grep -c dvb_usb_rtl28xxu # expect 0 ``` Result: a version number, nine lines that start with `blacklist`, and the number 0. 6. Install the clock service. ```bash sudo apt install -y chrony ``` The clock matters. auto_rx discards a position if the sonde's time is more than 3 hours from the computer's time. The auto_rx Docker page gives another way to install Docker and block the TV driver. Use one way, not both. ## 6. The radio auto_rx finds its radio by the setting `device_idx`. With `0`, it opens the first RTL radio it finds. On a computer with other RTL radios, that can be the wrong one. So give the sonde radio its own serial number. > **Caution.** Change only the serial number. Do not change the maker or product text on the radio. Some drivers look for that text. 1. Connect **only** the sonde radio to the computer. 2. Write the serial number `` to it. This command downloads one container only to use its `rtl_eeprom` tool. ```bash docker run --rm -it --device /dev/bus/usb --entrypoint rtl_eeprom \ ghcr.io/sdr-enthusiasts/docker-adsb-ultrafeeder -s ``` 3. Approve the write when the tool asks. 4. Disconnect the radio and connect it again. A restart of the computer does not load the new serial number. 5. Put a label with `` on the radio. Choose a serial number with letters in it, such as `SDR00404`. The auto_rx documents warn against `0`, `1`, `00000000` and `00000001`. The RTL tools can read a number like that as a place in the list of radios. ## 7. The software One container: [radiosonde_auto_rx](https://github.com/projecthorus/radiosonde_auto_rx), from Project Horus. Its settings are in one text file, `station.cfg`. A compose file tells Docker which containers to run, and with which settings. ### Get the settings file 1. Make the project folder and the log folder. ```bash sudo mkdir -p -m 777 /opt/station && cd /opt/station mkdir -p /opt/station/radiosonde/log ``` 2. Download the example settings file as your `station.cfg`. ```bash curl -o /opt/station/radiosonde/station.cfg \ https://raw.githubusercontent.com/projecthorus/radiosonde_auto_rx/master/auto_rx/station.cfg.example ``` Result: a file of about 660 lines. Most of them are comments that explain each setting. ### Edit the settings > **Caution.** In the example file, the upload to SondeHub is on. It also has `upload_listener_position = True`, which puts your station on the public map at the position you set. The two lines `sondehub_enabled = False` and `upload_listener_position = False` below stop that. Keep them until section 9. 1. Open the file. ```bash nano /opt/station/radiosonde/station.cfg ``` 2. Find each line below in its section, and change its value. Leave every other line as it is. ```ini [sdr_1] device_idx = ppm = 0 gain = -1 bias = False [search_params] min_freq = 400.05 max_freq = 406.0 never_scan = [] always_scan = [] [location] station_lat = station_lon = station_alt = [habitat] uploader_callsign = upload_listener_position = False uploader_antenna = [sondehub] sondehub_enabled = False ``` 3. Save the file and close the editor (Ctrl+X, then Y, then Enter). What each changed line does: | Setting | Example value | My value | Why | |---|---|---|---| | `device_idx` | `0` | The radio's serial number | Pins the radio. Section 6 | | `max_freq` | `403.0` | `406.0` | The example stops at 403 MHz. Many sondes are above that. The example file says to try 400.05 to 406 in the US | | `always_scan` | `[]` | My local sondes' frequency | auto_rx tries this frequency first in every scan, and still scans the rest | | `never_scan` | `[]` | The spurs that my scans found | auto_rx removes these from the list of peaks. Fill it later (section 8) | | `station_lat`, `station_lon`, `station_alt` | `0.0` | My position | Centers the web page map. auto_rx discards a sonde position more than 1000 km from it | | `uploader_callsign` | `CHANGEME` | A placeholder here | The example says to make it unique. It is public on SondeHub | | `upload_listener_position` | `True` | Section 9 | `True` puts your station on the public map | | `uploader_antenna` | `1/4 wave monopole` | Free text | Shows in your station description on the map | | `sondehub_enabled` | `True` | Section 9 | `True` uploads every frame that you decode | If you do not know `` yet, write `always_scan = []`. auto_rx then scans the whole band. The lists are in MHz, in square brackets, with commas between values, for example `[401.5, 403.2]`. `ppm = 0` and `gain = -1` are the example's values, and I kept them. `-1` is automatic gain. The auto_rx gain notes say automatic gain is often good enough without a preamplifier. A radio with a TCXO usually needs no ppm correction. ### Write the compose file 1. Create `/opt/station/docker-compose.yml`. If you built my other guides, the file exists: add the `radiosonde_auto_rx` block under `services:`. ```yaml services: radiosonde_auto_rx: image: ghcr.io/projecthorus/radiosonde_auto_rx:latest container_name: radiosonde_auto_rx restart: always network_mode: host devices: - /dev/bus/usb volumes: - /opt/station/radiosonde/station.cfg:/opt/auto_rx/station.cfg:ro - /opt/station/radiosonde/log/:/opt/auto_rx/log ``` `network_mode: host` puts the container on the computer's own network. The web page is then at `5000` on the computer itself, with no number to publish. The `:ro` at the end of the settings line means the container can read the file, not change it. ### Start it 1. Connect the radio to the computer. 2. Start the container. ```bash cd /opt/station && docker compose up -d ``` Result: Docker downloads the image and starts the container. 3. Read the log. ```bash docker logs --tail 50 --follow radiosonde_auto_rx ``` Result: lines like these. Press Ctrl+C to stop reading. The container keeps running. ``` INFO:Config - Tested RTLSDR # OK INFO:Started Flask server on http://0.0.0.0:5000 INFO:Task Manager - SDR # has been allocated to Scanner. INFO:Scanner (RTLSDR ) - Running frequency scan. ``` 4. Open the web page in a browser on your home network: `http://pi:5000/`. If the name does not work, use the address of the computer. Result: the page shows your version and ``, the radio as "Scanning", and a plot of the last scan. If the line `Tested RTLSDR ... OK` is missing, stop here. The radio is not connected, the serial number is wrong, or another program holds the radio. Section 13 has the fixes. ### Apply a change Each time you change `station.cfg`, restart the container. auto_rx reads the file only when it starts. ```bash docker restart radiosonde_auto_rx ``` ## 8. The first sonde ### When and where to listen The National Weather Service launches up to an hour before 00:00 and 12:00 UTC, every day. Most sites in the world aim for the same two moments. A flight can last more than two hours. In the US, NWS sondes typically use 400 to 405.9 MHz. 1. Open the SondeHub tracker: . 2. Turn on the launch sites in the Settings tab, if they are hidden. 3. Find the launch site nearest to you. Click it. The popup shows its name and its known launch times. 4. Near a launch time, click a sonde that rose from that site. Its entry in the list shows its telemetry. 5. Note its frequency. This is ``. Put it in `always_scan` (section 7) and restart the container. My local sondes are all on one frequency, 404.6 MHz. Yours can differ. Some US sites still use sondes near 1680 MHz. This guide does not cover them: the discone and the splitters stop at about 1200 MHz. ### Watch a flight 1. Keep the web page open from 30 minutes before the launch time. 2. Wait for the sonde to rise into view of your antenna. Result: the log shows these lines, and the web page shows a new row in its table and a track on its map. ``` INFO:Scanner (RTLSDR ) - Detected peaks on 10 frequencies (MHz): [...] INFO:Task Manager - Detected new RS41 sonde on 40x.xxx MHz! INFO:Task Manager - SDR # has been allocated to Decoder (RS41, 40x.xxx MHz). INFO:Telemetry Logger - Opening new log file: ... ``` 3. Read the SNR in the table. The auto_rx web page guide says a sonde needs about 8 to 10 dB for reliable decoding. auto_rx decodes one sonde at a time with one RTL radio. When no frame arrives for 180 seconds, it stops the decoder and goes back to the scan. My station first hears each flight at about 14 km up. So the first 40 minutes or so of each climb are below its reach. It then follows the flight through the burst and partway down. Your first height depends on your distance from the launch site, your antenna and what is between them. ### Is it a fair test? On SondeHub, click a sonde. The tracker draws two circles around it. The SondeHub guide says a station inside the green circle (5 degrees above the horizon) is very likely to receive the sonde. If you are inside it and hear nothing, the user guide says you may have a receiver problem. A balloon below about 5 degrees from you is not a fair test of your station. SondeHub also shows every flight from other receivers, so you can compare what you heard with the whole flight. ### Remove the spurs A spur is a signal that your own radio or computer makes. auto_rx sees it as a peak in every scan, and checks it each time, and that costs time. 1. Read the peak lists in the log for a day, or look at the scan plot on the web page. 2. Note a peak that comes back in every scan and never becomes a sonde. 3. Add it to `never_scan` in `station.cfg`, for example `never_scan = [403.2]`. 4. Restart the container. One of my spurs was 403.2 MHz. That is 14 times 28.8 MHz, the clock of the radio itself. The auto_rx documents name 403.2 MHz as a known spur on the R820T tuner. Do not add your sondes' frequency to this list. ### Read the log of a flight auto_rx writes one file for each sonde to `/opt/station/radiosonde/log`. The name holds the time, the sonde's serial number, its type and its frequency. Each line is one frame in comma-separated form: time, position, height, climb rate, temperature, humidity, SNR and more. The historical view of the web page plots past flights. It also draws a Skew-T chart of one flight: temperature, dew point and wind against height. ## 9. Share with SondeHub (optional) SondeHub is a volunteer network. It collects the frames from receiver stations, maps every sonde in the sky, and predicts where each one lands. The auto_rx project asks every station to leave the upload on. > **This step makes your station name public.** With `sondehub_enabled = True`, each frame that you decode goes to SondeHub, with `` as the receiver. Use a name that does not name you, if you prefer. SondeHub publishes the data under CC BY-SA 2.0. 1. Set this line in `station.cfg`. ```ini [sondehub] sondehub_enabled = True ``` 2. Restart the container. ```bash docker restart radiosonde_auto_rx ``` 3. Wait for the next flight. Click the sonde on . Result: the tracker draws green lines from the sonde to the receivers that sent the current frame. Your station is one of them only if its position is public (the next step). The setting `sondehub_contact_email` is optional. The example file says only the SondeHub admins see it, to tell you about a problem with your station. ### Put your station on the map (optional) > **This step makes your position public.** With `upload_listener_position = True`, SondeHub shows a receiver icon at ``, `` on its public map. The icon shows `` and ``. The example file says you need not give your home accurately. Use a position near your general area that does not identify your home. 1. Set this line in `station.cfg`. ```ini [habitat] upload_listener_position = True ``` 2. Restart the container. To stop sharing, set both lines back to `False` and restart the container. ## 10. If you find a sonde Most sondes are never found. The National Weather Service says these things about an NWS sonde: > **Warning.** A balloon found part-inflated may hold flammable hydrogen. Keep away from it. Call your local fire department to dispose of it. - It is safe to handle. The battery is probably dead. - You may keep it. You need not return it. - Report the find to upperair@noaa.gov. Also report it on SondeHub at , so that other hunters do not drive out for nothing. If you go out to look for one, SondeHub asks you to turn on Chase Mode. That puts your location on its public map for up to 12 hours. A sonde on private land needs the owner's permission first. Some hams reprogram a found RS41 into a small transmitter of their own (the free firmware RS41ng). That is transmitting, and the rules of your license and your band apply. This guide does not cover it. ## 11. Run it unattended The station needs no daily work. auto_rx scans all day, so it can also catch flights that are not on the schedule. `restart: always` makes Docker start it again after a crash or a restart of the computer. 1. Update the container from time to time. SondeHub can refuse uploads from old versions. ```bash cd /opt/station && docker compose pull && docker compose up -d ``` 2. After an update, read the Configuration File Changelog in the auto_rx wiki. A new version can add settings. Copy a new setting into your `station.cfg` by hand. 3. Restart the container after you disconnect the radio or the USB hub. ```bash docker restart radiosonde_auto_rx ``` 4. Look at the health of the container. ```bash docker ps ``` Facts to know: - **Storage.** The flight logs stay in `/opt/station/radiosonde/log`. Each flight makes one small text file. - **The memory card.** The settings in the `[debugging]` section save audio and raw data. The example file warns that they write a lot to the card. Leave them `False`. - **A baseline.** Write down how many flights your station hears in a week, and the height where it first hears them. Change one thing at a time, and compare with those numbers. ## 12. Check that it works | # | Check | Command or page | Pass | Wait | |---|---|---|---|---| | 1 | The container runs | `docker ps` | `radiosonde_auto_rx` is "Up" | 1 minute | | 2 | auto_rx holds the radio | `docker logs radiosonde_auto_rx 2>&1 \| grep "Tested RTLSDR"` | `Tested RTLSDR # OK` | At once | | 3 | It scans | `docker logs --tail 50 radiosonde_auto_rx` | `Running frequency scan` and `Detected peaks` lines | 1 to 2 minutes | | 4 | The web page opens | `http://pi:5000/` | The radio shows "Scanning". A scan plot | At once | | 5 | A sonde decodes | The log and the web page | `Detected new RS41 sonde`, then a row in the table, a track on the map, SNR above 8 dB | The next launch, up to an hour before 00 or 12 UTC | | 6 | A flight log exists | `ls /opt/station/radiosonde/log` | One `_sonde.log` file for each flight | After the first sonde | | 7 | Sharing works (optional) | | Your receiver, if you made its position public | The next flight | In its first three days on the roof discone, my station heard four flights. ## 13. If it does not work | Symptom | Likely cause | What to do | |---|---|---| | No `Tested RTLSDR ... OK` line. The log says `RTLSDR #... invalid` or `No working SDRs! Cannot run...` | The radio is not connected, `device_idx` does not match its serial number, or another program holds it | Connect the radio again. Check `device_idx`. Stop the other program. Restart the container | | `usb_claim_interface error -6`, "Device or resource busy" | The kernel's TV driver took the RTL radio | Check step 5 of section 5. Restart the computer | | Another receiver stops when auto_rx starts, or the reverse | A program with `device_idx = 0`, or with no serial number, opened the first radio | Give every radio and every program its own serial number | | No sonde for a whole flight, and the scan plot is flat | The antenna is indoors or low | Move the antenna outside and up. My indoor whip had my sondes' frequency only 1.5 dB above the noise floor | | SondeHub shows your local sondes, and auto_rx never detects them | Their frequency is above `max_freq` (the example stops at 403.0) | Set `max_freq = 406.0`. Put the frequency in `always_scan`. Restart | | The same peak in every scan, and it never becomes a sonde | A spur from your own radio, such as 403.2 MHz | Add it to `never_scan`. Restart | | Your sondes' frequency is in `never_scan` | A mistake in the list | Remove it. Restart | | A change in `station.cfg` does nothing | auto_rx reads the file only at start | `docker restart radiosonde_auto_rx` | | The container stops at start after an update | A setting is missing or changed | Read the Configuration File Changelog. Compare your file with the new example | | A sonde is detected, and decodes badly or not at all | The radio is off frequency | Use a radio with a TCXO. Set `ppm` as the auto_rx documents show | | You hear only the top of each climb | The low part of the flight is below your horizon | This is normal for a distant site. Compare with SondeHub. My station starts at about 14 km | | A sonde low on your horizon decodes nothing | Below about 5 degrees it is not a fair test | Judge the station on a flight inside the green circle on SondeHub | | Fewer decodes after you add an amplifier | The strong signals now overload the radio | Remove it. If you keep it, lower `gain` and compare the SNR | | A radio behind the splitter runs hot | A bias tee is on | Set `bias = False` | | The web page does not open | Wrong name or address, or the container is down | Use the address of the computer. Check checks 1 and 2 | | auto_rx detects a sonde and then blocks its frequency | An encrypted sonde (RS41-SGM) | Nothing. auto_rx does not decode it, and blocks the frequency for 120 minutes by default | | Nothing from your station on SondeHub | `sondehub_enabled` is `False`, the version is old, or your position is not public | Check section 9. Update the container | ## 14. What I did wrong - **I started with a small indoor whip beside the computer.** It heard nothing during a full flight. My sondes' frequency was only 1.5 dB above the noise floor. After I moved the radio to the roof discone, my station heard four flights in three days. - **I expected to hear the launch.** My station first hears each flight at about 14 km up. The first 40 minutes or so of each climb are below its reach. Other receivers on SondeHub hear the start. - **I judged the station on balloons low on the horizon.** A balloon below about 5 degrees is not a fair test. Compare with SondeHub, which shows every flight. ## 15. Not run and not confirmed - **The compose file in section 7 as written.** My station runs auto_rx 1.9.0 in Docker, but its web page is published on another number. The file here follows the auto_rx Docker page, with one change: that page writes `network: host`, and the Docker documents name the key `network_mode: host`. I did not run this file. - **The folders in `/opt/station/radiosonde`.** The auto_rx page uses `~/radiosonde_auto_rx`. I moved them to match my other guides. - **The serial number form `SDR00404`.** It follows the auto_rx advice. My own radio has a different serial number. - **The `rtl_eeprom` command on the NESDR SMArt v5.** It is from my full-station guide, where I ran it on other RTL radios. - **The lowest-cost path.** I did not build the quarter-wave antenna, and I did not try a 70 cm amateur antenna or a kit whip outdoors. - **A discone without the FM filter, and a narrow antenna without it.** I did not test either. - **A filtered preamplifier.** The auto_rx documents recommend one. I did not try one. - **The ppm advice.** My radio has a TCXO, and I kept `ppm = 0`. - **Sondes near 1680 MHz.** I read about them in the auto_rx documents. I have none here. - **That a launch site popup on SondeHub leads you to the frequency.** The user guide says the popup shows the name and the launch times. It does not list the fields of a sonde's entry. I read the frequency from the sonde. - **What SondeHub shows for a station that uploads without a public position.** The user guide does not say. - **The log lines in sections 7 and 8.** They are from the auto_rx documents and its source code, with my placeholders. The lines on your screen have times and more lines between them. - **The 3 hour time check, the 1000 km filter, the 180 second timeout and the 120 minute block.** They are from the example file and the source code. I did not test them. - **That `restart: always` and `docker compose pull && docker compose up -d` behave as I describe.** The auto_rx page shows the same with `docker run` and `docker pull`. - **The sdr-enthusiasts install script for auto_rx.** It is from my full-station guide. The auto_rx page installs Docker in another way. - **That the splitter passes or blocks DC.** Its data sheet does not say. So keep every bias tee off. - **The memory and processor load of auto_rx alone.** I did not measure it. - **The price of the radio, the discone, the filter, the coax and the small parts.** Read the listings. - **The law outside the United States.** I did not read it. - No step in this guide was run on a new, empty computer as written. ## 16. Sources All were read on 2026-10-26, except where a date is given. **The episode.** Episode 14 of Spurious Emissions, "Radiosondes": its fact sheet, its script and its list of links. **The full-station guide.** [Build the station](/guides/build-the-station/), sections 2, 4, 6 and 17. Its commands were checked against my station on 2026-10-07. The prices are from that guide and that date. Also [ACARS and VDL2](/guides/receive-acars-vdl2/), sections 4 and 5. **auto_rx.** , release 1.9.0 (2026-09-19). Its wiki: , the pages Home, Docker, Configuration Settings, Configuration File Changelog, Web Interface Guide, Gain Optimization Notes, Log Files and Performing Updates. The example file `auto_rx/station.cfg.example`, and the source files `auto_rx/autorx/config.py` and `auto_rx/auto_rx.py`. **SondeHub.** . The tracker wiki: , the pages SondeHub Tracker User Guide and Radiosonde Hunting Etiquette. **National Weather Service.** Factsheet: . Found radiosondes: . **Docker.** Compose networking, `network_mode`: . **The radio.** Nooelec NESDR SMArt v5 product page: . **Install script.** , read 2026-10-07 for the full-station guide. [^pi-load]: My Pi 5 with 8 GB runs auto_rx, a ship receiver and my aircraft-message receivers together. I did not measure auto_rx alone. A smaller Pi may be enough for this guide alone. I did not test it. [^nec]: Mike Holt's summary of NEC 810.21, 2020 edition: .