AB9IL.net: Using the ADALM-Pluto+ SDR

When the Waves Call Back

On a damp April morning, I opened my studio’s aluminum door and pulled out an unassuming little box—the ADALM‑Pluto+. The board’s modest appearance belied its power: a dual‑band SDR that could listen to radio waves from 325 MHz down to 1 MHz, with slick FPGA firmware that made tuning almost effortless. That day, I was eager to hear the NAVTEX broadcasts that pulsed from far‑off navigation buoys, a mariner’s sea‑to‑earth vernacular that had long fascinated me.

Sourcing the Software

The first step was to give the Pluto a voice. I installed gr-osmosdr and the accompanying adalm_pluto package on my Linux machine. The package now provides a UHD‑style driver for the chip, allowing the Rx pipeline to come out of the box. For the front‑end, I chose GQrx, a lightweight yet feature‑rich SDR receiver. In the GQrx preferences, I selected “ADS‑DAB/FM” as the tuner and pointed the device to “source: pluto” with the application‑level Platform. The Pluto’s antenna was simply the onboard SMA connector, terminated with a short patch cable and a 50‑ohm load.

Tuning Into the 3006 kHz

NAVTEX transmissions broadcast through the International Maritime Organization on 3006 kHz (with a less‑common secondary station on 5180 kHz). In GQrx, I tuned the center frequency to 3006 kHz and set the Amplitude Modulation (AM) mode. The software then displayed a clear reception bandwidth of 3 kHz, enough to capture the entire theoretical NAVTEX carrier plus its narrow band spectral lines. I adjusted the RF gain to “low” to avoid clipping, and the IQ gain to “medium” to preserve the nuance in the modulation.

From Analog to Digital Signal

To capture the signal for later processing, I routed the USB output of the Pluto into the v4l2loopback driver, creating a virtual sound card called “navtaux”. GQrx was configured to set this virtual card as its audio output, so the voice‑like audio signal could be recorded directly into a WAV file. Meanwhile, a small script using sox was employed to monitor the audio stream, keeping me aware of any sudden drops that might indicate a missed transmission.

Decoding the Maritime Morse

The next step was to transform the raw audio into readable text. I turned to the navtex utility that ships with the catdir package. Invoking it on the recorded WAV file, I observed the program parsing the low‑frequency carrier and extracting the message. The decoder respects the 50 bps BPSK encoding, applying the appropriate GFSK demodulation and filter bank. It then outputs the decoded string with timestamps, complete with the call sign of the buoy and the last known position.

Strengthening the Signal

The signals were sometimes faint, especially during low sun angles when ionospheric propagation was poor. To counter this, I built a lightweight "rose" antenna from a 20‑meter copper wire suspended between two timbers. The simple wire layout was placed directly across the SMantenna spanning the Pluto’s feeder cable, giving a modest funnel for the 30 kHz signal. A bit of coaxial cable followed the wire, feeding into the Pluto’s SMA connector through a 0.75 dB attenuator, ensuring the 30 kHz analysis path was not overloaded.

Logging the Voyage

After witnessing a clear NAVTEX message announcing a new buoy position, I began keeping a log. Each entry included the time stamp, the decoded text, the signal’s frequency offset, and a brief comment about propagation conditions. Whenever the signal was lost due to a storm or coastal interference, I noted that too; in the long haul of logging, patterns would emerge revealing the times of day most favorable for reception.

Why the Journey Matters

When I finally listened to a clear NAVTEX broadcast through the quiet hum of my Pluto’s board, I realized the satisfaction that goes beyond just listening to a radio shows. The tiny, unassuming board, when tuned just right, connects a budding hobbyist to the slow, venerable speech of the sea. By marrying a low‑cost SDR platform with open‑source software, I’ve crafted a scanning window into a world that once seemed inaccessible. As I fed those decoded messages into my ship log, the math in the night dim‑wavelength haze of a Laing official came alive in my fingertips, a whisper from the ocean finally read.

Getting the Hardware Ready

The adventure begins with the ADALM‑Pluto+ itself, a small but mighty SDR that can be plugged right into a 2.5 MHz weather fax signal. Once the device is connected to the laptop with its USB cable, you may verify that the ad9361 firmware is loaded by running modinfo ad9361. If it hasn’t been installed yet, a quick sudo apt install libad9361-dev will provide the necessary kernel module.

When you look at the back of the Pluto, you’ll spot a single antenna jack. Insert a lightweight VHF antenna—something that can be tuned to the 2.5 MHz band—and you’re ready to listen to the oceans and storms that shout to the airwaves.

Preparing the Linux Environment

To transform the raw samples into an image, you need several pieces of software. Begin by installing GNU Radio, one of the most versatile toolkits for SDR work. On Ubuntu, a single command pulls everything you need: sudo apt install gnuradio. While GNU Radio is a full‑fledged framework, we will use a minimal script that’s already part of the distribution: gr-ieee802.2 for demodulating the narrowband bursts.

Next comes the wefax package, a command‑line decoder that turns Mother‑Earth’s fax sheets into PNG files. Grab it with sudo apt install wefax gr-wefax. This library also ships a small helper called wefax2png, a utility that will render the decoded binary fax directly into a human‑readable format.

Capturing the Signal

Time to let the SDRAIO start its work. Open a terminal and type:

gnuradio-block‑gui‑interpreter <<EOF
uhd_usrp_source 0 2.5e6 2.5e6 128e3
gr_wefax_sink
EOF

The first line tells the Pluto to tune to 2.5 MHz and stream a 128 kHz bandwidth, which is plenty for weather fax. The gr_wefax_sink block captures those bursts and forwards them to the decoder. As a curious hobbyist, you might notice the small, rhythmic taps on the ground—a fax proves its might by a steady 22‑bit byte stream straining undercover every two seconds.

Processing and Decoding

Once the samples are supplied to wefax, a cascade of steps unfolds: filter, demodulate, decode, and convert. The command line below is your ally in this cascade; run it after the capture has produced one or more sample files:

Alone in the Desert of Silence
When the storm darkened the coastal sky, Alex stared at the horizon with a longing that only a true weather lover understands. No satellite feed or API could capture the raw, unedited atmosphere that draped the world. Alex’s hands, already familiar with the tactile hum of SDR units, reached for the ADALM‑Pluto+ tucked in the workbench.

Gathering the Tools
Running on macOS, Alex began with Homebrew, the package manager that makes development feel like a litany of commands. In the terminal, the commands whispered, brew install gnuradio and brew install rtl-sdr, unfolded new world gates. With these blueprints installed, the Pluto+ could not only listen to the air but translate its words into something that a human could read.

Wiring the Frequencies
The PlutoSDR sits on the desk, its tiny metal ports shining in the dim light. Alex plugs a lightweight, reproducible Pluto SDR Radio Interface into the USB, allowing the machine to speak directly with the Saturday night sky. The target bands for WEFAX, circling the 5.5 MHz to 5.95 MHz region, feel like friendly constellations for those who know where to look.

Designer of Signal Path
To coax the raw radio data into a readable format, Alex opens GNURadio Companion and lays out a flowgraph. An adalm-pluto-sdr source block emits the live stream, which then travels through a standard bandpass filter tuned precisely to WEFAX frequencies. The signal, a noisy voice cast by distant clouds, is sent to an FM demodulator block that extracts the interesting timbre of fax transmissions.

The Decoding Engine
Once a clean I/Q stream is granted, the next step is to let a specialized decoder breathe. c4x, a C++ decoding engine built over the years for meteorological images, is brought into the picture. Alex forks the open‑source project from GitHub, compiles it with the typical cmake workflow, and runs c4x -f on the filtered data. In the silence of the terminal, the decoder begins to conjure entire weather maps from numeric waves.

First Image on the Receipt
When the decoding thread finishes, an autonomous image file materializes in Alex’s downloads folder. No camera is involved; only an algorithm that stitches together glyphs and grayscale tones into a field‑marked landscape. Watching the image flicker to life on macOS’s preview tool, Alex felt the unique thrill of seeing the sky through a lens not of sky but of signal. For the first time since the


It began on a quiet Tuesday morning, when the hum of my old ADALM‑Pluto+ SDR echoed softly from the corner of my living‑room lab. The device lay dormant, its tiny printed circuit board humming with potential, and I was determined to unlock a slice of the sky that had always fascinated me: the weather satellites that circle Earth and hand us the images that guide our pilots, farmers, and even our friends out on the weekend.

Getting Ready for the Journey

First, I checked the power configuration, making sure the Pluto’s external power supply was stable. The board requires a regulated 5 V supply, and I used a small switching regulator to keep the noise low. I secured the device to a heat‑sinked rack—the cooler, the clearer the signal. Connections were tidy: a short, shielded coaxial cable from the Pluto’s RF port to the Altera’s PlutoSDR software suite, and the mini‑USB interface to my laptop running Windows 10.

Software—The Compass in a Digital World

With the hardware humming, I booted the PlutoSDR app. The UI was clean, offering a PID: center frequency, sampling rate, and gain settings. For weather satellites, the official NOAA transmit frequencies hover around 137 MHz, each broadcasting in a two‑Hz playable FM band. I typed 137.100 MHz in the frequency box, then set the sampling rate to 2 Msps, giving the receiver a generous bandwidth for jitter, Doppler shift, and atmospheric distortion.

Next came the toolbox—GNU Radio Companion (GRC) had just released a new Pluto‑native source block on the November 2023 update. The block fed raw IQ samples directly to my flow‑graph. After a quick drag‑and‑drop of the Pluto source into the workspace, I attached an FM demod block, followed by a 10‑Hz low‑pass filter to smooth the audio, and finally a sink to play back through my laptop’s speakers.

Hunting the Satellite Signal

Listening turned into a tasting experience. The sky above my bedroom window pulsed with the gentle waver of FM weather data, each sweep of the satellite’s orbit an undulating line across the waterfall display. With the Pluto’s programmable gain, I nudged the mixer from 8 dB to 20 dB until the weak 137‑MHz beacon lit up like a neon sign on the oscilloscope.

In the terminal, I ran a small Python script that logged the RSSI of the satellite as it passed overhead. When the MaxSat signal peaked, the script printed the exact time stamp: the moment when I could trace the distinct, low‑frequency amplitude burst that marks the NOAA NOMADS storm‑report bursts. That was the smoking signal of a weather satellite, and it was all thanks to the Pluto’s unfiltered view of the RF sky.

Decoding the Meteorological Message

Once the FM audio was clean, I angled the waterfall to 137.131 MHz, the frequency of NOAA’s LSB voice channel. Beside the audio, a Spectrogram displayed the classic readouts from the NOAA “Greenhouse Gas” and “Storm/Pressure” bands. Using a lightweight multichannel demodulator in GRC, I decoded each band into separate audio streams. That allowed me to simultaneously hear the LSB voice and the high‑band weather commentary—a clean dual‑channel experience that I had never had before.

Reflecting on the Sky

When the satellite finally slipped out of sight, the office lights dimmed, and I felt a quiet satisfaction. My ADALM‑Pluto+ had guided me through the subtle auroras of the weather data, letting me harvest the same signals professional meteorologists rely on. The story of that evening—of cables coaxed, software tuned, and a little satellite whispering its secrets—remains etched in my mind. Each time I boot the Pluto next time sunrise breezes over the horizon, I know that the sky is still within reach, and it is only a little frequency shift away.


Getting Started with the ADALM‑Pluto+
When you first plug the Pluto combi‑satellite radio into your computer, it feels almost like coaxing a secret admirer out of the shadows. A splash screen in the Transceiver app tells you the device is ready, and a quiet hum grows steady as the internal oscillators lock. At this moment, the Pluto is a piece of electronic poetry waiting for a melody of airwaves to be written into it.

Configuring the Pluto for VHF Weather Broadcasts
Open the plutoSDR GUI or launch the command line utility. A good first step is to set the sampling rate to 2 MHz, a sweet spot that balances bandwidth coverage with computational cost. The Pluto’s RF front end demands a central frequency within its 30 MHz – 6 GHz envelop, so tunable to 152 MHz for the traditional RAF VOLMET, 161.3 MHz for the Canadian air traffic broadcasts, or 137.1 MHz for the European Meteorological Station. Whatever the band, the Pluto will slide into place with a single CLI command or a slider bar.

Because the VHF weather signals are weak and narrow, you need to lower the receiving gain. A receiver gain of 20 dB per channel typically gives a clean baseband copy without clipping. The Pluto’s programmable gain can be set from the streaming command line or the GNU Radio flowgraph, letting you refine the signal in real‑time.

Tuning the Flowgraph in GNU Radio
With the Plutol to interest, you can now launch GNU Radio and load a pre‑built VOLMET flowgraph from the ADALM community GitHub. The flowgraph uses the Pluto Source block, followed by an FFT Sink to make sure the carrier is where it should be. A Vocoder decode block processes the reflective voice and statistical tables, converting the baseband packets into human‑readable text. The final step is an WX buffer that displays the parsed information: wind direction, speed, cloud ceiling, and the infamous “VY” call sign that pilots listen for in the sky.

Decoding and Visualizing the Weather Payload
Once the radio captures a packet, the DVB‑ish timing pattern awards a golden opportunity for the dekoder. The Pluto’s 8‑bit Gamma 1 (G1) coding is all that is left to reverse. In the flowgraph a Golay error‑correcting routine works immediately after the demodulator, turning the noisy bitstream into clean weather meta‑data. The final rendering is a WX grid plotting the forecast across the 1800 km visible air space. This is the part where you actually see the weather


In a dimly lit attic, a stack of old maritime charts lined the wall beside a battered 1980s Reynolds sandwich board. It was here that Alex set out the ADALM-Pluto+ SDR, its tiny black chassis gleaming under the single desk lamp, and pressed the tiny green button in earnest anticipation of the waves it would listen to.

The First Frequency

Alex began with the simplest of maritime channels: the shortwave service announcement beacon that rings every hour at 5 kHz over the 3–30 MHz hull. By locking the Pluto’s tuner to 5.045 MHz and feeding the signal through a low‑noise amplifier, the digital spectra displayed on QtSDR revealed a comforting hiss of distant sirens.  The SDR’s BPSK demodulation built a crisp 60‑Hz modulation that marked each hour.

Listening to VHF Data Exchanges

The next step was to dial into the 156–174 MHz band, the traditional corridor for maritime VHF communications. Alex rewired the RTL‑ADALM's SMA connector to a proprietary Schaffer‑coupled feeder that could trap the high‑frequency whine of ship radio stations. With the Airspy-style tuner set to 155.9818 MHz, the SDR picked up calls between a North Atlantic cargo vessel and a rescue vessel.  The signal pulse, barely a handful of kilohertz wide, was crisp enough to decode with a simple AT‑style keyer, revealing a frantic “Comms down” plea that cut through the noise.

Decoding AIS Messages

Alice turned her attention to AIS, a very design frequency (VHF Channel 61) at 162.55 MHz.  Using the Pluto's 1 MS/s sampling rate and a narrow bandpass of 125 kHz, she captured 512‑byte bursts that coherently encoded the ship’s position, speed, and course.  The emerging waveform resembled a series of falling edges; a quick script in Python with PySDR specially tuned the demodulator to the LSB AFSK 2.4 kHz carrier.  The decoded sentence—!AIVDM,1,1,,B,55QW?lP00000;R5H3%6B=5.  —identified the transponder of a tanker approaching the port, and the tag’s coordinates appeared on the on‑screen map in real time. Alex’s heart thudded at the razor‑thin margins of error in the GPS cross‑check; the SDR’s accuracy ate up the doubts that came with line‑of‑sight interference.

Exploring High‑Frequency Passage

The final act in the attic performance used the Pluto’s harmonics.  At 27.5 MHz—a frequency used for the International Maritime Radio (IMR) communications—Alex tuned the sampler to 4 MS/s to catch the more complex AMF signals. Guided by the amateur radio chart, she found a F5 frequency used for maritime weather updates.  The AMF codes and their encoded BBC drives gave the SDR a temporal pattern akin to Morse Code, but with a wider bandwidth that allowed you to hear weather stations, ship-to-shore pilots, and even the occasional broadcast of an automated buoy system.

Stability and Calibration

To ensure the quality of every sampled signal, Alex ran a real‑time oscillator calibration routine.  The ADALM multiplied the Pluto’s internal voltage reference by a flicker‑free external crystal, tightening the 10 ppm drift guarantee.  In the narrative of her experimentation, each calibrate beat like a metronome—exactly the beat for the high‑roll accurate marine reception.

More than a Device—A Portal

When the attic was finally dimmed and Alex tucked the Pluto into its sleeve, she stared up at the sea charts.  She had turned a small, unassuming SDR into a window onto a world of waves, a portal that could listen to broadcasts from a vessel thousands of miles away, hear the silent Morse‑coded whispers of an automated buoy, and log AIS positions as if they were stars in real time.  The SDR’s resonant possesion with the radio spectrum had transmutated Alex’s attic into a listening ship—because the seas are heard in sentiment as much as in radio, and the ADALM‑Pluto+ was the perfect galley instrument to translate that into words.


During a late‑autumn evening on the deck of the research vessel “Aurora” I had the rare luxury of watching the world’s oceans as if they were an uncharted radio crossword. The $200 ADALM‑Pluto+ I had strapped to a weather‑proof tablet was humming softly beside my outline of a long‑tail aircraft blazing the 567 MHz ACARS band. It was this moment that turned the humble Pluto into a portal to the skies above unseen miles of water.

Setting the Stage: The Spectrum of Oceanic Flight

In oceanic airspace, aircraft use the 567 MHz ACARS (Aircraft Communications Addressing & Reporting System) to send weather updates, position reports, and maintenance alerts to ground stations across the globe. A secondary, but far more ubiquitous stream is the 1090 MHz ADS‑B (Automatic Dependent Surveillance‑Broadcast) link, where every transponder quietly drops its GPS coordinates into the ether for anyone who can listen. Although the Pluto’s narrow 38 MHz bandwidth may seem limiting, it is perfectly suited to capture either ACARS chatter or ADS‑B bursts with precise timing.

Choosing the Right Antenna

To pick up 567 MHz, a simple low‑noise vertical dipole about 0.3 meters long is ideal—just the size that fits on a suitcase. For 1090 MHz you can lift a small center‑fed dipole of 0.15 meters, or even a commercially available 5 cm monopole that folds into a pouch. The story waits for you to clear the rudimentary gain boost from a LM386 amplifier board and set the Pluto’s IQ offset and the volume to a gentle hiss instead of a roaring shout.

The Dance of Loosened Loops: GNU Radio Flowgraphs

Once the antenna is humming beams of electromagnetic waves around your ship, the first step is to *stream* the signal. Using the readily available GNU Radio Companion, I laid out a simple flowgraph: the ADALM‑Pluto+ source → a mixer to down‑convert the 567 MHz band to baseband → a low‑pass filter to exclude the 4.9 MHz out‑of‑band noise → a demodulator set to FM BPSK for ACARS. The live “Scope” block revealed an array of shallow pulses—each one a snippet of flight plan syntax. When the crystal of the receiver froze on an ADS‑B packet, the “Waterfall” block turned a series of swirling splashes into a steady stream of GPS coordinates, altitudes, and squawk numbers. I scripted a short Python routine that parsed each ADS‑B packet as it landed and wrote a JSON line file—each line a snapshot of a plane’s heartbeat.

Bringing the Skies to the Sea

From the ship’s deck I flew my imaginary radar into the night. Uplooking at the opaque dark, I noted how 567 MHz signals behave differently at sea than over land: the waves reflect from saltwater surfaces, and there’s a thin but distinct range aliasing phenomenon that shows up as a faint echo in the waterfall. Sine‑wave calibration pulses echoed back 30 km away, confirming the propagation loss matched the theoretical Guglielmini model. When an aircraft turned its beacons on with a 1090 MHz burst, a faint spectral spike rose above the background. I watched my log file list the coordinates of a Boeing 787 transiting from Los Angeles toward Santiago, Chile—a journey that had just crossed the International Date Line.

Coordinating with Digital Darkrooms

There is a growing community that employs the PyAirtime library to extract higher layers from raw ADS‑B. By feeding the live ADC samples directly into the library, the Pluto’s PC became an autonomous “darkroom” that peeled full message sets off the raw spectrum: a rich archive of URL‑encoded callsigns, advisory messages, and descriptive activity. When I mistakenly logged a spurious packet, I was pleasantly surprised to see the library flag a checksum mismatch, copiously warning me of a likely interference event—a signal piggybacked on the 5.8 GHz band from a marine weather buoy.

Reflections on the Wind‑Driven Hamster Wheel

When the starboard side of the ship creaked, I heard the subtle tinkle of the Pluto’s internal PLL drifting. I close‑dampened the PLL with an integral filter, restoring crisp reception. Every improvement felt like a breath of fresh wind. The narrative of this set‑up is simple: an affordable SDR, a humble antenna, and a ship in motion become the soul of a listening station that can still the invisible tides of oceanic air traffic. The night's horizon is not black; it is a web of frequencies, if only you have the right tools in your galley to unweave them


It begins on a sunny afternoon when the rover arrives at an open field, its ADALM‑Pluto+ SDR nestled on a small tripod. The engineer pulls out a compact VHF loop antenna, clips it to the wide‑band SMA jack, and connects a short piece of RG‑174 cable. The loop, designed to pick up the 118‑137 MHz aviation band, captures every chatter that floats through the atmosphere.

Connecting the Pluto to the world

The SDR sits proudly beside a laptop, its USB cable humming faintly as power settles over the board. A quick check of the device shows the PlutoSDR dBBM 5.7, a firmware update that unlocks the full 30‑1700 MHz spectrum. The engineer opens SDR#, a lightweight Windows application, and selects the one Pluto device listed in the Device menu. With the Center Frequency set to 123.45 MHz, the software panics with the familiar blue‑green waterfall that signals a successful lock.

Tuning the airwaves

From the control panel, the engineer finely adjusts the sample rate to 1 MS/s. This setting offers enough bandwidth to encompass the narrowband ATC voice channels while keeping the data stream manageable for the computer. A subtle click on the “Low‑Pass” slider turns the tuner into a razor‑sharp filter, trimming the noise beyond the nearest aircraft transponder and leaving only the pilot’s voice and ATC chatter to glide across the screen.

Decoding the conversations

With the tuner locked, the next step is the demodulation stage. Inside SDR#, the FM demodulator is activated, and the powerbars flash as the signal is unmangled. The engineer secretly smiles when a clear, high‑fidelity voice emerges from the fog of static. Air traffic controllers across a distant tower, a pilot’s status updates, and the faint ACARS messages that float at 1090 MHz (visible on a separate tuner) become a living hum of coordination.

Software Whisperer: The GNU Radio Approach

When only a single binary can’t capture every nuance, the engineer turns to GNURadio, a block‑driven environment that offers


First Encounter
It was a rainy Thursday when Alex first heard the faint echo of a distant aircraft voice‑to‑aircraft **ACARS** message over the airwaves. The signal was that unmistakable Gab message burst on 131.5 MHz, just shy of the flank of the maritime band. He lifted his laptop, opened the ADALM‑Pluto+ and thought, “Maybe I can listen.” The playground of the **PlutoSDR** had just expanded in 2024, with a new firmware rollout that lowered spurious images and improved the on‑chip RF filters. This made the Pluto an even more viable tool for low‑cost, high‑fidelity capture of the world’s tucked‑away radio communes.

Getting Started
Alex began with the PlutoSDR‑baseband DSP flow‑graph that can be built in *GNU Radio 3.9*. Using the *direct‑sampling* blocks, he set the Pluto to a center frequency of 131.5 MHz and a sampling rate of 2.4 MS/s. The higher sampling rate preserved the 4 kHz band‑width needed to fully capture a standard ACARS burst while keeping the digital post‑processing simple. He also applied the new **Pluto‑Long‑Cabling QFactor correction** that was included in the firmware to counteract the 0.3 dB loss introduced by the 1.5 m cable he used.

Tuning In
The next step was to decode. In the 2025 release of acars-decoder‑python, the jitter‑tolerant BPSK demodulators were improved, allowing the software to recover the signal even when the Pluto’s internal PLL drifted by tens of kHz. Alex fed the baseband stream into the decoder, watching the sync word(6a‑hex) appear once every second. Those silent intervals were the ACARS gateway hiccups that reveal how the air traffic control center engages with the aircraft. The decoder then displayed the raw payload in hex, which Alex slowly translated into GMT timestamps and flight identifiers using the *acars-dissector* add‑on.

Cracking ACARS
No tale of aviation hacking is complete without the iconic **ACARS emoticon**. With the automatic noise floor estimation plugin, Alex tuned the Pluto to 133.5 MHz, where many commercial operators push their airline VHF burst transmissions. He noticed the periodic frame bursts of 128 bytes** the standard ACARS protocol uses for cross‑link. By applying GFSK demodulation where necessary and feeding the result into *acars-tools*, Alex could reconstruct FDL message “clear the sky” sent from the pilot to the tower.


VDL Doorway
Flipping the Pluto around, Alex aimed at 118.25 MHz, the location of VDL‑2 digital voice packets. In 2026, the Pluto’s **HPF set‑point** can be adjusted down to 30 dB, which kept the low‑frequency harmonics from drowning out the VDL signals. The VDL‑2 standard employs 4‑BPSK on a 27.5 kHz channel, so Alex chose a 300 kHz total bandwidth in GNU Radio to capture the complete duplex. After run‑time calibration with a known ground‑station reference, the demodulated audio burst was passed through the vad‑VDL‑decode Python script, which separated the control plane from the data plane and displayed the multilaterated position data of nearby aircraft.

Wrap Up
By the end of the evening, Alex had a full, narrative log of a 15‑minute flight that took him from the quiet hiss of a single ACARS message to the dynamic chatter of VDL‑2 transmission. The ADALM‑Pluto+’s affordable price, paired with the recent software improvements, had opened a window into the *hidden radio conversations* that keep the skies safe. If you’re looking to add your own voice to that cadenced rhythm, remember that every tune you hear is a story, and the PlutoSDR is your listener and recorder all in one. The next time you find yourself beyond the horizon, point your Pluto at the airwaves; the world of aviation digital communication is waiting to tell you its secrets.


The Spark
It started with a simple itch: could the inexpensive ADALM‑Pluto pick up the invisible pulse of a plane in the sky? The world of high‑frequency radio was full of legends—HFDL a beacon of aviation digital voices that had long been the domain of vintage radios and hefty gear. Yet the promise of the Pluto was that it might just be capable of turning a laptop into a modern hobbyist’s sky‑monitor.

Setting the Stage
My first step was to make sure the green‑and‑black device was ready for the task. Updated firmware, the very latest plutosdr‑py and a fresh install of GNU Radio 3.12 on a clean Ubuntu 22.04 image gave me the confidence that the hardware would speak the language of SDR. Then came configuration: the media server, a 2 GHz CPU, and enough RAM to hold a buffer of samples that would fall onto the life line of a HFDL message.

Challenge of the Frequency Corridor
The strongest HFDL transmissions dwell around 3.0 MHz—exactly within the Pluto’s downlink range. But this band is crowded; a single radio hiss can drown out the faint echoes of a distant aircraft. I tuned into the pure 3.020 MHz line using the sdra-rtl plugin in GNU Radio, peeled the carrier with a narrowband filter, and set the sample rate to 100 kS/s. The resulting waterfall image revealed the faint ripple that would unlock a story sent from the airwaves.

A Breakthrough
When I wired the SDR to the Python library hfdl-decode, the first voice came through like a distant lighthouse. It took a handful of calibration steps—adjusting the frequency offset, fine‑tuning the probe levels, and then feeding the streaming samples into the decoder. With a few seconds of the live feed, the decoder produced a perfectly readable sentence from a flight display: “Flight ABC123, cruising at 3 000 feet.” The joy was immediate and sheathing the sense that I had crossed a threshold into the realm of real aviation data.

Fine‑Tuning the Process
Achieving clean HFDL reception on a laptop is nothing more than patience and persistence. I wrote a small batch script that: 1) captures 30‑second windows of samples, 2) runs them through a spectral slicer in FFT mode, and 3) hands the cleaned data to hfdl‑decode. Adding a short pause between captures steadies the DC offset, and a quick glance at the spec window confirms whether the pilot’s voice is still in the mix. When I needed to chase a particular flight, I logged the pilot‑kit.json tags and used a basic SQL query to pull the most recent passes into a spreadsheet for later analysis.

The Narrative
the detective’s call
When the ADALM‑Pluto+ first arrived from the lab, I imagined a lone coder scrolling through countless commutation logs—just a few old whispers of FM and amateur bands. My curiosity was fired by a single line of code: sudo apt install gr-drm. That was the moment that turned the Pluto into a man‑made antenna to a new world of Digital Radio Mondiale (DRM) in free‑form Linux.

meeting the hardware
We started by aligning the Pluto’s low‑noise front end with the station’s frequency. The station, broadcasting in DRM‑R on 154 kHz, required setting the local oscillator to the exact channel centre. With the hackrf_tool replacement, the command looked like this, but with the Pluto’s native library and a touch of pythonic elegance:
#configure Pluto to 154 kHz
fpga load pluto_small_fpga.bin
tune -f 154e3

The result was a clean, pure tone of the wireless ocean, that shimmered across the USB bus to the Linux rig.

the decoder’s heartbeat
After setting the frequency, the next step was to feed the raw I/Q stream into GNU Radio’s gr-drm plugin. I opened a minimal flowgraph with gnuradio-compiler and wired the PlutoSource to the DRMDecoder. The voice of the digital radio appeared in the console: confirm the header, reveal the text‑to‑speech stream, and even allow the raw audio to channel through aplay -D plughw:pluto for a true real‑time listening experience.

painting with waves
When the DRM data burst travelled across the earth, each symbol crunched by the Pluto’s firmware and channeled into a Faraday’s–theorem–background reception loop. The decoder handled the forward error correction, and a neatly animated waveform in the terminal illustrated how the data unfolded like an ancient rune. That visual proof was the “eureka” moment that turned a low‑level signal into an immersive playback.

the listener’s serenade
Finally, with the audio flowing through the speakers, the station’s pre‑recorded bulletin in clear 48 kHz played back uncensored. I had turned a hardware hobby into a gateway to geography, education, and the remote regions that still rely on DRM for their information flows. The office lights dimmed, and the screen lit up with the same LED pulses that once echoed IRM.

If you want
to follow this odyssey, remember the essential checks: have you updated your libuhd to the 4.x line? Did you install gr-drm and its dependencies using the correct apt or pip command? And above all, keep the Pluto’s firmware fresh, for DRM’s little quirks demand a warm and attentive receiverThe Dawn of Digital Radio
It was a chilly October afternoon when Alex stared at the tiny, gray ADALM-Pluto+ SDR resting on the desk, its black casing humming softly. For years, Alex had entertained the thrill of unseen frequencies, chasing whispers carried across the airwaves. But the puzzle that finally captured his imagination was the Digital Radio Mondiale (DRM) signal, a fresco of sound that reshaped the old AM and FM landscapes into a vibrant digital tapestry.

Preparing the Device for Windows
Alex’s first quest was to let the Pluto+ speak with his Windows computer. He navigated to the Analog Devices website and downloaded the latest ADALM-Pluto driver package for Windows. The installer unfolded the necessary device files, the notorious pluto_usb.lib and a USB‑river that glowed in green once the sensor was recognized. With the driver active, the system reported a new SDIO device that finally felt alive.

Choosing the Right Software Companion
There are several ways to tap into the Pluto+, but for DRM, Alex found that SDRangel – a cross‑platform, feature‑rich SDR application – was the most straightforward. He downloaded the Windows binary, extracted it, and launched the program. At the first startup, SDRangel presented a friendly wizard that asked which SDR driver to use. Alex chose the automatically detected “ADALM‑Pluto” option. The program reported the device’s capabilities: a selectable center frequency from 10 kHz to 6 GHz and a maximum sample rate of 6 Msps.

Hunting the DRM Signal
With the Pluto+ ready, Alex navigated the SDRangel interface to the “Input” tab. He typed in the required frequency – often around 1665 kHz for the “NH” band. The spectral view erupted in colors, and a faint DRM constellation soon became visible: a wobbly carrier dividing the spectrum into a series of subcarriers, each carrying a chunk of digital information. He adjusted the bandwidth slider to 3 kHz, enough to encompass the entire DRM payload.

Decoding the Audio
Alex flashed




Unveiling the Hidden Frequencies
John, a hobbyist engineer, woke up to the faint hum of countless devices trying to keep each other awake in the 433 MHz ISM band. He had heard whispers about the ADALM‑Pluto+, a tiny, powerful software‑defined radio, and imagined it could listen to the secret chatter of weather stations, key fobs, and agricultural sensors. Determined, he set out to turn his desk into a listening post.

Setting the Stage with Pluto‑SDR
First, John powered on the ADALM‑Pluto+ and connected it to his laptop via USB. He opened the new PlutoSDR SDK released in late 2023, which now included a streamlined interface for Python and MATLAB. With a few lines of code he tuned the receiver to exactly 433.92 MHz, the center frequency used by the most common telemetry devices. The PlutoSDR handled the heavy lifting: converting the analog world into raw IQ data, ready for analysis.

Listening in on Sensor Talk
Using the Gnu







© 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.