Discovering the Audio Sunset
It was a quiet evening in early spring when I decided to turn the LibreSDR B220 clone from an idle hobby to a new window on the world. The device, a fork of the famous B210 SDR, sat beside my laptop, humming softly as it listened to the static between UHF bands. My research led me to navtex—the maritime weather and safety bulletin broadcast on 490 kHz and 518 kHz. I knew that at 518 kHz it transmitted High‑Frequency SITOR-A, the short‑wave descendant of the older telephone broadcast system, and a few stations still relied on it for emergency updates.
In the first half‑hour I set up the SDR’s USB power, confirmed that the soapySDR kernel module reported a clean 54 MHz sampling rate, and pasted the parameters from the official B220 clone guide: sample rate 12 Msps, IF offset 40 kHz set to 518 kHz, RF gain 30 dB, IF gain 20 dB, baseband gain 10 dB. I rolled back to 490 kHz the next session, and the same settings adapted perfectly. The device was breathing, as if it were a breathing sea sensor ready to deliver waves of data.
Instinctively I tried the very first program people recommend for hobby SDRs: CubicSDR. It opened like a sleek radio panel, and I was able to look at the Schmid transform and roam the prompt. When the music of maritime beats flickered, I tuned the solver to 518 kHz and watched the waterfall identify a narrow band at 518 kHz with an S? level around 12 dB. The device could hear the ocean's breathing.
It was the decode phase that made the whole project sing truly. I followed a gentle path: first, I installed sox and the Python package pydub. Those tools would be my audio processing friends. Then I cloned the navtex-decode repository from GitHub, derived from the SITOR-A legacy decoders. A single command—
git clone https://github.com/masm10/navtex-decode.git
Learning how to write cues for the GPS Oais wasn't necessary, but I felt like a coder mastering a compiler, each line a possibility. Running the script instructed me to feed it a raw radio stream, so I used The CubicalOUTPUT.SaveAs raw feature to write the SDR buffer to a .raw file. At the end of each broadcast—about five minutes—my script spun into action:
python navtex-decode/decode.py -i navtex.raw -o navtex.txt
The output file sprouted a clear, human‑readable sequence: the port of origin, the date and time, the high‑resolution sked of wind, waves, and advisories. In the next day I automated this cycle by writing a tiny cron job that yielded a new .txt file every 15 minutes. It was a quiet miracle: a flood of safety information, inventory readings, and alert notices, all via a
The Quest Begins
It was a chilly morning in April 2026 when I decided to turn my new LibreSDR B220 clone into a gateway to the radio sky. My goal was clear: listen to the distant NOAA weather fax broadcasts that paint storms in ink on a display. The promise of watching a thunderstorm roll across the language of radio waves was enough to spark my curiosity.
While considering my options, I remembered the many recent community guides that had surfaced on sites like Reddit, the LibreSDR forum, and the SatNOGS mailing list. Everyone seemed to agree on the same tooling: GQRX for initial tuning, WFAX for decoding the fax format, and the low‑level GNU Radio companion blocks for custom tweaking.
Setting Up the Hardware
I unboxed the LibreSDR, attached the tiny SMA cable to the front port, and connected it to the 14‑inch antenna that had been designed for 80‑meter band reception. The SDR was a sleek black rectangle, yet it hummed with power as soon as it linked to my laptop via USB‑3.0. I plugged the HDMI cable into the onboard display to keep my eye on a quick visual readout of what the device was hearing.
On my Linux system (Ubuntu 22.04), I installed the libresdrcli tool to monitor the device’s status. The software announced the clone’s frequency range from 0 to 200 MHz with a 28‑MHz sampling depth, just the prestige I need to go hunt WEFAX.
Getting the Software
To demodulate the weather fax signals, I first installed GQRX (deb package from the official repo). After launching it, I tuned to 7.125 MHz, at the center of the NOAA 7.125 MHz WEFAX channel. The waterfall toggle gave me a quick visual of the VHF uplink, confirming I was indeed pulling the weather satellite’s echo.
Next, I pulled the WX-Decoder package from GitHub. Building from source required adding the fftw3 and libsndfile libraries; once compiled I was ready to decode the incoming fax frames.
Finally, I installed WFAX via PIP. With the wxfax -d 0 -r 95.5 -f 7.125MHz command, I directed the decoder to listen on the same channel using the same sample rate that GQRX had set, and to route the data to the display module.
Listening to the Storm
When a WEFAX burst finally flickered onto the screen, the image unfolded like a digital canvas. The satellite’s pixelated forecast appeared as a grid of 1200 × 1200 pixels, a low‑resolution snapshot of atmospheric conditions. I watched the reds and blues dance across the screen, witnessing the movement of rain bands and high‑pressure cells in real time.
In a moment of delight, the station’s telemetry burst in too— a burst of descriptive text about the satellite’s position, the time, and the effective bandwidth. It was as if I had opened a small time capsule the weather carried across the sky.
From that day on, my LibreSDR had become a steady companion on my Linux machine. Each time the NOAA satellites drift into the signal band, the device brings orographic storms, storm fronts, and the hush of clear skies into the living room without the need for a window or a telescope. It’s a humble reminder that sometimes the most extraordinary tales are transmitted via low‑bit‑rate Morse and sinusoids that a small SDR can still translate into stories we can see.
It was a crisp autumn morning in the harbor when Elliot realized that his old ham radio was up for sale at a surplus yard. The only thing he needed was a way to hear the nightly sea‑taxi reports that unfailingly relayed coastal weather and navigational warnings. The list on the sticker simply read: LibreSDR B220 clone, a modest device that promised the same breadth of frequencies as its pricier sibling but at a fraction of the cost.
The Discovery
Back in his cramped workshop, Elliot straightened the LibreSDR B220 clone from its plastic casing and slid it into a sturdy USB stand. The device’s tiny jack‑jack connector looked promising—loud, yet warning that its front‑end limit sat around 10 Vpeak. He set out his trusty notebook, a monitor, and a fresh stack of NOAA navigation updates printed from a quick Internet search.
Setting up the SDR on Windows
After installing the latest libusb drivers, Elliot pulled down the open‑source SDR# (SDRSharp) installer from the project’s GitHub page. When the interface finally warmed to a menu of dropdowns, he chose the COM plug‑in for the LibreSDR. The software immediately began scanning, ticking away a chorus of tones as it mapped the spectrum up to 28 MHz.
Tuning and Decoding
Elliot’s first target was the 518 kHz NAVTEX frequency used by maritime authorities in the mid‑Atlantic. He slid the tuner in the software’s graph until the familiar “ navigations” tone filled his hearing—an oceanic lullaby of chirp‑s across an hour of data. To decode the information, he dove into the plugin manager and selected the NavTex Decode Module. The module offered a couple of presets: “Narrowband (5 kHz)” for tied‑or information and “Full 6‑kHz” for a more detailed capture. Elliot chose the first, confident that a single clip would do.
First NAVTEX Message
As the software blinked with the rumbling of the 5‑kHz channel, a heartbeat of text materialized on the right screen. A letter from the coast guard read: “Sailing vessels: Beware of heavy rain and high tide on the Bayside Channel from 1900 Z to 2100 Z.” Elliot chewed the words, feeling the reassuring pulse of a small community that worked in rhythm with the sea.
Continuous Listening
Day after day, Elliot tuned to 490 kHz as well—a station that herded weather updates from the Arabian Sea. Using the Windows task scheduler he configured SDR# to reboot the tuner nightly so he would always catch the briefing that arrives just after midnight. The repeated listening turns his workspace into a quiet time‑machine, allowing him to feel the pulse of distant storms and the soft whisper of the currents.
While the LibreSDR B220 clone remained a modest tool—a little box of copper and a faint glow in the evening—it became the cornerstone of a golden legacy: the ability to hear the unspoken word carried by the wind, a narrative of safety, and a signal that the seas, small and large, are connected by a shared chorus of voice.
When the Storm Finally Arrived
It was a gray afternoon in late September when Robert climbed the rooftop of his apartment building, the radio kit in his backpack. He had the latest LibreSDR B220 clone, a centimeter‑sized dish that looked like a futuristic doorbell. Only a USB3.0 port separated him from the thunderstorm’s distant sigh.
First, he opened SDR# on his Windows 11 laptop. The neat graphic display buzzed to life, showing the HF and VHF bands. With a single click he docked the device, and the operating system offered a prompt to install the libreSDR USB drivers. He accepted, letting the at‑muck windows complete the update quietly.
Getting the Weather Fax Feed
Robert’s goal was specific: capture the daily WEFAX message from the NOAA NWS site. The selected frequency lane—1.4 MHz in the HF band—was the most reliable source. Through the Rx Control panel he tuned to that line, whispering a playlist of a format for the weather fax protocol. A quick scan of the spectrum confirmed a narrow signal pulsing at 108 Hz, just like an old rotary dial clock.
Next, he opened a terminal and ran the lightweight wfxsdr.exe binary he had downloaded from the LibreSDR GitHub repo (2024 build). The command line read:
wfxsdr.exe -d 1 -f 1400000 -o wefax.wavWhen the program executed, a swish of phantom rain filled his headphones as the module began converting the analog storm whispers into a 16‑bit PCM WAV file. The data stream was petabytes… no, it was less than a megabyte—just enough raw data for a 60‑minute weather picture.
With the WAV file in hand, Robert launched the WEFAX Viewer—the open‑source remake of the old DustyPhone app. He carefully pointed the Open file button to wefax.wav. The viewer’s raucous engine spun as it processed the High‑Frequency electro‑graph signals. Within seconds a cloud map appeared, rendered in crisp, character‑based resolution.
“Look at the cloud tops,” he whispered to the empty street below. The satellite blinked green on the screen—New York City’s C‑Band weather fax, now rendered in the glow of his windows display.
If the signal had been rushed by wind or lost to a passing airplane, nothing was needed beyond a simple tweak. In SDR# he shifted center frequency by a few hundred hertz, then re‑ran wfxsdr.exe. The result: a clearer voice of the storm, no longer buried under static. Robert remembered a trick from the community’s 2023 forum: a brief inverse‑polarity filter before the fax client often revealed hidden bands that ordinary receivers lost.
By sunset, the slick city lights flickered across his screen as the final waveform completed processing. Robert closed the viewer, saved the picture as WEFAX_2024_09_26.png, and uploaded it to his weather blog for other enthusiasts who wanted the DIY look into the sky. The LibreSDR B220 clone sat back on his rooftop, silent and still, a testament to how modern Windows tools and an open‑source radio can bring the world’s weather directly to your desk.
From my tiny loft in the heart of the city, I found myself dreaming of distant horizons. The salty air of the sea seemed to spill in through the thin window, and I wondered how the comforting safety messages that ship engines carry overhead could reach me, even when I’m grounded in the city’s concrete maze.
Connecting the LibreSDR Clone to macOS
First came the LibreSDR B220 clone. I slipped it into the back of my Mac’s USB‑3.0 port, feeling the gentle click of the plug. The system avoided the usual startup dialog and simply listed the device among the recognized devices in System Information. A quick command, brew install libusb, brought the low‑level support that macOS requires to see the radio’s firmware.
Building the Software Stack
With the hardware now recognized, it was time to arm the software. I opened Terminal and let brew install gnuradio bleed through my screen. The installation handshook with Python, bringing in a suite of blocks that would later transform raw IQ samples into readable maritime messages. Up beside GNU Radio, I fetched GQRX in the same brew style, letting it sit alongside the GNU Radio Companion as a quick‑look tool for verifying the frequency.
Listening to the Wind: Setting the Frequency
I whirled the tuning knob in the GQRX GUI until the bright green magnitude canvas started wobbling shakily around 162.4 MHz – the standard NAVTEX frequency line. To confirm the signal’s legitimacy, I left GQRX listening and opened GNU Radio Companion. With a fresh flowgraph, I inserted a USB Radio Source block pointing at the LibreSDR, followed by a Band‑Pass Filter that narrowed the bandwidth to a clean 100 kHz slice. The expensive part of my journey, the FM Demodulator, slipped the carrier out, revealing the FM‑encapsulated fields that carry the location and the wave.
Decoding the Messages
At this point, the real adventure began. The demodulated audio was passed to an FSK Demodulator that could sniff the 1.2 kHz and 5.5 kHz Morse components of a NAVTEX broadcast. I wrapped the FSK output with a Decode NAVTEX block developed by the community, which walked the finite state machine that resolves the code into human‑readable text. The interpreter spun out lines like “Marine Weather Forecast: Winds at 12 knots” and “Nautical Warning: Strong currents near Cape Arthur.” Each line appeared on the terminal as if it had just slipped out of the waves themselves.
Fine‑Tuning and Storing the Storm
To sharpen the reception I added a simple notch filter that clipped stray harmonics from the neighbor’s attic radio. And when the patches of gale came and went, I pushed the decoded strings into a plain‑text log file with tee. The log grew over the next weeks, each entry a snapshot of a sea‑borne broadcast that I could read from the comfort of my desk. The machine, the software, and the moment I finally felt the sea’s voice whisper
In the Quiet of the Bedroom
When the winter wind rattled the windows, I slipped the LibreSDR B220 clone into the cozy corner beside my MacBook Pro. The device sat comfortably in the USB‑3.0 port, its tiny cooling fan breathing a low, steady rhythm. As the screen flickered on, I felt the familiar subtle electric hum that never fails to remind me that this little box is a gateway to a world of radio waves I could not see.
Getting the Device to Listen
Because the B220 clone is a hitherto unsupported USB radio, the first step was to let macOS recognize it. In Terminal I typed brew install libusbp audio-harvest ocl-sdr, and the package manager fetched a collection of libraries that would allow my computer to talk to the SDR. When the downloads finished, I ran SoapySDRTest -t and a line appeared confirming the presence of the device: LibreSDR B220, 25 MHz sample rate, 250 kHz bandwidth. With the RF front‑end now humming in the background, I opened the GUI that accompanies the driver: SoapySDRgui.
Choosing a Channel on the 2.5‑MHz Band
Weather fax, or WEFAX, broadcasts on HF frequencies clustered around 4.1–6.2 MHz. I slewed the device
The First Glimpse of the Sky
It was a clear morning when the LibreSDR B220 clone rested on my workbench, its crystal‑clear chassis a quiet promise of waves waiting to be captured. I had heard from friends that this low‑cost SDR, a faithful replica of the B200/B210 design, could let me listen to the whispers of weather satellites before the likes of NOAA‑15 were long gone. Their stories of S‑band FM noise and the peculiar hiss of the 137 MHz band intrigued me, and I had to find out if the LibreSDR B220 clone could indeed open that window.Turning Tuning into Art
First, the frequency came into play. Weather satellites now downlink on the 137 MHz band, specifically 137.1‑137.9 MHz for NOAA‑19 and the newer Meteosat‑A and B series. The clone’s 200 MHz input range was generous enough to reach these frequencies, but I had to set the tuner’s 6‑bit “sample rate” to a value that produced the narrowest bandwidth possible: 100 kHz. This tight band, in theory, keeps the precious signal in focus and eliminates a good portion of the unwanted skirt. Next followed gain—the delicate art of balancing. With a low‑noise amplifier (LNA) in the antenna chain—a simple 1:1 balanced tether and a 5 dB gain you could find online—the SDR’s built‑in variable gain setpoint struck a sweet spot at about 40 dB. Too low, and the signal hissed; too high, and the fisherman’s guidelines on the local FM moved into the picture. I made a deliberate decision to leave the “automatic” gain turned off. The freedom to adjust by half‑dB steps gave me a new sense of intimacy with the tuner.Choosing the Antenna and the Right Waves
The clone’s 2.4 mm coaxial output conveniently matched a short yet efficient dipole. I selected a 1.5‑meter dipole made of copper wire, carefully adjusted to be resonant at 137 MHz. I clipped the ends to a 15 cm loop of plastic that closed over a shielded slit. On windy days, the dipole flutters; moving it back and forth, I felt the live pulse of the downlink change in real time. The sky was a silent stage, so I had to be patient. After configuring the software—GQRX on Linux, which offered me a graphical digital waterfall—I let the SDR settle and listened for the characteristic 137.5 MHz few‑minute sweeps. On the first pass, everything appeared as a thin, ascending band of color that drifted by, the rainbow streaks hinting at a passing satellite. I named it “Green Dragon” for that reason.The Jargon of Tracing the Signal
Once the signal was visible, the next stage became spectral cleaning. The satellites sweep within a 137.1‑137.9 MHz slot, so I calibrated GQRX’s waterfall window to a 200 kHz span centered 137.5 MHz. I then set a notch filter at 137.2 MHz to filter out the congested, more heavily used amateur radio sub‑band that often overlapped. With the notch set, the satellites’ signals appeared as bold, crisp stripes, far from the ambient hiss. When NOAA‑19 hovered above the equator, the SDR’s digital-to-analog chain (although unused for reception) gave the impression that the satellite let the signal pulse through a door of possibilities. The waterfall chart fluttered as the satellite passed overhead, the FM baseband revealing the satellite's compressed imagery. A laugh rippled through me: I had just captured another piece of Earth’s climate story, one that others had been condensing for decades.A Night of Discovery
During the later twilight hours, the B220 clone stayed on the table. I tuned in to other weather satellite voices—Meteosat‑A and Meteosat‑B—each with its own slightly varied FM bandwidth (60 kHz for the GPS‑orbiting metasat and 20 kHz for the more advanced S‑band). Even without technical jargon, the experience thrilled me: the clear, hum‑pic for the soft seas, the low mentoring drums of some high‑altitude NOAA beacon. I kept the same half‑dB incremental adjustments, but this time decided to test the clone’s extremes and nudged the gain save for 60 dB, an asteroid’s amount. The signal rose louder, the FM parade wide enough to fill the screen. When the battery ran out, I logged every step I took: the tuner setting, the gain value, the antenna orientation. When I returned the next day, I compared theCracking the Code of the Sky
When the LibreSDR B220 clone arrived in the mail, I was more excited than a pilot approaching a cloud‑filled horizon. Described as a budget XDRB210 for the masses, the little puck wrestling with a Conexant tuner was a mystery in a world of high‑end boards. I stacked the antenna, a short active whip, alongside the tiny adapter that would connect the weird USB‑3 interface to my tablet, and turned on my laptop.
First Contact With the Frequency Band
Inside the GQRX 2.2 interface the world opened up. I switched the center frequency to 5.275 MHz, a spot known among meteorologists for the VOLMET 5 weather broadcast. A quick glance at the spectral plot
The Discovery
On a breezy evening at the edge of the harbor, an amateur radio enthusiast named Maya was drawn to the low hum that buzzed beneath the gulls’ chatter. She remembered the adventurous nights she spent chasing distant maritime signals on her old SDR, but the aging hardware no longer matched the clarity she craved. That night, she uncovered a recent gem: the LibreSDR B220 clone, an affordable, high‑quality transceiver that promised a fresh conduit to the sea’s conversations. With its 2 GHz dual‑band ADC and a price that slid into the realm of curiosity rather than investment, the B220 seemed the perfect vessel to dive deeper into the waves of maritime radio.
Setting Up the B220
Maya began by mounting the B220 onto a sturdy tripod in the breakwater shed. The device, housed in a compact, fan‑cooled chassis, attached snugly to a 2‑meter long disused VHF marine antenna angled toward the horizon. She powered it through a USB‑3.0 cable and noted the green light humming beneath the structure—an assurance that the signal path was ready. Next, she launched GQRX, the open‑source software that had become the go‑to companion for many SDR explorers. Within a few clicks, the B220 surfaced in the device list, and Maya reset the gain controls to their factory defaults, prepared for the stern clarity of sea‑borne chatter.
Tuning In the Open Sea
The B220’s tuning sweep revealed a tapestry of maritime frequencies. She first listened to Channel 1, a VHF channel reserved for ship‑to‑ship voice communication. The channel buzzed with the crisp, world‑timetone–like human voices: the captain’s breath, the navigator’s stare, conversations about cargo, weather, and distances. As the frequency slid toward 156.775 MHz—frequently a gateway for AIS data—Maya noticed the faint yet unmistakable 57‑bit binary pulses; the B220’s 25‑Msps sampling rate captured each pulse with remarkable fidelity. She spun the LO knob, eventually landing on the 156.8 MHz band that carried the daily port updates and navigational warnings from maritime authorities. Each received burst felt like a whisper across the vast expanse, captured intact by the B220’s robust data path.
Decoding the Messages
With the raw carrier at hand, Maya employed GNURadio Companion for deeper analysis. She imported the captured packets, tapped into the AIS decoder block, and watched ship identifiers bloom into readable coordinates, speeds, and heading information. The B220’s high dynamic range was essential when another vessel stepped into the same frequency band: the same pulses that vanished into static on older hardware remained clear and actionable. Meanwhile, the quiet of the evening stretched as she listened to maritime FM broadcasting—a powerful, low‑power announcer sharing local news, weather forecasts, and sea‑state advisories to feel a sense of community afloat. The clarity of those signals did not disappoint; each transmitted news bulletin was as crisp as her own voice in a quiet studio.
Future Horizons
The modern marina had a new potential at its doorstep. Maya considered adding a higher‑gain log‑periodic antenna to widen the effort to adjacent aviation channels—ARCERTs, for instance—yet her mind remained at the sea. The B220’s open‑source firmware, lightly flirted with the latest libreSDR modifications, promised future upgrades that could blur even further into the satellite‑telemetry domain. She imagined automated scripts that would sky‐sweep annual maritime metallic glides, capturing the ebb and flow of maritime traffic. Along with that anticipation came an idea: maybe she could share her datasets, and in doing so contribute to an open repository—an archive of the world’s open‑air maritime claims. The B220, in the nighttime, became a silent sentinel, turning mariner chatter into a shared story, a living narrative that would never be relegated to airwaves alone but transcribed into a global cache built on the solidarity of enthusiasts. In an age where everyone can listen, Maya was thrilled to have the right tool—today’s LibreSDR B220 clone—to keep the tales of the sea alive.
Gathering the Gear
When it comes to listening to the high‑altitude chatter that fills the oceanic airwaves, a low‑cost SDR can feel like a surprise ally. In early 2026 I found a second‑hand LibreSDR B220 clone at a local electronics swap meet. The chip, a tiny 100‑MHz RF front‑end, is surprisingly capable of capturing anything from 2 MHz to the 30 MHz band, much of the transponder traffic carried by aircraft on long‑haul routes. The clone’s firmware is the same open‑source GNU Radio script that the original has, so setting it up is a matter of hitting a few USB and GPIO pins.
Strapping on the Software
With the SDR plugged into a small single‑board computer, I pulled up the official LibreSDR graphical interface. The first thing I did was set the sample rate to 15 Msps; that gives enough headroom to reliably decode the 1090‑MHz Mode S returns used by air traffic control. The front panel’s 20‑band RF gain knob was cranked to the middle, and a quick sweep across the 108–111 MHz band revealed the faintst of traffic drops. It was clear that a function at 106.7 MHz was the tricky oceanic cross‑talk frequency, well outside the usual Moscow, Seattle, and Dubai ciphers.
Listening to the Oceanic Chorus
Once the SDR was tuned, I launched the ModeSdec decoder, an open‑source tool that turns raw IQ data into readable transponder frames. The visual display of aircraft ranging from 747 to 777 appeared almost immediately. Every turn of the wheel, every altitude change, became a cascade of numbers. I was especially intrigued by the A* Flight Track that ran from the Caribbean into the vast Atlantic. The decoders struggled at first, because the passes are murky and the airports are swathes of GPS insufficiency. A couple of calibration tweaks to the Receiver Timing Offset and I began to see the evening".
Dealing with the Oceanic Waves
Unlike continental flights, oceanic legs rely heavily on high‑frequency and very high‑frequency beacons for position fixes. The LibreSDR can capture these frequencies, but they sit lower in the spectrum, just beneath the airplane’s 1090‑MHz. Underwater interference can show up as unscheduled bursts of noise. I had to adjust the spectral window to 8000 kHz per sideband and introduced a simple low‑pass filter in soapySDR to isolate the 2–3 kHz cross‑talk characteristic of oceanic leaky waveguides. The result was a surprisingly clean readout of the A318‑C380 crossing from the Azores to New Jersey.
The Story of a Captured Flight
During one calm night, a Boeing 787 entered the N or “NEXRAD” airspace over the North Atlantic. It was smooth, the signal every so often whispering in the right frequency band. The decoder captured its ICAO Address, Flight ID, and the GNSS position updates telling a clear narrative: the aircraft was climbing, then cruising at 35 000 ft, and finally descending toward the coast. The joyous realization that a low‑cost SDR clone had handed me the raw logic of an oceanic flight was like seeing the invisible thread that holds global travel together.
What I Learned
Nested in the accidental discoveries I experienced, were key takeaways about an SDR’s fit for oceanic aviation surveillance. First: the modest clone can sample a wide bandwidth without breaking the bank. Second: a high‑sample rate front end combined with an open‑source decoder pipeline means the barrier between a hobbyist and aviation data is less than a few man‑hours of configuration. Third: the ocean presents its own electromagnetic signatures, but with gentle filter adjustments anything that floats above the earth can be decoded and examined.
Years from now, when my friend calls asking, “Can I really listen to the offshore flights?” I’ll answer: yes. It takes a LibreSDR B220 clone, a little free‑software, and a sense of curiosity. The oceanic sky, as it turns out, is a lake of signals just waiting for an adventurous inverter.
Meeting the Clone
It began on a rainy Thursday when I slipped an unsuspecting clone of the LibreSDR B220 into a small, cluttered workbench. The box itself was a modest beige cylinder fitted with a 16‑pin male header, a single 100 µF cap, and a cheap 0.1 µH inductor. When the power was brought on it chirped dutifully, the LED blinking in a steady blue pulse that promised productivity.
According to the latest firmware release from the LibreSDR project, this particular board supports the 50 MHz to 600 MHz band with a maximum instantaneous bandwidth of 10 MHz and a 24‑bit, 96 MS/s ADC. It is a perfect match for VHF voice communication that stretches from 108 MHz to 137 MHz, giving an ample headroom for the filters I would need to isolate the data.
From USB to a Listening Eye
With the adapter in my hand, I opened a terminal and typed the familiar hints from the documentation, updating the repository using git pull and then flashing the firmware with the command sudo ./flash. The board rebooted, and I could see it pop up as usb-sdr under /dev.
As a first test I launched GQRX on the laptop I had salvaged from a decades‑old MP3 player. The application detected usb-sdr immediately, and I set the software to a bandwidth of 150 kHz. Tuning to 121.5 MHz opened a world of roar and chatter as the regular 8 kHz FM modulation of ATC made a soundtrack of crisp audio.
Putting a Filter on It
While I was pleased with the raw signal, the ambient hiss of the band and the occasional intermodulation products from the 96 MS/s ADC suggested that a stronger front‑end filter was required. A simple DC‑blocker paired with a 10 kHz band‑pass inserted into the coax at the front of the B220 did that job, letting only the voice spectrum slide through. The forums on GitHub explained how a strip of thick copper wire around the inner coaxial cable could create a resonant choke, reducing spurious signals.
Once in place, the building cadences of pilots and radar operators turned from a muddle into a music composition, and the Highland diner’s no–silence competition took no duration with the loud music I was now hearing.
Controlling Story and Power
A key to serious monitoring is precise frequency control. Luckily, the B220 clone’s LO references come from a low‑jitter 10 MHz reference. By writing a tiny Python script that called the "limesdr" CLI, I could set the local oscillator to any corner frequency with a resolution of 50 Hz. The script also fed an opcode to my digital volume control on the audio interface, meaning I could automatically keep quieter communications audible without blaring louder ones.
Because the board’s internal oscillator can drift by up to 20 ppm, the script pulled a reference from ntp.org every hour and applied a correction to the tuning of a few kilohertz. The end result was a manufacturable and repeatable process, more reliable than a cheap, off‑the‑shelf RTK receiver plugged into a phone attached to it.
Logging the Chronicle
Just as a good story captivates, a good SDR tool records. I set up a “local tuner” server that ran SoX and Voxpopuli, capturing raw data once each hour and timestamping it with UTC. Squeezing the data through a bit‑stream encoder saved memory and made it possible to re‑play the flight path of an aircraft as it appeared on the dish of the local nuisance operator in the nearby city.
When a group of communications dropped to around 110.3 MHz, I noticed the typical “successive by flight: 110.31, 110.33, 110.35 …” and could map the numbering to the origins reported by the International Civil Aviation Organization (ICAO). Even the faintest practice calls from a flight school made sense once I had rendered them in high fidelity.
Collaborating With the Community
During the first week, I posted my configuration on a forum thread called “LibreSDR B220 VHF Podcast.” The community engaged
Landing the Clone
The first time I laid my greasy hands on the LibreSDR B220 clone, I felt the familiar thrill that comes from stepping into a field where hardware meets the sky. Unlike the polished, commercial SDRs that simply sit on a shelf, the B220 clone is a rabbit‑hole of freedom: supported by the latest UHD drivers and the gr-uhd radio stack, it promises the same breadth of frequencies with the transparency of an open‑source design. I attached a narrowband I‑beam dipole, powered a lightweight LNA, and turned my laptop on, ready to listen to the invisible chatter that glides through the air.First Signals, First Sighs
After tuning the device to 129 MHz, I watched my spectrum analyzer flicker with quiet noise. In the raw view the signal was barely a whisper, but once I swept the mode into FM and applied the same correction algorithms used for FM radio reception, a faint envelope burst into life. It was a VDL‑2 data burst sprouting from a cruising jet far above my head, carried by the very plane of a silent network that is invisible to most craftsmen. The LED on the B220 blinked: success. It is important to remember that the key to seeing these bursts is not in the hardware alone, but in the software, the filters, the timing, and the patience.Decoding ACARS through the Clone
In the quiet morning when the world still hummed with coffee makers and low‑flying turboprops, I buried the B220 in a corner of my studio. The software stack was a trifecta of gqrx, gr-uhd, and LiveACARS – a real‑time ACARS decoder that stitches the sky’s conversation into human language. While the clones hardware sent constant stream of IQ samples to the qtr, a gently pulsing digital received packet landed in a decoding queue. LiveACARS issued its awe in a murmur: a maintenance request for a de‑icing system on a midsize jet. The written message hit me like a paper airplane: heavy three‑mast thunderps, and a toast about the weather. The overnight passes showed me that the B220 clone could branch through the same low‑frequency bands as a bundle of aircraft master data-links. ACARS operates around 131 MHz and relies on a quasi‑error correction scheme. By building a small IQ data capture and feeding it into the acarsdecoder Python library, I could retrieve the flight number, transponder code, and the inspiration note that a pilot wrote to their loved ones on a rushed journey to the Rockies.A Flight to Remember
On a crisp November evening, as the sun kissed the horizon, I switched to a burst tick on 131.5 MHz. The B220’s eye‑sight played the faint, modulated barbs of an incoming flight. While I was adjusting the RF path, the aircraft’s ACARS messages flooded into the screen – a reassurance, a request, a routine check. The ground station on my small ham‑radio shack joined me in a synchronous clack: the flight’s weather data was deployed in real time as a low‑latency heat‑map for the local pilots. The feeling was striking. The clone turned an intrigued hobby into a frontier where aviation, software, and humanity intersected. When the inviting melodies of ACARS and VDL hang in a quiet space, one quickly learns that the sum of a good antenna, a well‑aligned tuner, and a passionate mind is the best way to listen to the sky.Community, Sharing, and the Path Ahead
In the weeks that followed, the clone’s community matrix exploded with passion‑filled threads on GitHub: three separate PRs added a sharper digital filter; a forum thread dedicated a entire section to demodulating VDL‑2 with GR-Helix; the next update in UHD was set to correct the pass‑band distortion that had been contaminating the lower end of the 10 MHz band. My personal rig never stopped improving. Today, I note that the latest streaming docs from the LibreSDR dev team are hammered with tweaks that will enable the B220 clone to perform far better on the very band that carries the ACARS in the commercial sky. My story with the LibreSDR B220 clone shows more than a hobbyist’s dream – it reflects a moment where the sky becomes a shared playground of data, the airwaves an open network between a plane’s cockpit and the land that supports it. The future will likely look to expand this approach to the higher bands, to VDL 3, to ADS‑B, and into the Horizon of global networks, but the litany of lessons on that crisp November night still play out in every amateur’s pocket.The Spark that Took Flight
It started one ordinary Thursday afternoon when Luke was scrolling through the latest posts on the SDR FAQ forum. A thread titled *“Listening to HFDL with a budget SDR”* caught his eye. The post featured a link to a review of the LibreSDR B220 clone, a piece of inexpensive hardware that promised full 10 MHz bandwidth from 1 MHz to 2 GHz. Luke was weary of the pricey boards he’d tried before, so curiosity nudged him toward this modest device.
Building the Signal Path
To give the B220 clone a chance, Luke purchased a high‑quality 50 Ω SMA cable, a cheap yet reliable LNA, and a small dipole made from two lengths of 17 µm AWG wire. He wired the antenna to the external port of the SDR, then the SDR to his laptop via USB‑3.0, just as the user manual suggested. The controlling software was SDR# (SDRSharp) updated to the latest version, which now included a built‑in “HF Digital Listener” plugin that automatically identifies common aviation protocols.
Zeroing In on HFDL
Luke remembered that HFDL transmits on two overlapping bands: 14.000 – 14.147 MHz and 14.200 – 14.333 MHz, with a 100 kHz channel spacing. Using SDR#’s on‑screen frequency cursor, he entered 14.091 MHz, the central frequency of a popular HFDL ground station near Gander, Newfoundland.
With the “HFDL Decoder” plugin enabled, background noise began to fade, replaced by faint bursts of disciplined, pulse‑modulated carrier signals. Luke adjusted the filter width to 120 kHz and the gain to 30 dB, a sweet spot that allowed the ADAR‑16 demodulator in the SDR to lock cleanly on the 1.87 kHz carrier used by HFDL. The software’s on‑screen spectrogram started to reveal the familiar patterns of data burst repetition: the “Sync” block, the 64‑bit header, and the 64‑byte payload.
Decoding the Sky’s Messages
As the live data stream displayed on the SDR’s terminal, the plugin decoded bits into printable characters. Luke watched in astonishment as the flight number and ground‑control directives poured onto the screen: “Lat: 45.42°N, Lon: 71.04°W, Alt: 12 000 ft; Proceed to Flight Plan A.” The decoder also highlighted error‑detected packets, though the robust CRC handling of HFDL meant errors were exceedingly rare at currents signal levels above 12 dB.
Joining a Community of Sky Aliens
With the basics covered, Luke began to sift through airline digital logs posted on AirTrafficRadio.com. He shared his own captured samples on the LibreSDR Forum, pointing out how the B220 clone’s bandwidth made it easy to record the 14 MHz transponder spectrum for later analysis. A seasoned listener named Elena welcomed him, offering a free copy of a “Digital Sky Atlas” PDF that plotted global HFDL ground stations.
By the end of the week, Luke’s modest USB dongle had become a doorway into the quiet conversations of aircraft navigating the Pacific and the Atlantic. He logged every useful parameter, from antenna orientation to the monthly changes in ground‑station firmware, and he felt a deep satisfaction that the inexpensive LibreSDR B220 clone had opened up a world that many had only spoken about — not with _emdas_, but with hands‑on, antenna‑driven real‑time listening.
From Ear to Audio: A Weekend of Radio Exploration
When I first unboxed the LibreSDR B220 clone, I felt the itch of discovery. It was a small, plastic casing humming quietly on my desk, a promise of waves from global airwaves waiting to be decoded. The brochure promised support for a wide range of chips and, crucially, for Digital Radio Mondiale (DRM) reception on Linux. The challenge was clear: set up the hardware, install the right software, then tune in to a live European radio station and listen with my own headphones.
The Hardware: Bringing the Stream Into the Machine
My first step was to power the board with a 12‑volt car battery supply – the B220 runs on a 12‑V/1.2‑A input. The built‑in power switch gave me a reassuring LED pulse so I knew the board was alive. I ran a USB 3.0 cable carefully between the SDR and my laptop; the cable’s shielding mattered to keep the low‑frequency interference at bay. Keeping the cable short (under 1.5 m) prevented RF feed‑through that could wash out the weak DRM signals.
Software Installations: The ORCA Pipeline
On my fresh Ubuntu 24.04 roll, I opened a terminal and proceeded with a handful of commands. First, I installed the driver and runtime that open the board for software use:
sudo apt-get install libhackrf-dev libhackrf0 libhackrf0-doc
Once the kernel module had loaded, I then installed osmocom-dsp as the digital signal processing foundation:
sudo apt-get install osmocom-dsp
The final piece of the puzzle was the mlnx-drm-receiver package that plugs into the osmocom-dsp framework. It adds a DRM specific decoder. Its source code lives on GitHub, so I cloned and built it from source:
git clone https://github.com/murata-adio/libmldrm.git
cd libmldrm
make
sudo make install
After compiling, the ml-mdrm binary now sits ready for the day’s broadcast.
Tuning Into The Sector: The Golden Fray of DRM
Searching for a drop‑in station required a little exploration. I consulted the Global DRM Frequency Database and identified a niche German broadcaster on 99.9 kHz. I opened the ml-mdrm program and entered the tuning values: band: FMV, frequency: 99.9 kHz, and modulation: DRM. The command line then echoed a stream of hexadecimal data for a few seconds – the cold start of decoding.
When the first real audio burst appeared on my monitors, I felt the built‑in Microsoft Windows 10 Channel emoji realize each word was being processed into stereo probes. The audio dump opened in Audacity automatically, enabling me to hear the station’s voice, the occasional jazz interlude, and the seamless transition between tracks that DRM makes possible due to its enhanced error protection.
Optimizing the Mix: SDR Parameters on the Fly
Streaming DRM is a dance of several parameters: sample rate, gain, and bandwidth. I initially used the default 2 MHz sampling and 1 dB gain, but found the signal drifting to the edge of the decodable range during a festival hour. Using hackrf_info to tap the board’s internal amps, I experimented with a 1 dB lower tuner gain until I struck the sweet spot. I also adjusted the IQ filter to 50 kHz – demodulating DRM on shortwave demanded a tight bandwidth to keep the narrow call‑sign boxes in clear view.
The Result: Listening with Everyday Gear
By the end of the afternoon, my headphones rang with a full DRM program line—bugs flying as I listened to a German sports station that used the B220 clone to stream NFL highlights into a local baseball field. The audio was clear, the transitions smooth, and the quality was comparable to a commercial SDR system but at one‑third the cost. In the humble hallway of my apartment, I placed a silver coaster on the table, and the SDR kept humming, as if it had been plugged into a radio previously.
Takeaway: The Future of SDR Is Now
This weekend experience reinforced that the LibreSDR B220 clone, paired with the right Linux tools, can become a portable, affordable gateway to the world of Digital Radio Mondiale. With its open source firmware, flexible sampling, and powerful decoding libraries, you can soon become a radio detective, chasing signals from broadcasters across the globe. All you need is a laptop, the
Picture a cool summer evening in a quiet suburban house, where the only hum that fills the room is the distant chatter of a digital bulletin board and the occasional rustle of leaves. In this hush, Emma has just set up her new LibreSDR B220 clone on a table beside the window, the sleek metal back glinting in the lamplight.
The Discovery
Emma had heard that the B220, a popular clone of the Euroradio B220, could capture a wide range of radio signals with astonishing clarity. She dreamed of tapping into digital television broadcasts, but a friend had mentioned the potential of DRM—Digital Radio Mondiale—as a rich source of high‑definition audio. This sparked a new quest: can a hobbyist stand a chance of tuning into DRM streams on a Windows laptop?
Preparing the Hardware
She began by attaching the USB‑to‑RT559MHZ adapter that came with the SDR kit. Before she could hear beyond the airwaves, she needed the low‑level communication between the device and her computer to work smoothly. The first step was to download the latest LibUSB driver bundle for Windows from the official source, ensuring the system recognised the B220 without malfunction.
After installing the driver, Emma opened the Device Manager to confirm that the “LibreSDR B220” appeared under “Audio inputs and outputs.” An optical check passed instantly, signalling that the hardware was ready to stream raw data.
Software Setup
Next, Emma turned to the SDR# (SDRSharp) application, the Windows favourite for SDR enthusiasts. She downloaded the portable, ZIP‑based version to keep the machine tidy. After unpacking, she launched SDRSharp.exe and faced a freshly clean interface.
In the “Source” panel, she selected “USB” and chose the LibreSDR device from the list. Under the basic input settings, she fine‑tuned the sample rate to 2 Msps, a sweet spot that balances bandwidth with manageable CPU usage for DRM decoding.
Now the crucial bit: Emma enabled the “Decode” tab and switched the “Mode” to “DRM.” The SDRSharp SDK automatically fetched a spectral view of the incoming signal. By following the tutorial that ships with SDR#, she manually aligned the peak to the known DRM frequency—say 533 kHz in her region.
With the SDR# plugin activated, the software began to present a demodulated audio stream. For maximum fidelity, Emma adjusted the “Audio” settings to 48 kHz PCM, which translated the raw digital signal into something her laptop speakers could process.
Listening to DRM
Emma shifted her focus to the headphones she had borrowed from a neighbour. She tuned in to the local DRM station, letting the SDR# UI display the dynamic spectrum as the DSP algorithm parsed the burst data. After a few moments of idle training, a subtlely‑synthesised “Welcome to Digital Radio Mondiale” sounded clear through her earphones.
She noted how the on‑screen bars appeared—one for the audio channel, one for the data channel—each pulsing in time with the broadcast. An on‑screen text overlay revealed radio station metadata, a testament to the power of the open‑source decoder included with the plugin.
To capture the experience, Emma ran a short audio recording via SDRSharp, directing output to a .wav file. When she played the file back, the high‑definition audio remained crisp, even after compression. This demonstrated that the B220, paired with the right software, could successfully lock onto DRM on a standard Windows platform.
Reflections
By the end of the night
The Setup Journey
When Alex first heard the faint, melodic chimes of DRM—Digital Radio Mondiale—he was fascinated by the idea of tuning into a global conversation that had survived the analog era. He had a LibreSDR B220 clone, a sleek USB stick that promised to open all the frequencies of the FM band to him, right from his macOS laptop. The challenge was to coax this little device into the modern macOS ecosystem and coax it into listening for the invisible DRM signal.
He opened the terminal, the familiar green text burning into his hand. In a swift, decisive rhythm he tapped the Homebrew commands that would feed his device with the necessary drivers:
brew tap usrp/uhd
brew install uhd
The installation printed a cascade of tips. “Remember to keep uhd in your PATH, and to load the libusb drivers as soon as you plug in the B220 clone.” Alex followed the steps to replug the device. Within seconds the command line flashed:
uhd_find_devices
Device B200: FPGA ID 0x3000 – version 2024.1
A sense of triumph washed over him. The B220 clone, once a dormant piece of hardware, was now visible to macOS.
Locating the Broadcast
Next, Alex turned to the software that would actually listen. He chose SDRangel, a versatile GUI that now supported DRM demodulation as of its 2023 release. It was available as a pre‑built binary and could be installed with:
brew install sdrangel
When he launched the program, the first pane asked for a radio interface. Alex selected the newly detected B200 clone, the list neatly labeled “Intel B200”, “B200 Clone”, or whatever name the firmware had returned. He then set the center frequency to 118.8 MHz, the frequency where many countries transmit their DRM services.
He worked the knobs and sliders of SDRangel: a sample rate of 250 kS/s, a decimation to 10 kS/s, and a fine‑grained frequency correction to drift into the narrow window of the DRM carrier. The GUI’s waterfall display jumped, the flickering bite of the FM broadcast turning into a clean tone as the carrier stabilized.
When it was time to add the demodulator, Alex chose the Digital Radio Mondiale block. The block hung its own set of parameters, a gentle reminder that DRM is not simply an FM broadcast. He set the Training Field length to 250 kS, adjusted the interleaver to “type‑B,” and dimly tuned the Audio Sample Rate to 8 kHz. The system began to output a low‑pass filtered audio stream into the Mac’s sound mixer. The familiarity of a pop‑song’s intro began to bloom in his headphones.
Releasing the Sound
With the demodulating block in place, Alex had achieved something that had felt so distant just a day before: direct, unmediated access to DRM content on macOS. The audio output drifted into the built‑in “Sound” preferences, where he adjusted the volume to a pleasant level. A simple press of the space bar in SDRangel paused the broadcast; a handful of clicks later, the waveform remapped, revealing the rhythmic cadence of DRM’s data packets – a silent conversation clad in glitching radiowaves.
He finally
© 2005 - 2026 AB9IL.net, All Rights Reserved.
Written and curated by Philip Collier / AB9IL.
About Philip Collier / AB9IL,
Commentaries and Op-Eds,
Contact,
Privacy Policy and Disclosures,
XML Sitemap.