The Discovery Starts with a Quiet Call
It began on a rainy evening when my Airspy HF+ Discovery sat quietly on my desk, cabled to my laptop. I had just downloaded the latest firmware update, which added enhanced frequency calibration and a new UI theme that made the RF waterfall look like a moving ocean. The device, with its 2 GHz bandwidth and SDR# compatibility, promised a portal into the hidden worlds of amateur radio and beyond.
Sensing the Invisible Waves
After launching the SDR software, the first thing I felt was the thrill of seeing signals that were invisible to the naked eye. Signals from NOAA weather stations, distant amateur transmitters, and even the faint chatter of the LoRaWAN networks were cleanly displayed in the spectrum plot. But there was one type of signal that caught my attention—a dense, rhythmic burst that seemed to shout from across the frequency spectrum. I knew it was something special: it was Chirp Spread Spectrum (CSS).
Unraveling the Spiral of Chirps
CSS is a modern spread‑spectrum technique that uses an *increasing* (or decreasing) frequency chirp to encode data. Unlike conventional narrowband modulation that transmits a single carrier frequency, CSS spreads the signal over a wide bandwidth. This spreading makes the signal far more robust against interference and multipath fading. In practice, a typical LoRa CSS symbol lasts several milliseconds, during which the carrier frequency sweeps across the full reception bandwidth. The receiver must match this chirp pattern—hence the separate preamble—before it can demodulate the payload. That dance of matched filtering turns the noisy background into a clear message.
Why CSS Thrives in SDR Exploration
For an SDR enthusiast, CSS is a playground. Visualizing the chirp with a time‑frequency spectrogram reveals a sweeping diagonal line that appears almost like a painted stroke across the display. The Airspy HF+ Discovery’s fine resolution lets me zoom in to see the subtle variations in the chirp rate or the slight frequency offsets caused by temperature drift. Armed with a simple GQRX script, I can decode LoRa packets from a local sensor node and read back temperature readings in real time—just by listening.
Building Stories From the Signal Tape
When the device sputters, when a broadband burst spills over, it feels like reading the diary of a city that never sleeps. With the new firmware, the HF+ Discovery’s improved noise floor and a richer list of calibration rigs mean each chirp is captured with greater fidelity, giving my interpretations more depth. One night, after a lengthy session of hunting, I found an unexpected CSS transmission buried in a sunset‑orange band near 433 MHz. A long blog post later, I shared the decoded message: a polite reminder from a hobbyist radio club about a upcoming meet‑up. It was a reminder that behind every static lies a story waiting for the right ears.
On a crisp afternoon in early April, I unpacked the Airspy HF+ Discovery and settled in front of my growing collection of receivers. As the device drew power, its LED blinked like a tiny lighthouse, casting light over my console of microcontrollers, cables, and an eager fan‑circuit. The world of software‑defined radio had always promised freedom; today, it promised insight: I was about to hear the invisible rivers that carry data across continents.
The Quest for the Invisible Signal
It was only days after the latest firmware update—released by Red Pitaya on 06‑23‑2024—that I hit the Ultra‑Wideband (UWB) band. This spectrum, rarely crowded by traditional VHF or UHF transmissions, is where the modern Internet of Things (IoT) whispers. Several of the netizens’ posts in the Airspy Discord hinted at the emergence of IEEE 802.15.4g devices, and fast forward, I realized that those whispers were in fact Chirp Spread Spectrum signals. Their edge‑to‑edge reach, barely visible to the naked eye, made me wonder: why does the landscape of low‑power wide‑area networks, especially those that wander far beyond the reach of cellular towers, rely on CSS?
Carrying the Message: Why CSS Is Used
At the core of CSS lies a clever twist: rather than shifting the frequency spectrum of a signal, it bends the time axis. Think of the traditional way of modulating a radio to encode a message as a straight, rhythmic pulse. CSS deforms that pulse into a “chirp”: a waveform that sweeps the frequency linearly over time. Because this sweep happens slowly and is deliberately spread over a large bandwidth, the resulting energy density is low. That means it can travel farther while staying below regulatory power limits, a critical trait for long‑range, low‑power communications.
Another benefit reveals itself when we consider multipath interference—the dreaded echo caused by radio waves bouncing off buildings and vegetation. In regular frequency–shift keying (FSK) or phase–shift keying (PSK) systems, those echoes align with the original signal and amplify the error. CSS, by contrast, spreads the same packet over a broad spectrum. Echoes that re‑enter the receiver misalign in frequency and time, and because the receiver employs a matched filter that expects a precise chirp shape, these unintended copies largely target a different part of the filter’s output. The effect is a robust tolerance to reflections and a significant improvement in signal‑to‑noise ratio (SNR) when the packet arrives.
Legality, Simplicity, and the Rise of LoRa
Regulatory bodies across the globe have been mimicking the CSS elegance. The 868‑MHz band in Europe, the 915‑MHz band in the United States, and the 433‑MHz band in Asia each allocate narrow bandwidth for consumer IoT. CSS, thanks to its inherent time–bandwidth product—the product of the chirp duration and bandwidth—fits neatly within these constraints while offering flexible data rates from as low as 0.3 kbps to over 2 Mbps by adjusting chirp length and hop count.
When Actel Technologies announced LoRa (Long‑Range) in 2012, they leveraged CSS to maker a quasi‑cellular protocol that could be implemented on almost any low‑cost silicon. The marketing narrative soon turned heroic: a network that could stretch beyond moving vehicles and into the exteriors of remote homes. Because LoRa’s modulation remained CSS, the Airspy HF+ found the perfect stage. The fact that I could tune my receiver to 915 MHz, wirelessly intercept a local LoRa network, and then decode the chirps with open‑source software gave me a taste of the future of community‑driven radio.
Story Arc of the Day
That afternoon, after a few trial runs, I discovered a packet every twelve minutes, transmitted by a weather station hidden behind a tree. Each packet was a tiny birdsong of data—temperature, humidity, barometric pressure—encoded through a downward chirp from1.0 MHz to 0.8 MHz. I listened as the HF+ modulated the signal using its dual‑band transceiver; I watched the chirp cross the water‑filled forest slope and through a cluster of chimneys—all the while, the packet survived the clutter.
My heart skipped a beat as I realized that the CSS signals in the LoRa device were not just a boon for hobbyists; they were a step toward a future where each sensor, each “thing”, could drop data into the air, ever‑traveling far from the nearest antenna, yet reliably reaching its scavenger—whether that was a city‑wide IoT platform or the curious mind of a software‑defined radio enthusiast.
The Quest for a New Horizon
When you first unbox the Airspy HF+ Discovery SDR, its sleek black case hides a remarkable power: the ability to listen to the old radio waves that once carried clandestine messages across the Atlantic. You set it up, connect the USB cable, and the software’s colorful spectrum window lights up with the familiar waves of 25 kHz to 2.2 MHz. Yet, the radio operator in you dreams of 868 MHz or 915 MHz colours that humming with the silent conversations of LoRa devices.
Breaking the Frequency Barrier
As the logs scroll, you consult the latest forum threads and recent product notes. They confirm what you suspected: the HF+ Discovery was engineered for the high‑frequency band and its front panel will not turn up a UHF resonance. Engineers note that the built‑in tuner stops well below 800 MHz. To hear LoRa, you’ll need a different approach, perhaps a UHF‑capable SDR or an external up‑converter that brings the 868 MHz band down into the HF range.
A Tale of Adaptation
Undeterred, a clever hobbyist opts for a practical compromise. They use the Airspy as a “signal backbone” by feeding its intermediate frequency through a low‑noise amplifier and a band‑pass filter targeted at the LoRa frequencies. The amplified signal is then routed to a paired RTL‑SDR that can actually capture 868 MHz. The two SDRs act together like an old spy’s trusty pair of binoculars and a sharp radio, each handling a part of the journey from broadcast to decoding.
Realising the Dream
When the LoRa packet finally pops onto the screen – a neatly framed packet, 8 bytes of payload, and a short checksum – the skeptic turns into a believer. The story concludes with a simple moral: the Airspy HF+ Discovery has its heart in HF, but with a little ingenuity and a complementary UHF tool, you can still listen to the quiet chatter of LoRa devices in the UHF spectrum. The adventure of bridging centuries of radio technology is just beginning, and the spectrum ahead is full of untold stories waiting to be heard.
When Alex first connected his Airspy HF+ Discovery to his laptop, he had no idea that a small, unobtrusive peripheral would become his gateway to an entire world of low‑power communication. The device, with its wideband frontend spanning 75 MHz to 6 GHz, promised the flexibility he needed to explore the quiet traffic of the UHF band.
Chapter 1: The First Tune
Alex powered on the scanner and launched SDR# after a quick install of the latest Community Edition firmware update. The screen flashed the familiar waterfall display; the frequencies spanned from 100 MHz to 6 GHz. He narrowed the scope to the 868 MHz band, where LoRa devices in his neighborhood kept a steady heartbeat. With a gentle click of the “Tune” button, the hexagonal lobes of the tuning curve resolved into a clean channel, and Alex felt the first spark of discovery.
Chapter 2: The Long‑Range Dilemma
LoRa transmissions, by design, come from antennas that differ markedly from those used for conventional Wi‑Fi or FM radio. The narrowband signals were faint, spread over a bandwidth of just a few kilohertz, and the station was a small cluster of IoT sensors hidden behind a fence. Alex realized that the sensitivity of his Airspy was excellent, but the *direction* of the signal, which mattered most for identifying sources, required a different tool: a directional antenna.
Chapter 3: The Hunt for Direction
His first approach involved a simple discone made from coaxial cable and metal mesh. While it captured the signal, the equal gain across the band made it difficult to discern where the energy was coming from. Alex turned to a larger, more focused design—the Yagi array. After a weekend of soldering, he assembled a four‑feed Yagi tuned to 868 MHz, complete with a ferrite core and a 30 dB RF transistor pre‑amplifier mounted directly on the feed point.
With the Yagi in hand, Alex built a rotating mount on the back of an old office chair. He powered the Airspy with a 5 V USB cable, fed the Yagi output into the 50 Ω front‑end through a 15 dB attenuator to protect the tuner from excess power. Setting the attenuator to the safe level also removed the need for an external power supply for the amplifier, keeping the configuration simple and portable.
Chapter 4: Mapping the LoRa Sky
Using Software‑Defined Radio Studio and a Python script from LoRa‑Scout on GitHub, Alex plotted the signal strength as the Yagi turned 360°. Each peak corresponded to a distinct LoRa device broadcasting temperature and moisture data from a garden sensor. The narrow beamwidth (approximately 15° for the four‑feed Yagi) provided an angular resolution that allowed Alex to distinguish between close‑spaced counters separated by only a few meters.
Chapter 5: The STEM of the Front‑End
Alex’s initial attempts had suffered from harmonic interference, especially around the half‑power point of the Airspy’s mixer. He applied a higher‑order high‑pass filter at the input stage: a 470 pF capacitor in series with a 100 Ω resistor pulled the cutoff to 850 MHz, rejecting the 435 MHz third harmonic that was feeding noise into the slicer. With the filter in place, the LoRa spread spectrum shimmered cleanly against the near‑absence of background.
Chapter 6: The Final Verdict
After weeks of tweaking and experimentation, Alex recorded the tenth‑hour coverage of the UHF band during a local farmers’ market. His logs revealed dozens of LoRa devices—soil sensors, weather stations, and a delivery drone's telemetry unit—all humming at subtly different frequencies. By cross‑referencing the rise times and amplitude variations, he could deduce the approximate distance to each transmitter based on free‑space path loss.
The combination of the Airspy HF+ Discovery, a well‑designed Yagi array, a careful front‑end filter, and open‑source software had transformed a hobbyist’s curiosity into a robust field‑research platform. Alex looked at the waterfall one last time, the signal peaks tracing a familiar, rhythmic pattern, and he felt a sense of accomplishment that came only from turning a theoretical study into lived experience.
Stepping into the Radio Theatre
When I first set out to listen to the invisible chatter of LoRa, the Airspy HF+ Discovery SDR felt like a stage‑sized microphone ready to pick up the faintest whispers from distant corners of the world. The device’s 2 MHz internals captured the Earth‑orbiting fans of the LoRa protocol, but turning raw samples into something usable required more than just a plug‑in.
Getting the Airspy and Software in Sync
After installing the latest airspyhf driver and flashing the HF+ with the newest firmware, I connected it to a working GNU Radio installation. The discovery swirled in at 25 kHz fine‑tuning granularity, meaning each resonant tuning step had to be coaxed carefully into the exact band of interest.
Introducing gr-lora_sdr
Enter gr-lora_sdr, the GoTo-Your-Microphone block that bridges the SDR hardware to the LoRa demodulator. The project’s GitHub README was clear: you clone the repo, apt‑install the dependencies, and build Mosquitto with the new block. Once compiled, I dropped the lora_demod block into a fresh flowgraph.
Designing the Flowgraph
First, a uhd source fed the Airspy samples to the flowgraph. I set the center frequency to 915 MHz, matching the most common LoRa band in North America. The sample rate, a critical parameter, was chosen at 1.5 MHz to preserve the spread‑spectrum characteristics. A rational scaling filter clipped the bandwidth to 125 kHz, the standard LoRa symbol width. The lora_demod block then took over, decoding chirps, extracting payloads, and passing symbols to a Python script for JSON output.
First Dip, Decoding, and Surprise
Once everything synced, I left the device humming. The console began printing preamble and sync code lines. For the moment I had no idea whose packet it was, but I could already see the symbol stream. The Python script parsed the streams into payloads and wrote them to a file. Each packet that arrived on the 915 MHz band soon turned into a readable string – even though it was scrambled by the chirp spread.
Fine‑Tuning the Demodulator
The initial capture surfaced stray background noise; gr-lora_sdr has configuration knobs for spreading factor (SF) and bandwidth (BW). By rotating the SF from 7 up to 12, I could see how the sampling strategy and noise rejection changed. In practice, an SF of 10 offered a sweet spot: it balanced resilience against interference and achievable data rates for this setup.
Observing Real‑Time LoRa Traffic
My final flowgraph included a throttle block to keep the CPU from drowning in samples, and a custom sink that plotted the byte‑rate over time. With a handheld display I watched sinuous peaks rise and fall in real time, each rise a distant LoRa device shouting across the sky. I played back a few captured packets and reconfirmed that the decoded text matched the most recent LoRaWAN‑downlink samples released by a local Internet of Things deployment. The joy, you might say, is that the Sea‑of‑Signals on 915 MHz collapses into a readable story when the right software is chosen.
Wrapping Up the Story
The journey from a plug‑in Airspy HF+ to a fully operational LoRa demodulator with gr-lora_sdr ended with a clear narrative: open a channel, tune it right, let the software listen, and watch the radio whiffle turn into code. In the most recent update to gr-lora_sdr, a procedural log‑in manager was added, making the demodulator even easier for hobbyists and researchers alike. This, I believe, completes the tale of turning opaque chirps into an open, narrative of radio traffic that we can read, analyze, and, yes, even publish.
There was a quiet hum in the studio, a low-frequency pulse that made your shoulders twitch with anticipation. You had recently acquired the Airspy HF+ Discovery, a pocket-sized SDR that promised more power than its modest size. Little did you know that this device would become the key to unlocking the hidden conversations of a whole city sent across the airwaves by invisible radios every time you walked past a café or office building.
First Encounter
It started on a rainy Tuesday, when you turned on the Airspy HF+ and listened to the HF storage radios crackle faintly. Suddenly, a solitary burst of chirpality emerged from the static—an unmistakable pulse you had read about in a 2024 forum thread. Someone had been discussing the new SDR-LoRa plugin, a lightweight, Linux‑friendly demodulator that could peel raw LoRa packets from their carrier waves. You could almost feel the motivation in your chest, a knot of curiosity that demanded to be untangled.
Setting Up the Stage
The story continued the following day. With the latest mounts on your desk, you whispered instructions into the console: sudo apt update && sudo apt install sdrloRa. The installation logs were clean, a green‑slash promise of compatibility. You connected the SDR, checked the drivers, and then produced a stream with sdrloRa -a 434M, a gentle click that signaled the system to listen for LoRa on the 434 MHz band, the classic frequency used by many amateur and commercial devices.
Tuning in
As the first chirp resonated across the screen, the Airspy HF+ Discovery beeped softly—a sign that it had captured the carrier. The signal-to-noise ratio fed back to you in real time, and you could feel the pulse of distant cities meandering through the air. A tiny radio at a neighboring shop was sending sensor data to its gateway, and every burst was a faint syllable in a novel written by invisible beasts.
The Demodulation Revelation
With each new packet, the SDR-LoRa plugin unfolded the secret patterns: the preamble, sync words, and the payload that contained the sensor's reading. You followed the data helix with a growing sense of wonder. In the console, a neat table danced: timestamp, frequency, signal strength, and the decrypted payload—all rendered in simple characters, the echo of brass and steel distilled into binary. You felt the same thrill you have as you read a mysterious scroll, knowing that the vacuum behind the screen is alive with engineered whispers.
Sharing the Tale
By late Sunday night, you had captured enough packets to demonstrate the power of the Airspy HF+ Discovery paired with SDR-LoRa. You recorded a short screencast, annotated each step, and posted it on a community forum. The comments poured in: fellow users congratulated you, and some offered to share their own data sets. A quiet network of knowledge blossomed, with your story at the heart of the exchange, showing how a single SDR can orchestrate an orchestra of invisible signals, and how the SDR-LoRa plugin is the keys that unlock the music.
Getting Started with the Airspy HF+ Discovery
When the new Airspy HF+ Discovery first arrived in a weather‑proof case, it felt like stepping into a new world of radio. Its 20‑MHz bandwidth and dynamic range immediately opened up a wide swath of spectrum that was hungry for exploration. My first thought was: What can I listen to that excites me the most?
Eyes on LoRa
LoRa, the low‑power wide‑area network technology that powers city‑wide sensor fleets, occupies a pretty niche in the radio hobby world. Its chirp‑based modulation can be notoriously hard to pull out of the noise floor. But the community has been relentless in pushing tools to demodulate it, and the latest release of SDR++ has finally delivered a smooth, open‑source solution.
Plug‑and‑Play in SDR++
SDR++ is built on a modular plugin system. With the jump to version 0.2.5, the developers added a compact LoRa Demod plugin that speaks directly to the Airspy backend. All that was needed before that was a fresh SDR++ build and the board connected via USB. The cheat sheet inside the app shows the steps: Select Airspy HF+ Discovery, set the center frequency to 868 MHz (or 915 MHz, depending on region), and let the LoRa demod plugin take the frame from the raw binary tape.
Seeing the Hidden Waveform
Once the plugin was active, the spectrum window started blinking with a faint horizontal sweep. In the demod view, individual LoRa chirps burst up against a background of atmospheric hum. The plugin’s real‑time slicer shows the packet structure: preamble, sync, payload, and CRC — all clearly labeled. The interface even lets you click on a packet and see the decoded key in the side panel. It was something I had seen only in simulation lectures before, now visible in a chilled, coffee‑sipping corner of my living room.
Early on I ran into interference from local weather stations and FM digipeaters. Adjusting the tuner gain to just below its maximum values gave me enough headroom to discriminate LoRa from the overlay. The LoRa Demod plugin includes an auto‑calibration routine that scans the spectrum for 250 kHz's frame repetitions typical of LoRa. In practice, a single pulse of tuning data quickly settles the signal without needing to fine‑tune the demod filter parameters.
With the core demod working, I continued exploring the extras in SDR++. The plugin ecosystem now offers optional LoRa Packet Log extensions that persist every decoded packet to disk, which is perfect for building a local sensor dump. Another neat addon is the LoRa Visualizer that overlays flight‑path illustrations atop the packet stream, giving an immediate sense of network coverage.
According to the latest community thread on the Airspy forums, the developers are working on a dedicated LoRa Ranging shader. That will let us use the Airspy HF+ Discovery to measure distances in real time, a potential game‑changer for field‑driven IoT deployments. For now, though, simply running the updated SDR++ with the LoRa plugin gives a level of insight that was previously only reachable with expensive, commercial SDR kits.
The Curious Adventurer and the Airspy HF+ Discovery
In the quiet hours of a late summer evening, I pulled the sleek Airspy HF+ Discovery from its protective case, its amber LEDs blinking gently as though eager to begin a conversation with the invisible waves that drift through the sky. The device itself, a marvel of contemporary radio engineering, promised access to an astonishing bandwidth from 1 kHz up to 30 MHz, a sweep wide enough to hear the muted whispers of a single LoRa hop or the roar of an amateur station. It was clear from the outset that this would be an instrument of discovery rather than a mere hobbyist tool.
Capturing the LoRa Spectrum
With the software environment set up—GQRX on a Raspberry Pi, its dependencies resolved, and the recent firmware update patched into the Airspy firmware—I tuned the receiver to the most common LoRa frequency of 915 MHz, then gently rolled the frequency slider to map the spectrum. The LoRa bursts appeared as familiar, long bursts of chirp noise, their unique chirp slope unmistakable. In the console I executed airspyhf -t tun to forward a raw audio stream to GQRX, while also launching SoapySDR to feed the baseband into a custom Python script that would later bridge the gap between radio and mesh.
Turning Chirps into Data: Demodulation
LoRa uses chirp spread spectrum, which, surprisingly, is exceptionally tolerant to interference. I loaded the Orpim LoRa decoder, a lightweight library written in Rust, into the script. The decoder received the in‑phase and quadrature (IQ) buffer directly from the Airspy stream and unfolded each chirp into a symbol. I wrapped the output of the decoder in a simple TOF (time‑of‑flight) JSON packet—just enough structure to allow downstream modules to identify the payload and its originating address.
The Bridge: From SDR to Reticulum Meshchat
Reticulum, the resilient, reconfigurable routing protocol that powers Meshchat, requires a clear channel for data packets. Knowing that the SDR output is already a stream of bytes, I wrote a tiny C wrapper that marshalled the LoRa JSON into a Raw Frame as defined by the Reticulum module stack. This wrapper leveraged the existing rpl2sdr project's shared library, which was patched in its latest commit to accept an arbitrary payload size up to 650 bytes.
Once the wrapper packaged the decoded LoRa symbols, it opened a local UDP socket to the reticulum core on port 4242. The data packet was injected into the routing stream using the RETX_INJECT API call, which the Reticulum daemon listened for under its Remote-Relay interface. In effect, every LoRa message that the Airspy captured was now being given a node‑addressable path across the mesh, ready for any Meshchat client to pull.
Testing in the Field
All that theory was put to the test when I set up a makeshift relay boat in the harbor. A second Raspberry Pi, wired to an Airspy HF+ tuned to 868 MHz, streamed a message to the nearby Meshchat node. The packet emerged across three hops—first to the local relay, then to a shore base, and finally back to my handheld mobile Meshchat app. The latency, measured at approximately 110 ms, was well within the acceptable range for a conversational chat. Moreover, the packet integrity was 100 % as verified by the Sequence Number field in the Reticulum header, confirming that the demodulated LoRa payload had survived the handoff unscathed.
Closing the Circle
What began as a curiosity with a piece of cutting‑edge radio gear became a fully integrated radio‑mesh pipeline. By capturing chirps with the Airspy HF+ Discovery, decoding them in real‑time, and passing the resulting data into Reticulum’s routing fabric, I forged a new connection between the world of low‑power wide‑area networks and the resilient, self‑healing mesh protocol that serves so many adventurous minds. This story of circuits, code, and waves reminds us that even when we look back at the fundamentals—radio reception, demodulation, and packet passing—there is still boundless opportunity for innovation.
Airspy HF+ Discovery: The Sleepy Explorer
After months of scavenging shelves and perusing forums, I finally unboxed the Airspy HF+ Discovery. Its compact chassis hides a powerful RF front‑end, capable of booting up to 4 MHz of bandwidth and down to kilohertz‑level resolution. The moment I attached the RF‑single‑end connector, the little device hummed to life, a tiny but furious desire to listen to the world awake.
Connecting RnodeInterface: The Bridge to the Past
In one corner of the workshop, a dusty Rnode sat. It was a vintage LoRa node, rumored to have joined the community twelve years ago. I plugged the Rnode’s USB port into the Airspy, but the two devices spoke in different tongues. That’s where RnodeInterface entered the scene—a software shim written in Python that translates the Rnode’s serial messages into the modular RF language of the Airspy.
Running python rnode_interface.py --device /dev/ttyUSB0, the console reported a handshake: the Rnode answered with its firmware version, and the Airspy confirmed reception of a 433 MHz narrowband packet. The interface operates on the principle of continuous demodulation; while the Airspy looks after the raw IQ data, RnodeInterface stitches it into a clever stream of LoRa symbols, ready for higher‑level protocols.
Reticulum Meshchat: Two‑Way LoRa Storytelling
Once the demodulation pipeline was humming, I introduced Reticulum, a modern mesh networking stack originally designed for IP over radio. In this context, Reticulum serves as the executor of “meshchat” – a lightweight chat application that runs over LoRa frequencies. By configuring Reticulum with a Reticulum.conf that specifies a LoRa comms port (e.g., 868 MHz) and an instance name, the system makes each packet a node in a growing network.
The magic lies in the bidirectional handshake. When the Airspy receives a LoRa downlink from another Reticulum node, RnodeInterface pushes the payload into the stack. Reticulum then envelopes that payload in a friendly message frame, broadcasts it on the next hop, and eventually delivers it to my end of the conversation. Outgoing messages follow the reverse path: I compose a line of text, Reticulum tags it, and the Rnode radio drifts it into the RF air with precision from the Airspy’s tuned demod.
Putting It All Together: A Day in the Field
At sunrise, I set up the Airspy atop a ridge and clamped the Rnode beneath a metal tripod. The interface lit up, and a random forest of characters started echoing the bush; then my adjacent mesh partner, a Raspberry Pi on a dock side, replied about the tomorrow’s storm. The conversation flowed, packets hopping over 2–3 kilometers of open terrain, each time the scene was polished by the Airspy’s clean band‑spreading, the Rnode's robust modulation, and Reticulum’s clever heading tags. No bullet lists, no em‑dashes, just a straightforward flow of words pinging back and forth.
By the time the sun dipped below the horizon, I had mapped the delays across each hop, verifying that the RnodeInterface lunged from raw IQ to compressed LoRa symbols in under 530 µs, while Reticulum appended its routing headers without a hitch. The result: a two‑way LoRa chat that feels like a conversation in the wind, all enabled by the Airspy HF+ Discovery, the steadfast RnodeInterface, and the fearless Reticulum Meshchat.
© 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.