Software Defined Radio - how does it work? Part 4

Hi, Habr.



In the third part, it was explained how to access the SDR receiver via the Python language. Now we will get acquainted with the program GNU Radio - a system that allows you to create a fairly complex radio configuration without writing a single line of code.





')

For example, consider the problem of parallel reception of several FM-stations on one receiver. As the receiver, we will use the same RTL SDR V3.



Continued under the cut.

Installation

To get started, GNU Radio must be installed, the distribution for Windows can be downloaded here . This system is cross-platform, there are also versions under Linux and under OSX (it seems that GNU Radio was successfully launched on Raspberry Pi, but I cannot give a 100% guarantee).



In fact, GNU Radio is a whole framework for digital signal processing, in which the program is “assembled” from separate modules. There are a large number of ready-made blocks, if you wish, you can also create your own. The modules themselves are written in C ++, and Python is used to communicate the blocks with each other. Those interested can look at the API in more detail , but in practice this is most likely not useful - all actions can be done visually in the GNU Radio Companion program.



The system is focused on processing data streams, so each block usually has an input and an output. Next, connecting the blocks in the editor, we get the finished system. The GNU Radio interface itself is fairly simple, the difficulty is in understanding what a block does. As mentioned earlier, low-level SDR work has a high entry threshold and requires some knowledge of DSP and math. But we will consider a simple task for which no special knowledge is required. So let's get started.

Beginning of work

We start GNU Radio Companion, create a new project, choose the project type WX GUI, add it to the screen and connect two blocks, as shown in the screenshot.







We see two types of blocks - Source (source) and Sink (output, “drain”). RTL-SDR is our receiver, FFT GUI is a virtual spectrum analyzer.



The Sample Rate variable is set to 2048000, this is the sampling rate of our receiver. The RTL-SDR frequency is left at the default of 100 MHz.



We start the project - everything works, we see the spectrum of FM stations. The first program for GNU Radio is ready!







If we look at the log, we will see such lines.



Generating: 'D: \\ MyProjects \\ GNURadio \\ top_block.py'

Executing: C: \ Python27 \ python.exe -u D: \ MyProjects \ GNURadio \ top_block.py



Yes, we can see the top_block.py file that the GNU Radio Companion generated for us. True Jedi can write directly in Python, but the required code, as we can see, is quite large. We created it in 1 minute.





However, if we remove the cumbersome initialization, we will see that there are not so many key lines of code.

 from gnuradio import gr from gnuradio.wxgui import fftsink2 import osmosdr class top_block(grc_wxgui.top_block_gui): def __init__(self): grc_wxgui.top_block_gui.__init__(self, title="Top Block") self.samp_rate = samp_rate = 2048000 self.wxgui_fftsink2_0 = fftsink2.fft_sink_c(...) self.Add(self.wxgui_fftsink2_0.win) self.rtlsdr_source_0 = osmosdr.source(args="numchan=" + str(1) + " " + '' ) self.connect((self.rtlsdr_source_0, 0), (self.wxgui_fftsink2_0, 0)) def main(top_block_cls=top_block, options=None): tb = top_block_cls() tb.Start(True) tb.Wait() 

So basically, you can write it manually. But the mouse is still faster. Although the ability to change the code can sometimes come in handy if you want to add some kind of non-standard logic.

We accept FM radio

Now try to take one of the stations. As was seen from the screenshots, the center frequency of the receiver is 100 MHz and the bandwidth is about 2 MHz. On the spectrum, we see two stations, at 100.1 MHz and 100.7 MHz, respectively.



The first step is to transfer the station spectrum to the center, now it is 100 KHz to the right. To do this, we recall the school cosine multiplication formula - as a result, there will be two frequencies, a sum and a difference - the desired station will move to the center, which is what we need (and then we will filter the excess).



We create two variables for storing the freq_center = 100000000 and freq_1 = 100100000 frequencies, and also add a signal generator with the freq_center frequency - freq_1.







Because Since the system is based on Python, we can use expressions in the parameter input fields, which is quite convenient.



The scheme in the end should look like this:







Now you need to add several blocks at once - reduce the clock frequency of the input signal (it is equal to 2048 KHz), filter the signal, feed it to the FM decoder, then again reduce the clock frequency to 48 KHz.



The result is shown in the picture:







We consider carefully. We divide the clock frequency of 2048 KHz by 4 times with the Rational Resampler unit (we get 512 KHz), then after the Low Pass filter we have a WBFM decoder with decimation 10 (we get 51.2 KHz). In principle, this signal can already be sent to the sound card, but the pitch will be slightly different. Once again, we change the clock frequency to 48/51, as a result, the clock frequency will be 48.2KHz, the difference can already be neglected.



The second important point is the type of inputs. The receiver receives a complex IQ signal (inputs-outputs are blue), a real signal comes out of the FM decoder - inputs and outputs are yellow. If confused, it will not work. More was already on Habré , it is enough for us to understand the general principle.



In general, we start, we are convinced that everything works. You can run the program and listen to the radio. We will go further - we still have Software Defined radio - we will add simultaneous reception of the second station.

Multi-channel reception

The second receiver is added by a favorite programmer method - Ctrl + C / Ctrl + V. Add the freq_2 variable, copy the blocks and connect them in the same way.







The result is quite surreal - you can listen to two FM stations simultaneously. By the same method (Ctrl + V) you can add a third station.

Record

Listening to two stations is original, but in practice it is of little use. Let's do something more necessary, for example, add a sound recording to separate files. This can be quite convenient - several channels can be recorded in parallel from one physical receiver.



Add a File Sink component to each output, as shown in the screenshot.







For some reason, the Windows version requires absolute file paths, otherwise the recording does not work. We start, we are convinced that everything is normal. The size of the saved files is quite large, because The default format is float. Record in int format leave readers as homework.



The resulting files can be opened in Cool Edit and make sure that the sound is recorded normally.











Of course, the number of recorded channels can be increased, it is limited only by the receiver bandwidth and computer power. In addition to File Sink, you can also use UDP Sink, so the program can be used for broadcasting over the network.

Run from the command line

And the last. If you use the program offline, for example for multichannel recording, the UI is not needed in principle. In the upper left Options block, change the Run Options parameter to No UI. Run the program again, make sure everything works. Now save the generated file top_block.py - we can simply run it from the command line, for example from a bat-file or from the console.







If anyone is interested, the generated file is saved under the spoiler.



Conveniently, the system is cross-platform, and the resulting program can run on Linux, Windows and OSX.

Conclusion

We can say that GNU Radio is a rather complicated system, not in terms of drawing blocks, of course, but in terms of understanding how it all works. But some simple things to do quite feasible and interesting. GNU Radio is also convenient to use as a “virtual lab” for learning - you can connect a virtual oscilloscope or a spectrum analyzer to any part of the circuit and see what the signal looks like.



If there are no individual wishes, the topic of the SDR reception can probably be closed - all the main points have already been considered, and the number of views from the first to the third part falls almost exponentially (although you can still write about the program, but it requires more expensive " gland "for tests than RTL SDR). I hope, nevertheless, that some understanding of how this works, the readers have left. Well, all successful experiments.