Software Defined Radio - how does it work? Part 6

Hi, Habr.

In the previous part, we looked at the possibility of transmitting simple signals using GNU Radio. Now we will go further and see how to convey something more complicated. Let's start with the amateur radio signals WSPR, and then create a working software QAM modem.



And as in the previous case, we will do this without writing a single line of code, the program will also be cross-platform, and will be able to work both under OSX / Linux and under Windows. I will also show how to debug a modem using GNU Radio, without any hardware at all.

Continued under the cut.

For those who have not used GNU Radio, it is recommended to read parts 4 and 5 , which described the principles of working with the program.

Wspr

Let's start with a simpler one, with WSPR - this type of communication was specially made for propagation tests of weak signals, i.e. what we need is a power level of devices like LimeSDR no more than 100mW. The WSPR signal is transmitted at a very low speed (2 minutes per message of approximately 30 bytes) in a very narrow band, which allows it to be received even below the noise level. Transmit such a signal using GNU Radio.

First you need to record the signal. To do this, take the WSJT program, set all the necessary parameters (power, call sign, location, etc.). Specify Virtual Audio Cable as the output audio device in the settings, and record the signal in WAV. Pauses at the edges need to be cut off in any editor (for example, Cool Edit), as a result, we should get a file with a duration of about 2 minutes.

Now create a graph in the GNU Radio Companion.



This method does not claim to be maximum efficiency, but it is quite simple and straightforward. The WSPR signal is initially at a frequency of 1500 Hz, the recorded wav file has a sampling frequency of 22050 s / s. First, we resample the signal 57/5 times to bring the sampling frequency to the required 250.000 s / s. Then we shift the frequency up by 10KHz (the useful signal will be at the frequency of 11.5KHz), translate the signal into the complex form required by the receiver, and cut out the excess filter, leaving the frequencies 11-12KHz.

WSPR signals are time-bound and transmitted every even minute (0:00, 0:02, etc.). I started the transfer to GNU Radio manually, by eye, determining the interval by the hour, anyone who wants can add a script in Python to automatically start the transfer.

We are waiting for the right time, turn on the transmitter, receiver, and check the result.



If you wish, you can also add automatic generation of a WSPR file to the program based on input data (call sign, location, transmit power), examples of WSPR generation for Python can be taken on github.

It is interesting to note that at 432 MHz the frequency drift is already quite noticeable, although the signal is still decoded. But at a frequency of 1.3 GHz, the drift becomes so large that WSPR is no longer accepted - an external reference generator with a more stable signal is needed for SDR (or at least software frequency correction during transmission, although this is less convenient).

If the SDR allows you to transmit at low frequencies, then you can try transmission on the HF band. Thus, with HackRF, it was possible to transmit a signal at 1000 km at 14 MHz from a room antenna, which can be considered a good result. Although the high frequencies (433 MHz and 1.3 GHz) are perhaps even more interesting for experiments, the signals are transmitted only in direct line of sight, so for such experiments you need a second participant on the receiving side. The second plus of such tests is that only the lazy did not transmit to HF in wspr, but high frequencies are much less mastered. So, with boards like LimeSDR or USRP, you can carry out quite interesting experiments with reception and transmission at ultra-high frequencies.

QAM Modem

Let's go further. WSPR is a fairly simple format, let's do something more interesting - a full-fledged (well, almost) modem. With quadrature amplitude modulation, both the amplitude and phase of the signal simultaneously change, which allows data to be transmitted at a higher speed (but the occupied band is also larger).

Consider the first part - the transmitter.



As you can see, we read the data from the data.txt file, then with a sampling frequency of 25KHz we send data to the packet encoder, which converts the stream into a 4-bit code. This stream goes to the quadrature modulator, then the sampling frequency is increased to a transmitter frequency of 250KHz, and the signal is shifted upward by 80KHz (many receivers have a peak at zero frequency, and this will interfere). The Constellation Rect component sets the modulation parameters - the number of characters and the phase and amplitude shift.

The first part is ready. We start the “transfer” and see our signal.



We can test our transmitter without even having any equipment - for this there is a special Channel Model block - a communication channel model. There you can set the noise, frequency shift, etc.

This is what our signal looks like before and after the transmission. By the way, as you can see, all the "harmonics" of the transmitter below 120 dB have gone much lower than the noise level.



Now the reception. In fact, the same thing, only in reverse order.



Separately, you can stop at the last UDP Sink block. It is not clear why, but in GNU Radio there is no component for viewing text data. Therefore, we simply send data via UDP to any local port (I chose 999).

To receive, we write a simple program in Python.

import socket
UDP_IP = "127.0.0.1"
UDP_PORT = 999
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # UDP
sock.bind((UDP_IP, UDP_PORT))
sock.settimeout(1.0)
while True:
  try:
    data, addr = sock.recvfrom(64) # buffer size is 64 bytes
    print("Msg:", data)
  except socket.timeout:
   pass

Result: run the script, run GNU Radio, and see the received messages in the console.



As you can see, everything works, and you can not have either a receiver or antennas :)

For those who want to repeat the experiments, the project grc-file is under the spoiler. It should work on both Linux and Windows.


A good guide to creating a more sophisticated modem is on the GNU Radio website , but they use a custom block for demodulation, which was only launched under Linux. There is no problem with this in the above example.

Conclusion

As you can see, GNU Radio is a rather interesting program for working with signals in different ways, in which you can do many different interesting things. If the audience does not lose interest (there is a feeling that I delve into narrow topics that are of little interest to most), you can try to consider transmitting something more interesting, for example, a video.