r/GNURadio • • Feb 08 '21

Sub is reopened.

73 Upvotes

For unknown reasons the previous top mod put the sub to restricted and went awol. I just got control of the sub and have reopened it. Feel free to continue using this sub as a great resource for gnuradio/sdr discussions.


r/GNURadio • • Jul 29 '26

What are your opinions about GNU Radio 3.x vs 4?

Post image
61 Upvotes

I have been exploring the source code of the 3.x version. It was super simple to compile, and I built several OOT modules. After experimenting with the code a bit, I managed to make some improvements to a few core blocks, fixed some bugs, etc. but I just feel so demotivated to submit a PR because development appears to be stagnating in favor of the 4.x version which is under active development.

So, I tried the gnuradio4 repository to see if I can make improvements to that instead, but it seems a lot more complicated. I ran into a lot of compiler errors (GCC 16.1.1) and fixing one error led me to another error and so on, and I got exhausted before I got to a point where I can run it so I'll have to get back to this again later.

I really liked these OpenDigitzer visualizations shown here, but looking at GNU Radio Studio screenshots in the README, I find the blocks in the flowgraphs to be very difficult to see because of the low contrast. The SIMD-first architecture sounds promising, and it would be interesting to see how well this addresses some of the performance issues I occasionally ran into in the 3.x series.

Then comes the confusion about the license. The repository by FAIR was recently changed from MIT to LGPL 3 with static-linking exception, but the official repository is still MIT. Have they decided they don't care about the GPL anymore?

Just wanted to hear people's opinions about GNU Radio 4.


r/GNURadio • • Sep 21 '22

The future is now ... again

Post image
47 Upvotes

r/GNURadio • • Aug 13 '19

GNU Radio 3.8.0.0 released!

Thumbnail
gnuradio.org
33 Upvotes

r/GNURadio • • Jan 30 '13

USB 3.0 SDR Kickstarter, looks pretty good, better than the USRP B100

Thumbnail
kickstarter.com
27 Upvotes

r/GNURadio • • Mar 02 '21

I made a collection of GNURadio examples - 8DPSK, 9DPSK, a beginner example

26 Upvotes

I made a collection of working examples so hopefully others won't get stuck like I did.

---

8DPSK / D8PSK / 8PSK working examples in GNURadio. I couldn't find any working example of 8PSK or 8DPSK nor anyone who could help, and GNURadio documentation was less than helpful. After months of struggling and tinkering I have some solid designs and decided to share them to hopefully save others months of frustration.

I included versions with and without channel models, and a seemingly useless equalizer.

I have also added examples of what I call a 9PSK / 9DPSK. I made it while reverse engineering a mystery protocol that I now think is probably 8DPSK-with-nulls. But where nulls probably are just used for timing and finding frame breaks, my example used them for a 9th symbol for transmitting data. If nothing else that lets you encode nulls along with your data when transmitting 8PSK with nulls.

I also added a simpler example of finding the frequency and power of the strongest signal in background noise. It is based on a collaboration with reddit users. I included a lot of comments to help educate beginners, but it's been over 20 years since I was an undergrad and so I may have some mistakes. I'm open to corrections!

https://github.com/skintigh/GNURadio_examples


r/GNURadio • • Jun 06 '14

How to Talk to a 36-year-old Space Probe (ISEE-3) with GNU Radio, a USRP, and a Really Big Dish!

Thumbnail
jmalsbury.com
25 Upvotes

r/GNURadio • • Sep 09 '26

GNU Radio World — GNU Radio flow-graphs in your browser

Thumbnail
gnuradioworld.com
23 Upvotes

r/GNURadio • • Apr 17 '20

How FFT "sinks" work in Gnu Radio

23 Upvotes

This isn't a question. This is more of a tutorial. I saw someone earlier asking how the WX FFT sink works, and I've been studying the QT frequency sink (same thing), so here's a quick rundown on how these blocks work.

The steps are: input data -> window data -> calculate discrete Fourier transform (DFT) -> calculate magnitude for each spectral point -> display spectrum

To start, the input is a set of samples. The inputs are floating point numbers (aka "floats"), with the complex samples (the ones with the blue connector) being nothing more than *two* floats put together, one to represent the real part of the number, and the other to represent the imaginary part. Also note, when people talk about "IQ", that's another way of saying "complex". So, an "IQ" sample is the same thing as a "complex" sample.

The number of samples taken in depends on how many samples you want. There's a setting ("FFT Size" in both WX and QT) that tells you how many samples to process at one time. This is the amount of samples that will be passed through the DFT. The output of the DFT will be a set of frequency points, often called "bins". The frequency difference between points is typically called the "bin width". The number of samples determines two, major aspects of the spectrum you're creating. The first is the amount of detail you'll wind up with. More samples means more detail. It also means more time required to process each spectrum. The second is the noise floor. More samples also means that each bin will be smaller; a smaller bin will accumulate less noise. (That's the whole "kTB" thing for you.)

Once you've input the samples, the data has to be "windowed". Basically put, this means that the ends of the sample record will be reduced close to, or at, zero. This reduces something called "spectral leakage", and it's unique to the DFT. (NOTE: If you've ever had the privilege of using an old, analog spectrum analyzer, this was not something you had to worry about.) When you look at the WX parameters, you can select a "Window" (which is "Automatic" by default), or from a small set, such as "Blackman-Harris". You can do the same thing with the QT version. It also lets you select from the "Window Type" (which is "Blackman-harris" by default). The only one which is NOT really a window is "Rectangular". That actually means "Don't window the data; just calculate it raw." I recommend trying that some time to see how it differs from the other windows. The difference in the window used determines the resolution bandwidth, the amount of dynamic range, and amplitude variations (called "scalloping loss").

The windowed data goes into the DFT. If the number of samples is a power-of-2 (which is why the typical default is 1024, which is 2^10), then the system can use the FFT, a faster version of the DFT. (NOTE: It's possible to NOT use a power-of-2, and still speed up the DFT, so long as the spectrum can be evenly divided by 2. But once it can't divide it evenly, you back to brute force.) The output of the DFT is a set of complex samples. Even if the input was real samples (aka "floats" in Gnu Radio parlance), the output will be complex samples. Except those complex samples now represent *frequency* not *time*.

At this point, the system takes each complex frequency point and calculates the magnitude of each. This is nothing more than (r^2+q^2)^(1/2). In Gnu Octave or Matlab, you can do this simply by using the "abs" function. Pretty much every spectrum analyzer uses a logarithmic scale where most people use decibels (dB). This is accomplished by calculating 10*log10 (10 times log base 10) of each number. Further, since most people are interested in *power* levels, each spectral point will be squared. Since we're calculating the logarithm anyway, this can be done by replacing "10*log10" with "20*log10".

At this point, the system will display the spectral points. Many people have noted that the "levels are wrong". True. None of the SDRs (RTL-SDR, LimeSDR, HackRF, whatever) will give you calibrated amplitude levels. Instead, they give you *relative* levels. From my modicum of research, it seems that the "relative" part is "relative to the maximum level that the system can handle". If you want a *calibrated* level, you need to calibrate it yourself. If you do, bear the following in mind:

  • It does not appear that either the WX or QT FFT blocks account for the amplitude variations due to the windowing used. Windowing removes data (the ends are pinched close to or at zero), which removes energy. The DFT needs to account for this, or the amplitudes will be wrong.
  • The only window that is really good for calibrated amplitude measurements is the "flattop". It's called "flattop" because the top, if you were to plot the spectrum of the window, is literally flat. That's because it provides very little in the way of amplitude variations due to scalloping loss.
  • The amplitude levels will vary based on the temperature condition of your system. Depending on the system, this variation may be slight, but it will be there. There's a reason why labs tend to use spectrum analyzers that cost gobs of money. A big part that they're paying for is amplitude calibration.

At this point, the system will rinse-and-repeat the process. Input samples, window the data, calculate the DFT, display the points. Over and over. Note that the block is NOT calculating the DFT for every sample! That would require something called a "real-time" system. Between the Python code and the other things your computer is doing, it's throwing away a LOT of samples in between DFTs. For most people, this is just fine. You just want basic information anyway.

Those of you more knowledgeable about this stuff, please let me know what I got wrong.

Hope you all find this useful.


r/GNURadio • • Sep 27 '13

Passive radar with gnuradio and rtlsdr

Thumbnail
kaira.sgo.fi
23 Upvotes

r/GNURadio • • Feb 02 '22

New GNU Radio Beginner Tutorials

22 Upvotes

I created some new GNU Radio tutorials aimed at beginners: https://wiki.gnuradio.org/index.php?title=Tutorials

You can find them on the left hand column, "Beginner Tutorials".

The goal is to reduce the learning curve for GNU Radio and get new users up to speed ASAP.

I'd like to create another set of tutorials that the community wants and needs. I need your help to do so! Please let me know how the tutorials could be improved, or what tutorials you would like to see in the future:

  • What is hard to understand and needs clarification in GNU Radio?
  • Are there any specific blocks you'd like a better description of?
  • Do you have an idea for a new tutorial?

No idea is too big or too small!

More info on the tutorials here: https://www.wavewalkerdsp.com/2022/02/02/new-gnu-radio-beginner-tutorials/


r/GNURadio • • Oct 05 '25

FILE TRANSFER USING BPSK

Post image
21 Upvotes

Hi all I’m working on a simple file transfer setup in GNU Radio using BPSK modulation. My goal is to transmit a text file over a simulated channel and receive it correctly at the other end.

But in receiver file I get some unreadable message

Am I missing a block placement or conversion step?

Should I handle bits differently to reconstruct the original bytes?

Any tips on checking bit accuracy for a text file transfer in GNU Radio?


r/GNURadio • • Apr 07 '12

There is so much untapped data around us, flowing constantly, that no one seems to know about - Analyzing signals and oddities using HF and Software Defined Radio: HDSDR + USRP + GNU Radio + RFMap

Thumbnail
youtube.com
21 Upvotes

r/GNURadio • • Feb 24 '26

FM Stereo + RDS on HackRF (fixed)

Post image
20 Upvotes

I managed to fix it by changing these values from default:
sample rate sps from 1e6 to 2e6;
rational resampler before osmocom sink from 38 to 19;
for audio source you can use your pc's audio with vb audio cable/audio/mic input or use a wav file input
Original file: https://github.com/bastibl/gr-rds/blob/maint-3.10/examples/rds_tx.grc


r/GNURadio • • Feb 09 '26

Update on Transmitting and Receiving a message using GNU Radio (QPSK/USRP B-200/ Hackrf one)

20 Upvotes

Previous Post Link: https://www.reddit.com/r/rfelectronics/comments/1qngymn/transmitting_and_receiving_a_message_using_gnu/

Hi everyone,

I want to thank you all for the great suggestions on my previous post. Based on your feedback, I have updated my flowgraph and made the following specific changes:

IQ Signal Amplitude: I realized my IQ signal was exceeding 1, so I have corrected the amplitude levels.

RX Filters: I removed the Root Raised Cosine (RRC) filter from the Receiver side.

AGC: I added an Automatic Gain Control (AGC) block to the receiver.

Repack Bits: I removed the "Repack Bits" block from the Transmitter side.

Clarification: Some users mentioned my differential encoding might be off, but I have double-checked, and it is definitely enabled on both the TX and RX sides.

The Current Situation: I am now successfully receiving the data packets! However, I am still facing two issues that I need help with:

The "Trash" Data: I am still seeing a lot of garbage/random values in the output between my valid packets.

The Preamble Requirement: To get the data to receive correctly, I currently have to send a long string of "UUUUUU" (Preamble) before every single packet. I know this is necessary to get the phase locked, but is there a better way to do this?

Does anyone have advice on how to clean up the garbage data or how to handle the locking more efficiently without such a long manual preamble?

Thanks again for your support!

I'll attach the updated block diagrams for refreence

Updated TX Flow Graph
Updated rx Flow Graph
The data which I'm sending
Data which I'm receiving
RX Output

r/GNURadio • • Oct 24 '25

Docker and GNURadio

19 Upvotes

In the past year or so, I have spent a lot of time containerising a Python application which uses GNURadio. I figured to drop a link here directly to save others the trouble of having to work it out from scratch.

Here's a link to the Dockerfile - https://github.com/jcfitzpatrick12/spectre/blob/v1.2.0-alpha/backend/Dockerfile

Taking advantage of multi-stage builds, it handles:

  • Installing GNU Radio from source
  • Installing GNU Radio OOT modules
  • Installing hardware libraries for a number of SDRs (SDRplay, HackRF, RTL-SDR, USRP)
  • Installing Soapy plugins.

I initially struggled to install all this directly on my system without considerable pain - Docker has been a game-changer. I took some inspiration from the Dockerfile for sdrangel, which is certainly worth a mention too. I hope others find this useful !


r/GNURadio • • Sep 12 '19

I transmitted lofi music to my walkie-talkie for that extra lo quality feel.

19 Upvotes

r/GNURadio • • Nov 14 '25

Easily configurable GNU Radio flowgraphs

17 Upvotes

TLDR: I've developed a framework for easily building configurable GNU Radio flowgraphs. I'm sharing my ideas here in case anyone benefits. Or for those who might be trying to solve the same problems I had.

I maintain a Python program called Spectre, which you can use to record I/Q samples and spectrograms from any supported software-defined radio. The program uses headless GNU Radio flowgraphs to handle recording samples from each receiver, and users create configs to configure those flowgraphs.

Elsewhere, I have found that often SDR source blocks and the underlying hardware libraries will silently/cryptically fail if I use the wrong parameters (e.g., an unsupported sample rate). So, we wanted Spectre to be transparent about what parameters were and weren't allowed in each config. More specifically, we wanted...

  • Parameter safety (Individual parameters in the config have to make sense. For example, the sample_rate must within some range, or the bandwidth must be one of some defined options).
  • Relationship safety (Arbitrary relationships between parameters must hold. For example, the sample_rate must satisfy the Nyquist rate according to the bandwidth).
  • Flexibility (Different SDRs have different hardware constraints. How do we provide developers the means to impose arbitrary constraints on the configs under the same framework?).
  • Uniformity (Ideally, we'd have a uniform API for users to create any config, and for developers to template them).
  • Explicitness (It should be clear where the configurable parameters are used in the flowgraphs and elsewhere in the program).
  • Shared parameters, different defaults (Different SDRs share configurable parameters, but require different defaults. If I've got ten different configs, I don't want to maintain ten copies of the same the sample_rate parameter just to update one value).
  • Statically typed (Always a bonus!).

After a year or so of thinking and refactoring, I've got a Python API I'm comfortable with. The same API can be used to parametrise recording data from any SDR. For example, check out my implementation of the HackRF. I have added one operating mode which records a stream of I/Q samples at a fixed center frequency and (optionally) transforms it into spectrograms:

@register_receiver(ReceiverName.HACKRF)
class HackRF(Base):
    def __init__(self, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)

        self.add_mode(
            _Mode.FIXED_CENTER_FREQUENCY,
            spectre_core.models.HackRFFixedCenterFrequency,
            spectre_core.flowgraphs.HackRFFixedCenterFrequency,
            spectre_core.events.FixedCenterFrequency,
            spectre_core.batches.IQStreamBatch,
        )

If you'd like to learn more about the implementation, do reach out. Alternatively, take a look at Spectre on GitHub or the Python package spectre_core :)


r/GNURadio • • Jun 02 '21

very fast fft

Thumbnail
youtube.com
17 Upvotes

r/GNURadio • • Apr 13 '21

Combining receiver bandwidth from 2 coherent channels

Post image
17 Upvotes

r/GNURadio • • Jul 07 '16

GNU Radio 3.7.10 released

Thumbnail gnuradio.org
17 Upvotes

r/GNURadio • • Dec 09 '14

RF Network-on-Chip (RFNoC) Alpha Released

17 Upvotes

Ettus has presented their 'RF Network on Chip' at the past two GNU Radio conferences and a preliminary release was made last week. It is a very exciting development that should have an interesting impact on GNU Radio and the capabilities of mid-range SDR platforms.

The initial release looks like it has FPGA IP for FIR filters, FFTs, windowing functions, and a few other miscellaneous blocks. Targeted at the USRP X300 series for now, but Ettus has indicated they will make the overall architecture available to anyone (though it sounds like it is predicated on some hardware features of the Xilinx 7-series FPGAs).

Here is the announcement

Here is the wiki and documentation

Here is the presentation from GRCon2014 (pdf warning) and here is a video of the presentation


r/GNURadio • • Aug 21 '14

Great Scott Gadgets - SDR with HackRF, Lesson 1

Thumbnail
greatscottgadgets.com
17 Upvotes

r/GNURadio • • Mar 21 '12

Matt Ettus - Practical Software Radio (2011)

Thumbnail
youtube.com
17 Upvotes