When working on SDR (Software Defined Radio) projects, especially those involving trunked radio systems like P25, having access to live RF signals is often essential. But what if you want to prototype or develop your software without a working local system? That was the exact problem I faced while working on my MCH25 control head project for P25 radios.
The Problem: No Local P25, No Problem?
The MCH25 project required me to interact with and decode signals from a trunked P25 system. But I didn’t have a local system available for continuous development and testing. I needed a way to capture the raw IQ data from the times when I did have access, and play it back later—just as if it were coming live over the air.
Existing Solutions Fell Short
While tools like rtl_tcp let you stream IQ data from an RTL-SDR dongle over the network, none offered a seamless way to record these IQ streams (along with all control commands like frequency and gain) and then replay them in a way that SDR software could connect to just like a live dongle.
Enter RTL_TCP_ECHO
That’s why I built RTL_TCP_ECHO. It acts as a transparent proxy between your SDR software and the rtl_tcp server, passing through all control commands (frequency, gain, sample rate, etc.) while recording the IQ stream to disk. Later, you can run it in playback mode and serve that recording as a virtual rtl_tcp server—making your SDR software believe it’s listening to live RF.
Key Features
- Proxy Mode: Sits between your SDR software (like SDR#, Unitrunker, OP25, etc.) and your rtl_tcp server, forwarding all commands and IQ data, while recording IQ data to a file.
- Playback Mode: Serves the recorded IQ file as an rtl_tcp server so you can connect your SDR software and work as if you had a live signal.
- Transparent Command Support: All control commands are passed through, including gain adjustments—critical for trunked system decoding.
- Simple Workflow: Record once, playback as many times as you need. Perfect for development, debugging, and demonstrations.
How I Used It
With RTL_TCP_ECHO, I was able to record IQ data from a trunked P25 system when I had access. Then, back in my lab, I replayed those recordings over the network, allowing my SDR software and my MCH25 control head project to interact with the data as though the real P25 system was live. This made development and debugging possible without constant access to RF signals.
Getting Started
RTL_TCP_ECHO is written in Go and open source. You can find installation and usage instructions in the GitHub repository. Typical workflow:
- Record:
Connect your SDR client (e.g. Unitrunker, SDR#) to RTL_TCP_ECHO in proxy mode, which in turn connects to your rtl_tcp server. IQ data is recorded transparently. - Replay:
Run RTL_TCP_ECHO in playback mode and connect your SDR client to it. The recorded stream is served just like live IQ data.
Why This Matters
If you’re working on trunked radio decoding, protocol analysis, or building control heads like the MCH25, RTL_TCP_ECHO lets you develop and test your software anytime, not just when a live signal is available. This is a game changer for anyone building SDR tools for public safety or hobbyist trunked radio projects.
Check out RTL_TCP_ECHO on GitHub and let me know how you use it in your own SDR workflows!
Happy hacking,
Sarah Rose
SignalsEverywhere
Leave a Reply